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 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"
46 #include "tree-mudflap.h"
48 #include "tree-inline.h"
49 #include "c-family/c-pragma.h"
50 #include "tree-dump.h"
53 #include "pointer-set.h"
54 #include "splay-tree.h"
55 #include "langhooks.h"
56 #include "c-family/c-ada-spec.h"
58 extern cpp_reader *parse_in;
60 /* This structure contains information about the initializations
61 and/or destructions required for a particular priority level. */
62 typedef struct priority_info_s {
63 /* Nonzero if there have been any initializations at this priority
64 throughout the translation unit. */
65 int initializations_p;
66 /* Nonzero if there have been any destructions at this priority
67 throughout the translation unit. */
71 static void mark_vtable_entries (tree);
72 static bool maybe_emit_vtables (tree);
73 static bool acceptable_java_type (tree);
74 static tree start_objects (int, int);
75 static void finish_objects (int, int, tree);
76 static tree start_static_storage_duration_function (unsigned);
77 static void finish_static_storage_duration_function (tree);
78 static priority_info get_priority_info (int);
79 static void do_static_initialization_or_destruction (tree, bool);
80 static void one_static_initialization_or_destruction (tree, tree, bool);
81 static void generate_ctor_or_dtor_function (bool, int, location_t *);
82 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
84 static tree prune_vars_needing_no_initialization (tree *);
85 static void write_out_vars (tree);
86 static void import_export_class (tree);
87 static tree get_guard_bits (tree);
88 static void determine_visibility_from_class (tree, tree);
89 static bool determine_hidden_inline (tree);
90 static bool decl_defined_p (tree);
92 /* A list of static class variables. This is needed, because a
93 static class variable can be declared inside the class without
94 an initializer, and then initialized, statically, outside the class. */
95 static GTY(()) VEC(tree,gc) *pending_statics;
97 /* A list of functions which were declared inline, but which we
98 may need to emit outline anyway. */
99 static GTY(()) VEC(tree,gc) *deferred_fns;
101 /* A list of decls that use types with no linkage, which we need to make
103 static GTY(()) VEC(tree,gc) *no_linkage_decls;
105 /* Nonzero if we're done parsing and into end-of-file activities. */
111 /* Return a member function type (a METHOD_TYPE), given FNTYPE (a
112 FUNCTION_TYPE), CTYPE (class type), and QUALS (the cv-qualifiers
113 that apply to the function). */
116 build_memfn_type (tree fntype, tree ctype, cp_cv_quals quals)
122 if (fntype == error_mark_node || ctype == error_mark_node)
123 return error_mark_node;
125 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
126 || TREE_CODE (fntype) == METHOD_TYPE);
128 type_quals = quals & ~TYPE_QUAL_RESTRICT;
129 ctype = cp_build_qualified_type (ctype, type_quals);
130 raises = TYPE_RAISES_EXCEPTIONS (fntype);
131 attrs = TYPE_ATTRIBUTES (fntype);
132 fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
133 (TREE_CODE (fntype) == METHOD_TYPE
134 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
135 : TYPE_ARG_TYPES (fntype)));
137 fntype = build_exception_variant (fntype, raises);
139 fntype = cp_build_type_attribute_variant (fntype, attrs);
144 /* Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
145 return type changed to NEW_RET. */
148 change_return_type (tree new_ret, tree fntype)
151 tree args = TYPE_ARG_TYPES (fntype);
152 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
153 tree attrs = TYPE_ATTRIBUTES (fntype);
155 if (same_type_p (new_ret, TREE_TYPE (fntype)))
158 if (TREE_CODE (fntype) == FUNCTION_TYPE)
160 newtype = build_function_type (new_ret, args);
161 newtype = apply_memfn_quals (newtype, type_memfn_quals (fntype));
164 newtype = build_method_type_directly
165 (class_of_this_parm (fntype), new_ret, TREE_CHAIN (args));
167 newtype = build_exception_variant (newtype, raises);
169 newtype = cp_build_type_attribute_variant (newtype, attrs);
174 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
178 cp_build_parm_decl (tree name, tree type)
180 tree parm = build_decl (input_location,
181 PARM_DECL, name, type);
182 /* DECL_ARG_TYPE is only used by the back end and the back end never
184 if (!processing_template_decl)
185 DECL_ARG_TYPE (parm) = type_passed_as (type);
187 /* If the type is a pack expansion, then we have a function
189 if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION)
190 FUNCTION_PARAMETER_PACK_P (parm) = 1;
195 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
199 build_artificial_parm (tree name, tree type)
201 tree parm = cp_build_parm_decl (name, type);
202 DECL_ARTIFICIAL (parm) = 1;
203 /* All our artificial parms are implicitly `const'; they cannot be
205 TREE_READONLY (parm) = 1;
209 /* Constructors for types with virtual baseclasses need an "in-charge" flag
210 saying whether this constructor is responsible for initialization of
211 virtual baseclasses or not. All destructors also need this "in-charge"
212 flag, which additionally determines whether or not the destructor should
213 free the memory for the object.
215 This function adds the "in-charge" flag to member function FN if
216 appropriate. It is called from grokclassfn and tsubst.
217 FN must be either a constructor or destructor.
219 The in-charge flag follows the 'this' parameter, and is followed by the
220 VTT parm (if any), then the user-written parms. */
223 maybe_retrofit_in_chrg (tree fn)
225 tree basetype, arg_types, parms, parm, fntype;
227 /* If we've already add the in-charge parameter don't do it again. */
228 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
231 /* When processing templates we can't know, in general, whether or
232 not we're going to have virtual baseclasses. */
233 if (processing_template_decl)
236 /* We don't need an in-charge parameter for constructors that don't
237 have virtual bases. */
238 if (DECL_CONSTRUCTOR_P (fn)
239 && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
242 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
243 basetype = TREE_TYPE (TREE_VALUE (arg_types));
244 arg_types = TREE_CHAIN (arg_types);
246 parms = DECL_CHAIN (DECL_ARGUMENTS (fn));
248 /* If this is a subobject constructor or destructor, our caller will
249 pass us a pointer to our VTT. */
250 if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
252 parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
254 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */
255 DECL_CHAIN (parm) = parms;
258 /* ...and then to TYPE_ARG_TYPES. */
259 arg_types = hash_tree_chain (vtt_parm_type, arg_types);
261 DECL_HAS_VTT_PARM_P (fn) = 1;
264 /* Then add the in-charge parm (before the VTT parm). */
265 parm = build_artificial_parm (in_charge_identifier, integer_type_node);
266 DECL_CHAIN (parm) = parms;
268 arg_types = hash_tree_chain (integer_type_node, arg_types);
270 /* Insert our new parameter(s) into the list. */
271 DECL_CHAIN (DECL_ARGUMENTS (fn)) = parms;
273 /* And rebuild the function type. */
274 fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
276 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
277 fntype = build_exception_variant (fntype,
278 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
279 if (TYPE_ATTRIBUTES (TREE_TYPE (fn)))
280 fntype = (cp_build_type_attribute_variant
281 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn))));
282 TREE_TYPE (fn) = fntype;
284 /* Now we've got the in-charge parameter. */
285 DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
288 /* Classes overload their constituent function names automatically.
289 When a function name is declared in a record structure,
290 its name is changed to it overloaded name. Since names for
291 constructors and destructors can conflict, we place a leading
294 CNAME is the name of the class we are grokking for.
296 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
298 FLAGS contains bits saying what's special about today's
299 arguments. DTOR_FLAG == DESTRUCTOR.
301 If FUNCTION is a destructor, then we must add the `auto-delete' field
302 as a second parameter. There is some hair associated with the fact
303 that we must "declare" this variable in the manner consistent with the
304 way the rest of the arguments were declared.
306 QUALS are the qualifiers for the this pointer. */
309 grokclassfn (tree ctype, tree function, enum overload_flags flags)
311 tree fn_name = DECL_NAME (function);
313 /* Even within an `extern "C"' block, members get C++ linkage. See
314 [dcl.link] for details. */
315 SET_DECL_LANGUAGE (function, lang_cplusplus);
317 if (fn_name == NULL_TREE)
319 error ("name missing for member function");
320 fn_name = get_identifier ("<anonymous>");
321 DECL_NAME (function) = fn_name;
324 DECL_CONTEXT (function) = ctype;
326 if (flags == DTOR_FLAG)
327 DECL_DESTRUCTOR_P (function) = 1;
329 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
330 maybe_retrofit_in_chrg (function);
333 /* Create an ARRAY_REF, checking for the user doing things backwards
337 grok_array_decl (tree array_expr, tree index_exp)
341 tree orig_array_expr = array_expr;
342 tree orig_index_exp = index_exp;
344 if (error_operand_p (array_expr) || error_operand_p (index_exp))
345 return error_mark_node;
347 if (processing_template_decl)
349 if (type_dependent_expression_p (array_expr)
350 || type_dependent_expression_p (index_exp))
351 return build_min_nt (ARRAY_REF, array_expr, index_exp,
352 NULL_TREE, NULL_TREE);
353 array_expr = build_non_dependent_expr (array_expr);
354 index_exp = build_non_dependent_expr (index_exp);
357 type = TREE_TYPE (array_expr);
359 type = non_reference (type);
361 /* If they have an `operator[]', use that. */
362 if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp)))
363 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
364 array_expr, index_exp, NULL_TREE,
365 /*overload=*/NULL, tf_warning_or_error);
370 /* Otherwise, create an ARRAY_REF for a pointer or array type.
371 It is a little-known fact that, if `a' is an array and `i' is
372 an int, you can write `i[a]', which means the same thing as
374 if (TREE_CODE (type) == ARRAY_TYPE)
377 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
379 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
382 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
384 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
386 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
389 if ((p1 && i2) && (i1 && p2))
390 error ("ambiguous conversion for array subscript");
393 array_expr = p1, index_exp = i2;
395 array_expr = p2, index_exp = i1;
398 error ("invalid types %<%T[%T]%> for array subscript",
399 type, TREE_TYPE (index_exp));
400 return error_mark_node;
403 if (array_expr == error_mark_node || index_exp == error_mark_node)
404 error ("ambiguous conversion for array subscript");
406 expr = build_array_ref (input_location, array_expr, index_exp);
408 if (processing_template_decl && expr != error_mark_node)
409 return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
410 NULL_TREE, NULL_TREE);
414 /* Given the cast expression EXP, checking out its validity. Either return
415 an error_mark_node if there was an unavoidable error, return a cast to
416 void for trying to delete a pointer w/ the value 0, or return the
417 call to delete. If DOING_VEC is true, we handle things differently
418 for doing an array delete.
419 Implements ARM $5.3.4. This is called from the parser. */
422 delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete,
423 tsubst_flags_t complain)
427 if (exp == error_mark_node)
430 if (processing_template_decl)
432 t = build_min (DELETE_EXPR, void_type_node, exp, size);
433 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
434 DELETE_EXPR_USE_VEC (t) = doing_vec;
435 TREE_SIDE_EFFECTS (t) = 1;
439 /* An array can't have been allocated by new, so complain. */
440 if (TREE_CODE (exp) == VAR_DECL
441 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
442 warning (0, "deleting array %q#D", exp);
444 t = build_expr_type_conversion (WANT_POINTER, exp, true);
446 if (t == NULL_TREE || t == error_mark_node)
448 error ("type %q#T argument given to %<delete%>, expected pointer",
450 return error_mark_node;
453 type = TREE_TYPE (t);
455 /* As of Valley Forge, you can delete a pointer to const. */
457 /* You can't delete functions. */
458 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
460 error ("cannot delete a function. Only pointer-to-objects are "
461 "valid arguments to %<delete%>");
462 return error_mark_node;
465 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */
466 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
468 warning (0, "deleting %qT is undefined", type);
472 /* Deleting a pointer with the value zero is valid and has no effect. */
473 if (integer_zerop (t))
474 return build1 (NOP_EXPR, void_type_node, t);
477 return build_vec_delete (t, /*maxindex=*/NULL_TREE,
478 sfk_deleting_destructor,
479 use_global_delete, complain);
481 return build_delete (type, t, sfk_deleting_destructor,
482 LOOKUP_NORMAL, use_global_delete,
486 /* Report an error if the indicated template declaration is not the
487 sort of thing that should be a member template. */
490 check_member_template (tree tmpl)
494 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
495 decl = DECL_TEMPLATE_RESULT (tmpl);
497 if (TREE_CODE (decl) == FUNCTION_DECL
498 || DECL_ALIAS_TEMPLATE_P (tmpl)
499 || (TREE_CODE (decl) == TYPE_DECL
500 && MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))))
502 /* The parser rejects template declarations in local classes. */
503 gcc_assert (!current_function_decl);
504 /* The parser rejects any use of virtual in a function template. */
505 gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
506 && DECL_VIRTUAL_P (decl)));
508 /* The debug-information generating code doesn't know what to do
509 with member templates. */
510 DECL_IGNORED_P (tmpl) = 1;
513 error ("template declaration of %q#D", decl);
516 /* Return true iff TYPE is a valid Java parameter or return type. */
519 acceptable_java_type (tree type)
521 if (type == error_mark_node)
524 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
526 if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
528 type = TREE_TYPE (type);
529 if (TREE_CODE (type) == RECORD_TYPE)
532 if (! TYPE_FOR_JAVA (type))
534 if (! CLASSTYPE_TEMPLATE_INFO (type))
536 args = CLASSTYPE_TI_ARGS (type);
537 i = TREE_VEC_LENGTH (args);
540 type = TREE_VEC_ELT (args, i);
541 if (TREE_CODE (type) == POINTER_TYPE)
542 type = TREE_TYPE (type);
543 if (! TYPE_FOR_JAVA (type))
552 /* For a METHOD in a Java class CTYPE, return true if
553 the parameter and return types are valid Java types.
554 Otherwise, print appropriate error messages, and return false. */
557 check_java_method (tree method)
560 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
561 tree ret_type = TREE_TYPE (TREE_TYPE (method));
563 if (!acceptable_java_type (ret_type))
565 error ("Java method %qD has non-Java return type %qT",
570 arg_types = TREE_CHAIN (arg_types);
571 if (DECL_HAS_IN_CHARGE_PARM_P (method))
572 arg_types = TREE_CHAIN (arg_types);
573 if (DECL_HAS_VTT_PARM_P (method))
574 arg_types = TREE_CHAIN (arg_types);
576 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
578 tree type = TREE_VALUE (arg_types);
579 if (!acceptable_java_type (type))
581 if (type != error_mark_node)
582 error ("Java method %qD has non-Java parameter type %qT",
590 /* Sanity check: report error if this function FUNCTION is not
591 really a member of the class (CTYPE) it is supposed to belong to.
592 TEMPLATE_PARMS is used to specify the template parameters of a member
593 template passed as FUNCTION_DECL. If the member template is passed as a
594 TEMPLATE_DECL, it can be NULL since the parameters can be extracted
595 from the declaration. If the function is not a function template, it
597 It returns the original declaration for the function, NULL_TREE if
598 no declaration was found, error_mark_node if an error was emitted. */
601 check_classfn (tree ctype, tree function, tree template_parms)
607 if (DECL_USE_TEMPLATE (function)
608 && !(TREE_CODE (function) == TEMPLATE_DECL
609 && DECL_TEMPLATE_SPECIALIZATION (function))
610 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
611 /* Since this is a specialization of a member template,
612 we're not going to find the declaration in the class.
615 struct S { template <typename T> void f(T); };
616 template <> void S::f(int);
618 we're not going to find `S::f(int)', but there's no
619 reason we should, either. We let our callers know we didn't
620 find the method, but we don't complain. */
623 /* Basic sanity check: for a template function, the template parameters
624 either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
625 if (TREE_CODE (function) == TEMPLATE_DECL)
628 && !comp_template_parms (template_parms,
629 DECL_TEMPLATE_PARMS (function)))
631 error ("template parameter lists provided don%'t match the "
632 "template parameters of %qD", function);
633 return error_mark_node;
635 template_parms = DECL_TEMPLATE_PARMS (function);
638 /* OK, is this a definition of a member template? */
639 is_template = (template_parms != NULL_TREE);
641 /* We must enter the scope here, because conversion operators are
642 named by target type, and type equivalence relies on typenames
643 resolving within the scope of CTYPE. */
644 pushed_scope = push_scope (ctype);
645 ix = class_method_index_for_fn (complete_type (ctype), function);
648 VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
649 tree fndecls, fndecl = 0;
651 const char *format = NULL;
653 for (fndecls = VEC_index (tree, methods, ix);
654 fndecls; fndecls = OVL_NEXT (fndecls))
658 fndecl = OVL_CURRENT (fndecls);
659 p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
660 p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
662 /* We cannot simply call decls_match because this doesn't
663 work for static member functions that are pretending to
664 be methods, and because the name may have been changed by
667 /* Get rid of the this parameter on functions that become
669 if (DECL_STATIC_FUNCTION_P (fndecl)
670 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
671 p1 = TREE_CHAIN (p1);
673 /* A member template definition only matches a member template
675 if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
678 if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
679 TREE_TYPE (TREE_TYPE (fndecl)))
680 && compparms (p1, p2)
682 || comp_template_parms (template_parms,
683 DECL_TEMPLATE_PARMS (fndecl)))
684 && (DECL_TEMPLATE_SPECIALIZATION (function)
685 == DECL_TEMPLATE_SPECIALIZATION (fndecl))
686 && (!DECL_TEMPLATE_SPECIALIZATION (function)
687 || (DECL_TI_TEMPLATE (function)
688 == DECL_TI_TEMPLATE (fndecl))))
694 pop_scope (pushed_scope);
695 return OVL_CURRENT (fndecls);
698 error_at (DECL_SOURCE_LOCATION (function),
699 "prototype for %q#D does not match any in class %qT",
701 is_conv_op = DECL_CONV_FN_P (fndecl);
704 ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
705 fndecls = VEC_index (tree, methods, ix);
708 fndecl = OVL_CURRENT (fndecls);
709 fndecls = OVL_NEXT (fndecls);
711 if (!fndecls && is_conv_op)
713 if (VEC_length (tree, methods) > (size_t) ++ix)
715 fndecls = VEC_index (tree, methods, ix);
716 if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
728 format = N_("candidates are: %+#D");
730 format = N_("candidate is: %+#D");
731 error (format, fndecl);
734 else if (!COMPLETE_TYPE_P (ctype))
735 cxx_incomplete_type_error (function, ctype);
737 error ("no %q#D member function declared in class %qT",
741 pop_scope (pushed_scope);
742 return error_mark_node;
745 /* DECL is a function with vague linkage. Remember it so that at the
746 end of the translation unit we can decide whether or not to emit
750 note_vague_linkage_fn (tree decl)
752 DECL_DEFER_OUTPUT (decl) = 1;
753 VEC_safe_push (tree, gc, deferred_fns, decl);
756 /* We have just processed the DECL, which is a static data member.
757 The other parameters are as for cp_finish_decl. */
760 finish_static_data_member_decl (tree decl,
761 tree init, bool init_const_expr_p,
765 DECL_CONTEXT (decl) = current_class_type;
767 /* We cannot call pushdecl here, because that would fill in the
768 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
769 the right thing, namely, to put this decl out straight away. */
771 if (! processing_template_decl)
772 VEC_safe_push (tree, gc, pending_statics, decl);
774 if (LOCAL_CLASS_P (current_class_type))
775 permerror (input_location, "local class %q#T shall not have static data member %q#D",
776 current_class_type, decl);
778 DECL_IN_AGGR_P (decl) = 1;
780 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
781 && TYPE_DOMAIN (TREE_TYPE (decl)) == NULL_TREE)
782 SET_VAR_HAD_UNKNOWN_BOUND (decl);
784 cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags);
787 /* DECLARATOR and DECLSPECS correspond to a class member. The other
788 parameters are as for cp_finish_decl. Return the DECL for the
789 class member declared. */
792 grokfield (const cp_declarator *declarator,
793 cp_decl_specifier_seq *declspecs,
794 tree init, bool init_const_expr_p,
799 const char *asmspec = 0;
804 && TREE_CODE (init) == TREE_LIST
805 && TREE_VALUE (init) == error_mark_node
806 && TREE_CHAIN (init) == NULL_TREE)
809 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
810 if (! value || error_operand_p (value))
811 /* friend or constructor went bad. */
812 return error_mark_node;
814 if (TREE_CODE (value) == TYPE_DECL && init)
816 error ("typedef %qD is initialized (use decltype instead)", value);
820 /* Pass friendly classes back. */
821 if (value == void_type_node)
824 /* Pass friend decls back. */
825 if ((TREE_CODE (value) == FUNCTION_DECL
826 || TREE_CODE (value) == TEMPLATE_DECL)
827 && DECL_CONTEXT (value) != current_class_type)
830 name = DECL_NAME (value);
832 if (name != NULL_TREE)
834 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
836 error ("explicit template argument list not allowed");
837 return error_mark_node;
840 if (IDENTIFIER_POINTER (name)[0] == '_'
841 && ! strcmp (IDENTIFIER_POINTER (name), "_vptr"))
842 error ("member %qD conflicts with virtual function table field name",
846 /* Stash away type declarations. */
847 if (TREE_CODE (value) == TYPE_DECL)
849 DECL_NONLOCAL (value) = 1;
850 DECL_CONTEXT (value) = current_class_type;
856 /* If this is a typedef that names the class for linkage purposes
857 (7.1.3p8), apply any attributes directly to the type. */
858 if (TAGGED_TYPE_P (TREE_TYPE (value))
859 && value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
860 attrflags = ATTR_FLAG_TYPE_IN_PLACE;
862 cplus_decl_attributes (&value, attrlist, attrflags);
865 if (declspecs->specs[(int)ds_typedef]
866 && TREE_TYPE (value) != error_mark_node
867 && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
868 set_underlying_type (value);
870 /* It's important that push_template_decl below follows
871 set_underlying_type above so that the created template
872 carries the properly set type of VALUE. */
873 if (processing_template_decl)
874 value = push_template_decl (value);
876 record_locally_defined_typedef (value);
880 if (DECL_IN_AGGR_P (value))
882 error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
883 return void_type_node;
886 if (asmspec_tree && asmspec_tree != error_mark_node)
887 asmspec = TREE_STRING_POINTER (asmspec_tree);
891 if (TREE_CODE (value) == FUNCTION_DECL)
893 /* Initializers for functions are rejected early in the parser.
894 If we get here, it must be a pure specifier for a method. */
895 if (init == ridpointers[(int)RID_DELETE])
897 DECL_DELETED_FN (value) = 1;
898 DECL_DECLARED_INLINE_P (value) = 1;
899 DECL_INITIAL (value) = error_mark_node;
901 else if (init == ridpointers[(int)RID_DEFAULT])
903 if (defaultable_fn_check (value))
905 DECL_DEFAULTED_FN (value) = 1;
906 DECL_INITIALIZED_IN_CLASS_P (value) = 1;
907 DECL_DECLARED_INLINE_P (value) = 1;
910 else if (TREE_CODE (init) == DEFAULT_ARG)
911 error ("invalid initializer for member function %qD", value);
912 else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
914 if (integer_zerop (init))
915 DECL_PURE_VIRTUAL_P (value) = 1;
916 else if (error_operand_p (init))
917 ; /* An error has already been reported. */
919 error ("invalid initializer for member function %qD",
924 gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
925 error ("initializer specified for static member function %qD",
929 else if (TREE_CODE (value) == FIELD_DECL)
930 /* C++11 NSDMI, keep going. */;
931 else if (TREE_CODE (value) != VAR_DECL)
933 else if (!processing_template_decl)
935 if (TREE_CODE (init) == CONSTRUCTOR)
936 init = digest_init (TREE_TYPE (value), init, tf_warning_or_error);
937 init = maybe_constant_init (init);
939 if (init != error_mark_node && !TREE_CONSTANT (init))
941 /* We can allow references to things that are effectively
942 static, since references are initialized with the
944 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
945 || (TREE_STATIC (init) == 0
946 && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
948 error ("field initializer is not constant");
949 init = error_mark_node;
955 if (processing_template_decl
956 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
958 value = push_template_decl (value);
959 if (error_operand_p (value))
960 return error_mark_node;
964 cplus_decl_attributes (&value, attrlist, 0);
966 if (init && BRACE_ENCLOSED_INITIALIZER_P (init)
967 && CONSTRUCTOR_IS_DIRECT_INIT (init))
968 flags = LOOKUP_NORMAL;
970 flags = LOOKUP_IMPLICIT;
972 switch (TREE_CODE (value))
975 finish_static_data_member_decl (value, init, init_const_expr_p,
976 asmspec_tree, flags);
981 error ("%<asm%> specifiers are not permitted on non-static data members");
982 if (DECL_INITIAL (value) == error_mark_node)
983 init = error_mark_node;
984 cp_finish_decl (value, init, /*init_const_expr_p=*/false,
986 DECL_IN_AGGR_P (value) = 1;
991 set_user_assembler_name (value, asmspec);
993 cp_finish_decl (value,
995 /*init_const_expr_p=*/false,
996 asmspec_tree, flags);
998 /* Pass friends back this way. */
999 if (DECL_FRIEND_P (value))
1000 return void_type_node;
1002 DECL_IN_AGGR_P (value) = 1;
1011 /* Like `grokfield', but for bitfields.
1012 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1015 grokbitfield (const cp_declarator *declarator,
1016 cp_decl_specifier_seq *declspecs, tree width,
1019 tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, &attrlist);
1021 if (value == error_mark_node)
1022 return NULL_TREE; /* friends went bad. */
1024 /* Pass friendly classes back. */
1025 if (TREE_CODE (value) == VOID_TYPE)
1026 return void_type_node;
1028 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))
1029 && (POINTER_TYPE_P (value)
1030 || !dependent_type_p (TREE_TYPE (value))))
1032 error ("bit-field %qD with non-integral type", value);
1033 return error_mark_node;
1036 if (TREE_CODE (value) == TYPE_DECL)
1038 error ("cannot declare %qD to be a bit-field type", value);
1042 /* Usually, finish_struct_1 catches bitfields with invalid types.
1043 But, in the case of bitfields with function type, we confuse
1044 ourselves into thinking they are member functions, so we must
1046 if (TREE_CODE (value) == FUNCTION_DECL)
1048 error ("cannot declare bit-field %qD with function type",
1053 if (DECL_IN_AGGR_P (value))
1055 error ("%qD is already defined in the class %qT", value,
1056 DECL_CONTEXT (value));
1057 return void_type_node;
1060 if (TREE_STATIC (value))
1062 error ("static member %qD cannot be a bit-field", value);
1065 cp_finish_decl (value, NULL_TREE, false, NULL_TREE, 0);
1067 if (width != error_mark_node)
1069 /* The width must be an integer type. */
1070 if (!type_dependent_expression_p (width)
1071 && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (width)))
1072 error ("width of bit-field %qD has non-integral type %qT", value,
1074 DECL_INITIAL (value) = width;
1075 SET_DECL_C_BIT_FIELD (value);
1078 DECL_IN_AGGR_P (value) = 1;
1081 cplus_decl_attributes (&value, attrlist, /*flags=*/0);
1087 /* Returns true iff ATTR is an attribute which needs to be applied at
1088 instantiation time rather than template definition time. */
1091 is_late_template_attribute (tree attr, tree decl)
1093 tree name = TREE_PURPOSE (attr);
1094 tree args = TREE_VALUE (attr);
1095 const struct attribute_spec *spec = lookup_attribute_spec (name);
1099 /* Unknown attribute. */
1102 /* Attribute weak handling wants to write out assembly right away. */
1103 if (is_attribute_p ("weak", name))
1106 /* If any of the arguments are dependent expressions, we can't evaluate
1107 the attribute until instantiation time. */
1108 for (arg = args; arg; arg = TREE_CHAIN (arg))
1110 tree t = TREE_VALUE (arg);
1112 /* If the first attribute argument is an identifier, only consider
1113 second and following arguments. Attributes like mode, format,
1114 cleanup and several target specific attributes aren't late
1115 just because they have an IDENTIFIER_NODE as first argument. */
1116 if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE)
1119 if (value_dependent_expression_p (t)
1120 || type_dependent_expression_p (t))
1124 if (TREE_CODE (decl) == TYPE_DECL
1126 || spec->type_required)
1128 tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl);
1130 /* We can't apply any attributes to a completely unknown type until
1131 instantiation time. */
1132 enum tree_code code = TREE_CODE (type);
1133 if (code == TEMPLATE_TYPE_PARM
1134 || code == BOUND_TEMPLATE_TEMPLATE_PARM
1135 || code == TYPENAME_TYPE)
1137 /* Also defer most attributes on dependent types. This is not
1138 necessary in all cases, but is the better default. */
1139 else if (dependent_type_p (type)
1140 /* But attribute visibility specifically works on
1142 && !is_attribute_p ("visibility", name))
1151 /* ATTR_P is a list of attributes. Remove any attributes which need to be
1152 applied at instantiation time and return them. If IS_DEPENDENT is true,
1153 the declaration itself is dependent, so all attributes should be applied
1154 at instantiation time. */
1157 splice_template_attributes (tree *attr_p, tree decl)
1160 tree late_attrs = NULL_TREE;
1161 tree *q = &late_attrs;
1168 if (is_late_template_attribute (*p, decl))
1170 ATTR_IS_DEPENDENT (*p) = 1;
1172 *p = TREE_CHAIN (*p);
1173 q = &TREE_CHAIN (*q);
1177 p = &TREE_CHAIN (*p);
1183 /* Remove any late attributes from the list in ATTR_P and attach them to
1187 save_template_attributes (tree *attr_p, tree *decl_p)
1189 tree late_attrs = splice_template_attributes (attr_p, *decl_p);
1191 tree old_attrs = NULL_TREE;
1196 if (DECL_P (*decl_p))
1197 q = &DECL_ATTRIBUTES (*decl_p);
1199 q = &TYPE_ATTRIBUTES (*decl_p);
1203 /* Place the late attributes at the beginning of the attribute
1205 TREE_CHAIN (tree_last (late_attrs)) = *q;
1208 if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p))
1210 /* We've added new attributes directly to the main variant, so
1211 now we need to update all of the other variants to include
1212 these new attributes. */
1214 for (variant = TYPE_NEXT_VARIANT (*decl_p); variant;
1215 variant = TYPE_NEXT_VARIANT (variant))
1217 gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs);
1218 TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p);
1223 /* Like reconstruct_complex_type, but handle also template trees. */
1226 cp_reconstruct_complex_type (tree type, tree bottom)
1230 if (TREE_CODE (type) == POINTER_TYPE)
1232 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1233 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
1234 TYPE_REF_CAN_ALIAS_ALL (type));
1236 else if (TREE_CODE (type) == REFERENCE_TYPE)
1238 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1239 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
1240 TYPE_REF_CAN_ALIAS_ALL (type));
1242 else if (TREE_CODE (type) == ARRAY_TYPE)
1244 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1245 outer = build_cplus_array_type (inner, TYPE_DOMAIN (type));
1246 /* Don't call cp_build_qualified_type on ARRAY_TYPEs, the
1247 element type qualification will be handled by the recursive
1248 cp_reconstruct_complex_type call and cp_build_qualified_type
1249 for ARRAY_TYPEs changes the element type. */
1252 else if (TREE_CODE (type) == FUNCTION_TYPE)
1254 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1255 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
1256 outer = apply_memfn_quals (outer, type_memfn_quals (type));
1258 else if (TREE_CODE (type) == METHOD_TYPE)
1260 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1261 /* The build_method_type_directly() routine prepends 'this' to argument list,
1262 so we must compensate by getting rid of it. */
1264 = build_method_type_directly
1265 (class_of_this_parm (type), inner,
1266 TREE_CHAIN (TYPE_ARG_TYPES (type)));
1268 else if (TREE_CODE (type) == OFFSET_TYPE)
1270 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1271 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
1276 if (TYPE_ATTRIBUTES (type))
1277 outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type));
1278 return cp_build_qualified_type (outer, cp_type_quals (type));
1281 /* Replaces any constexpr expression that may be into the attributes
1282 arguments with their reduced value. */
1285 cp_check_const_attributes (tree attributes)
1288 for (attr = attributes; attr; attr = TREE_CHAIN (attr))
1291 for (arg = TREE_VALUE (attr); arg; arg = TREE_CHAIN (arg))
1293 tree expr = TREE_VALUE (arg);
1295 TREE_VALUE (arg) = maybe_constant_value (expr);
1300 /* Like decl_attributes, but handle C++ complexity. */
1303 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1305 if (*decl == NULL_TREE || *decl == void_type_node
1306 || *decl == error_mark_node
1307 || attributes == NULL_TREE)
1310 if (processing_template_decl)
1312 if (check_for_bare_parameter_packs (attributes))
1315 save_template_attributes (&attributes, decl);
1316 if (attributes == NULL_TREE)
1320 cp_check_const_attributes (attributes);
1322 if (TREE_CODE (*decl) == TEMPLATE_DECL)
1323 decl = &DECL_TEMPLATE_RESULT (*decl);
1325 decl_attributes (decl, attributes, flags);
1327 if (TREE_CODE (*decl) == TYPE_DECL)
1328 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1331 /* Walks through the namespace- or function-scope anonymous union
1332 OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
1333 Returns one of the fields for use in the mangled name. */
1336 build_anon_union_vars (tree type, tree object)
1338 tree main_decl = NULL_TREE;
1341 /* Rather than write the code to handle the non-union case,
1342 just give an error. */
1343 if (TREE_CODE (type) != UNION_TYPE)
1345 error ("anonymous struct not inside named type");
1346 return error_mark_node;
1349 for (field = TYPE_FIELDS (type);
1351 field = DECL_CHAIN (field))
1356 if (DECL_ARTIFICIAL (field))
1358 if (TREE_CODE (field) != FIELD_DECL)
1360 permerror (input_location, "%q+#D invalid; an anonymous union can only "
1361 "have non-static data members", field);
1365 if (TREE_PRIVATE (field))
1366 permerror (input_location, "private member %q+#D in anonymous union", field);
1367 else if (TREE_PROTECTED (field))
1368 permerror (input_location, "protected member %q+#D in anonymous union", field);
1370 if (processing_template_decl)
1371 ref = build_min_nt (COMPONENT_REF, object,
1372 DECL_NAME (field), NULL_TREE);
1374 ref = build_class_member_access_expr (object, field, NULL_TREE,
1375 false, tf_warning_or_error);
1377 if (DECL_NAME (field))
1381 decl = build_decl (input_location,
1382 VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
1383 DECL_ANON_UNION_VAR_P (decl) = 1;
1384 DECL_ARTIFICIAL (decl) = 1;
1386 base = get_base_address (object);
1387 TREE_PUBLIC (decl) = TREE_PUBLIC (base);
1388 TREE_STATIC (decl) = TREE_STATIC (base);
1389 DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
1391 SET_DECL_VALUE_EXPR (decl, ref);
1392 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1394 decl = pushdecl (decl);
1396 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1397 decl = build_anon_union_vars (TREE_TYPE (field), ref);
1401 if (main_decl == NULL_TREE)
1408 /* Finish off the processing of a UNION_TYPE structure. If the union is an
1409 anonymous union, then all members must be laid out together. PUBLIC_P
1410 is nonzero if this union is not declared static. */
1413 finish_anon_union (tree anon_union_decl)
1419 if (anon_union_decl == error_mark_node)
1422 type = TREE_TYPE (anon_union_decl);
1423 public_p = TREE_PUBLIC (anon_union_decl);
1425 /* The VAR_DECL's context is the same as the TYPE's context. */
1426 DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1428 if (TYPE_FIELDS (type) == NULL_TREE)
1433 error ("namespace-scope anonymous aggregates must be static");
1437 main_decl = build_anon_union_vars (type, anon_union_decl);
1438 if (main_decl == error_mark_node)
1440 if (main_decl == NULL_TREE)
1442 warning (0, "anonymous union with no members");
1446 if (!processing_template_decl)
1448 /* Use main_decl to set the mangled name. */
1449 DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1450 maybe_commonize_var (anon_union_decl);
1451 if (TREE_STATIC (anon_union_decl) || DECL_EXTERNAL (anon_union_decl))
1452 mangle_decl (anon_union_decl);
1453 DECL_NAME (anon_union_decl) = NULL_TREE;
1456 pushdecl (anon_union_decl);
1457 if (building_stmt_list_p ()
1458 && at_function_scope_p ())
1459 add_decl_expr (anon_union_decl);
1460 else if (!processing_template_decl)
1461 rest_of_decl_compilation (anon_union_decl,
1462 toplevel_bindings_p (), at_eof);
1465 /* Auxiliary functions to make type signatures for
1466 `operator new' and `operator delete' correspond to
1467 what compiler will be expecting. */
1470 coerce_new_type (tree type)
1473 tree args = TYPE_ARG_TYPES (type);
1475 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1477 if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1480 error ("%<operator new%> must return type %qT", ptr_type_node);
1483 if (args && args != void_list_node)
1485 if (TREE_PURPOSE (args))
1487 /* [basic.stc.dynamic.allocation]
1489 The first parameter shall not have an associated default
1491 error ("the first parameter of %<operator new%> cannot "
1492 "have a default argument");
1493 /* Throw away the default argument. */
1494 TREE_PURPOSE (args) = NULL_TREE;
1497 if (!same_type_p (TREE_VALUE (args), size_type_node))
1500 args = TREE_CHAIN (args);
1507 permerror (input_location, "%<operator new%> takes type %<size_t%> (%qT) "
1508 "as first parameter", size_type_node);
1513 args = tree_cons (NULL_TREE, size_type_node, args);
1516 type = build_exception_variant
1517 (build_function_type (ptr_type_node, args),
1518 TYPE_RAISES_EXCEPTIONS (type));
1526 coerce_delete_type (tree type)
1529 tree args = TYPE_ARG_TYPES (type);
1531 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1533 if (!same_type_p (TREE_TYPE (type), void_type_node))
1536 error ("%<operator delete%> must return type %qT", void_type_node);
1539 if (!args || args == void_list_node
1540 || !same_type_p (TREE_VALUE (args), ptr_type_node))
1543 if (args && args != void_list_node)
1544 args = TREE_CHAIN (args);
1545 error ("%<operator delete%> takes type %qT as first parameter",
1551 args = tree_cons (NULL_TREE, ptr_type_node, args);
1554 type = build_exception_variant
1555 (build_function_type (void_type_node, args),
1556 TYPE_RAISES_EXCEPTIONS (type));
1564 /* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
1565 and mark them as needed. */
1568 mark_vtable_entries (tree decl)
1571 unsigned HOST_WIDE_INT idx;
1573 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
1578 STRIP_NOPS (fnaddr);
1580 if (TREE_CODE (fnaddr) != ADDR_EXPR
1581 && TREE_CODE (fnaddr) != FDESC_EXPR)
1582 /* This entry is an offset: a virtual base class offset, a
1583 virtual call offset, an RTTI offset, etc. */
1586 fn = TREE_OPERAND (fnaddr, 0);
1587 TREE_ADDRESSABLE (fn) = 1;
1588 /* When we don't have vcall offsets, we output thunks whenever
1589 we output the vtables that contain them. With vcall offsets,
1590 we know all the thunks we'll need when we emit a virtual
1591 function, so we emit the thunks there instead. */
1592 if (DECL_THUNK_P (fn))
1593 use_thunk (fn, /*emit_p=*/0);
1598 /* Set DECL up to have the closest approximation of "initialized common"
1599 linkage available. */
1602 comdat_linkage (tree decl)
1605 make_decl_one_only (decl, cxx_comdat_group (decl));
1606 else if (TREE_CODE (decl) == FUNCTION_DECL
1607 || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1608 /* We can just emit function and compiler-generated variables
1609 statically; having multiple copies is (for the most part) only
1612 There are two correctness issues, however: the address of a
1613 template instantiation with external linkage should be the
1614 same, independent of what translation unit asks for the
1615 address, and this will not hold when we emit multiple copies of
1616 the function. However, there's little else we can do.
1618 Also, by default, the typeinfo implementation assumes that
1619 there will be only one copy of the string used as the name for
1620 each type. Therefore, if weak symbols are unavailable, the
1621 run-time library should perform a more conservative check; it
1622 should perform a string comparison, rather than an address
1624 TREE_PUBLIC (decl) = 0;
1627 /* Static data member template instantiations, however, cannot
1628 have multiple copies. */
1629 if (DECL_INITIAL (decl) == 0
1630 || DECL_INITIAL (decl) == error_mark_node)
1631 DECL_COMMON (decl) = 1;
1632 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1634 DECL_COMMON (decl) = 1;
1635 DECL_INITIAL (decl) = error_mark_node;
1637 else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1639 /* We can't do anything useful; leave vars for explicit
1641 DECL_EXTERNAL (decl) = 1;
1642 DECL_NOT_REALLY_EXTERN (decl) = 0;
1646 DECL_COMDAT (decl) = 1;
1649 /* For win32 we also want to put explicit instantiations in
1650 linkonce sections, so that they will be merged with implicit
1651 instantiations; otherwise we get duplicate symbol errors.
1652 For Darwin we do not want explicit instantiations to be
1656 maybe_make_one_only (tree decl)
1658 /* We used to say that this was not necessary on targets that support weak
1659 symbols, because the implicit instantiations will defer to the explicit
1660 one. However, that's not actually the case in SVR4; a strong definition
1661 after a weak one is an error. Also, not making explicit
1662 instantiations one_only means that we can end up with two copies of
1663 some template instantiations. */
1667 /* We can't set DECL_COMDAT on functions, or cp_finish_file will think
1668 we can get away with not emitting them if they aren't used. We need
1669 to for variables so that cp_finish_decl will update their linkage,
1670 because their DECL_INITIAL may not have been set properly yet. */
1672 if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
1673 || (! DECL_EXPLICIT_INSTANTIATION (decl)
1674 && ! DECL_TEMPLATE_SPECIALIZATION (decl)))
1676 make_decl_one_only (decl, cxx_comdat_group (decl));
1678 if (TREE_CODE (decl) == VAR_DECL)
1680 DECL_COMDAT (decl) = 1;
1681 /* Mark it needed so we don't forget to emit it. */
1682 mark_decl_referenced (decl);
1687 /* Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage.
1688 This predicate will give the right answer during parsing of the
1689 function, which other tests may not. */
1692 vague_linkage_p (tree decl)
1694 /* Unfortunately, import_export_decl has not always been called
1695 before the function is processed, so we cannot simply check
1697 return (DECL_COMDAT (decl)
1698 || (((TREE_CODE (decl) == FUNCTION_DECL
1699 && DECL_DECLARED_INLINE_P (decl))
1700 || (DECL_LANG_SPECIFIC (decl)
1701 && DECL_TEMPLATE_INSTANTIATION (decl)))
1702 && TREE_PUBLIC (decl)));
1705 /* Determine whether or not we want to specifically import or export CTYPE,
1706 using various heuristics. */
1709 import_export_class (tree ctype)
1711 /* -1 for imported, 1 for exported. */
1712 int import_export = 0;
1714 /* It only makes sense to call this function at EOF. The reason is
1715 that this function looks at whether or not the first non-inline
1716 non-abstract virtual member function has been defined in this
1717 translation unit. But, we can't possibly know that until we've
1718 seen the entire translation unit. */
1719 gcc_assert (at_eof);
1721 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1724 /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
1725 we will have CLASSTYPE_INTERFACE_ONLY set but not
1726 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
1727 heuristic because someone will supply a #pragma implementation
1728 elsewhere, and deducing it here would produce a conflict. */
1729 if (CLASSTYPE_INTERFACE_ONLY (ctype))
1732 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1734 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1736 else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1737 && !flag_implicit_templates)
1738 /* For a template class, without -fimplicit-templates, check the
1739 repository. If the virtual table is assigned to this
1740 translation unit, then export the class; otherwise, import
1742 import_export = repo_export_class_p (ctype) ? 1 : -1;
1743 else if (TYPE_POLYMORPHIC_P (ctype))
1745 /* The ABI specifies that the virtual table and associated
1746 information are emitted with the key method, if any. */
1747 tree method = CLASSTYPE_KEY_METHOD (ctype);
1748 /* If weak symbol support is not available, then we must be
1749 careful not to emit the vtable when the key function is
1750 inline. An inline function can be defined in multiple
1751 translation units. If we were to emit the vtable in each
1752 translation unit containing a definition, we would get
1753 multiple definition errors at link-time. */
1754 if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
1755 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1758 /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
1759 a definition anywhere else. */
1760 if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
1763 /* Allow back ends the chance to overrule the decision. */
1764 if (targetm.cxx.import_export_class)
1765 import_export = targetm.cxx.import_export_class (ctype, import_export);
1769 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1770 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1774 /* Return true if VAR has already been provided to the back end; in that
1775 case VAR should not be modified further by the front end. */
1777 var_finalized_p (tree var)
1779 return varpool_node (var)->finalized;
1782 /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
1783 must be emitted in this translation unit. Mark it as such. */
1786 mark_needed (tree decl)
1788 /* It's possible that we no longer need to set
1789 TREE_SYMBOL_REFERENCED here directly, but doing so is
1791 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
1792 mark_decl_referenced (decl);
1795 /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
1796 returns true if a definition of this entity should be provided in
1797 this object file. Callers use this function to determine whether
1798 or not to let the back end know that a definition of DECL is
1799 available in this translation unit. */
1802 decl_needed_p (tree decl)
1804 gcc_assert (TREE_CODE (decl) == VAR_DECL
1805 || TREE_CODE (decl) == FUNCTION_DECL);
1806 /* This function should only be called at the end of the translation
1807 unit. We cannot be sure of whether or not something will be
1808 COMDAT until that point. */
1809 gcc_assert (at_eof);
1811 /* All entities with external linkage that are not COMDAT should be
1812 emitted; they may be referred to from other object files. */
1813 if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1815 /* If this entity was used, let the back end see it; it will decide
1816 whether or not to emit it into the object file. */
1817 if (TREE_USED (decl)
1818 || (DECL_ASSEMBLER_NAME_SET_P (decl)
1819 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1821 /* Functions marked "dllexport" must be emitted so that they are
1822 visible to other DLLs. */
1823 if (flag_keep_inline_dllexport
1824 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
1826 /* Otherwise, DECL does not need to be emitted -- yet. A subsequent
1827 reference to DECL might cause it to be emitted later. */
1831 /* If necessary, write out the vtables for the dynamic class CTYPE.
1832 Returns true if any vtables were emitted. */
1835 maybe_emit_vtables (tree ctype)
1840 struct varpool_node *current = NULL, *last = NULL, *first = NULL;
1842 /* If the vtables for this class have already been emitted there is
1843 nothing more to do. */
1844 primary_vtbl = CLASSTYPE_VTABLES (ctype);
1845 if (var_finalized_p (primary_vtbl))
1847 /* Ignore dummy vtables made by get_vtable_decl. */
1848 if (TREE_TYPE (primary_vtbl) == void_type_node)
1851 /* On some targets, we cannot determine the key method until the end
1852 of the translation unit -- which is when this function is
1854 if (!targetm.cxx.key_method_may_be_inline ())
1855 determine_key_method (ctype);
1857 /* See if any of the vtables are needed. */
1858 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
1860 import_export_decl (vtbl);
1861 if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
1866 /* If the references to this class' vtables are optimized away,
1867 still emit the appropriate debugging information. See
1869 if (DECL_COMDAT (primary_vtbl)
1870 && CLASSTYPE_DEBUG_REQUESTED (ctype))
1871 note_debug_info_needed (ctype);
1875 /* The ABI requires that we emit all of the vtables if we emit any
1877 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = DECL_CHAIN (vtbl))
1879 /* Mark entities references from the virtual table as used. */
1880 mark_vtable_entries (vtbl);
1882 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1884 VEC(tree,gc)* cleanups = NULL;
1885 tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), &cleanups,
1888 /* It had better be all done at compile-time. */
1889 gcc_assert (!expr && !cleanups);
1893 DECL_EXTERNAL (vtbl) = 0;
1894 rest_of_decl_compilation (vtbl, 1, 1);
1896 /* Because we're only doing syntax-checking, we'll never end up
1897 actually marking the variable as written. */
1898 if (flag_syntax_only)
1899 TREE_ASM_WRITTEN (vtbl) = 1;
1900 else if (DECL_COMDAT (vtbl))
1902 current = varpool_node (vtbl);
1904 last->same_comdat_group = current;
1912 last->same_comdat_group = first;
1914 /* Since we're writing out the vtable here, also write the debug
1916 note_debug_info_needed (ctype);
1921 /* A special return value from type_visibility meaning internal
1924 enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 };
1926 /* walk_tree helper function for type_visibility. */
1929 min_vis_r (tree *tp, int *walk_subtrees, void *data)
1931 int *vis_p = (int *)data;
1936 else if (CLASS_TYPE_P (*tp))
1938 if (!TREE_PUBLIC (TYPE_MAIN_DECL (*tp)))
1940 *vis_p = VISIBILITY_ANON;
1943 else if (CLASSTYPE_VISIBILITY (*tp) > *vis_p)
1944 *vis_p = CLASSTYPE_VISIBILITY (*tp);
1949 /* Returns the visibility of TYPE, which is the minimum visibility of its
1953 type_visibility (tree type)
1955 int vis = VISIBILITY_DEFAULT;
1956 cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
1960 /* Limit the visibility of DECL to VISIBILITY, if not explicitly
1961 specified (or if VISIBILITY is static). If TMPL is true, this
1962 constraint is for a template argument, and takes precedence
1963 over explicitly-specified visibility on the template. */
1966 constrain_visibility (tree decl, int visibility, bool tmpl)
1968 if (visibility == VISIBILITY_ANON)
1970 /* extern "C" declarations aren't affected by the anonymous
1972 if (!DECL_EXTERN_C_P (decl))
1974 TREE_PUBLIC (decl) = 0;
1975 DECL_WEAK (decl) = 0;
1976 DECL_COMMON (decl) = 0;
1977 DECL_COMDAT_GROUP (decl) = NULL_TREE;
1978 DECL_INTERFACE_KNOWN (decl) = 1;
1979 if (DECL_LANG_SPECIFIC (decl))
1980 DECL_NOT_REALLY_EXTERN (decl) = 1;
1983 else if (visibility > DECL_VISIBILITY (decl)
1984 && (tmpl || !DECL_VISIBILITY_SPECIFIED (decl)))
1986 DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
1987 /* This visibility was not specified. */
1988 DECL_VISIBILITY_SPECIFIED (decl) = false;
1992 /* Constrain the visibility of DECL based on the visibility of its template
1996 constrain_visibility_for_template (tree decl, tree targs)
1998 /* If this is a template instantiation, check the innermost
1999 template args for visibility constraints. The outer template
2000 args are covered by the class check. */
2001 tree args = INNERMOST_TEMPLATE_ARGS (targs);
2003 for (i = TREE_VEC_LENGTH (args); i > 0; --i)
2007 tree arg = TREE_VEC_ELT (args, i-1);
2009 vis = type_visibility (arg);
2010 else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
2013 if (TREE_CODE (arg) == ADDR_EXPR)
2014 arg = TREE_OPERAND (arg, 0);
2015 if (TREE_CODE (arg) == VAR_DECL
2016 || TREE_CODE (arg) == FUNCTION_DECL)
2018 if (! TREE_PUBLIC (arg))
2019 vis = VISIBILITY_ANON;
2021 vis = DECL_VISIBILITY (arg);
2025 constrain_visibility (decl, vis, true);
2029 /* Like c_determine_visibility, but with additional C++-specific
2032 Function-scope entities can rely on the function's visibility because
2033 it is set in start_preparsed_function.
2035 Class-scope entities cannot rely on the class's visibility until the end
2036 of the enclosing class definition.
2038 Note that because namespaces have multiple independent definitions,
2039 namespace visibility is handled elsewhere using the #pragma visibility
2040 machinery rather than by decorating the namespace declaration.
2042 The goal is for constraints from the type to give a diagnostic, and
2043 other constraints to be applied silently. */
2046 determine_visibility (tree decl)
2048 tree class_type = NULL_TREE;
2050 bool orig_visibility_specified;
2051 enum symbol_visibility orig_visibility;
2053 /* Remember that all decls get VISIBILITY_DEFAULT when built. */
2055 /* Only relevant for names with external linkage. */
2056 if (!TREE_PUBLIC (decl))
2059 /* Cloned constructors and destructors get the same visibility as
2060 the underlying function. That should be set up in
2061 maybe_clone_body. */
2062 gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
2064 orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
2065 orig_visibility = DECL_VISIBILITY (decl);
2067 if (TREE_CODE (decl) == TYPE_DECL)
2069 if (CLASS_TYPE_P (TREE_TYPE (decl)))
2070 use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
2071 else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
2076 else if (DECL_LANG_SPECIFIC (decl))
2077 use_template = DECL_USE_TEMPLATE (decl);
2081 /* If DECL is a member of a class, visibility specifiers on the
2082 class can influence the visibility of the DECL. */
2083 if (DECL_CLASS_SCOPE_P (decl))
2084 class_type = DECL_CONTEXT (decl);
2087 /* Not a class member. */
2089 /* Virtual tables have DECL_CONTEXT set to their associated class,
2090 so they are automatically handled above. */
2091 gcc_assert (TREE_CODE (decl) != VAR_DECL
2092 || !DECL_VTABLE_OR_VTT_P (decl));
2094 if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
2096 /* Local statics and classes get the visibility of their
2097 containing function by default, except that
2098 -fvisibility-inlines-hidden doesn't affect them. */
2099 tree fn = DECL_CONTEXT (decl);
2100 if (DECL_VISIBILITY_SPECIFIED (fn))
2102 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2103 DECL_VISIBILITY_SPECIFIED (decl) =
2104 DECL_VISIBILITY_SPECIFIED (fn);
2108 if (DECL_CLASS_SCOPE_P (fn))
2109 determine_visibility_from_class (decl, DECL_CONTEXT (fn));
2110 else if (determine_hidden_inline (fn))
2112 DECL_VISIBILITY (decl) = default_visibility;
2113 DECL_VISIBILITY_SPECIFIED (decl) =
2114 visibility_options.inpragma;
2118 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2119 DECL_VISIBILITY_SPECIFIED (decl) =
2120 DECL_VISIBILITY_SPECIFIED (fn);
2124 /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
2125 but have no TEMPLATE_INFO, so don't try to check it. */
2128 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl)
2129 && flag_visibility_ms_compat)
2131 /* Under -fvisibility-ms-compat, types are visible by default,
2132 even though their contents aren't. */
2133 tree underlying_type = TREE_TYPE (DECL_NAME (decl));
2134 int underlying_vis = type_visibility (underlying_type);
2135 if (underlying_vis == VISIBILITY_ANON
2136 || (CLASS_TYPE_P (underlying_type)
2137 && CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type)))
2138 constrain_visibility (decl, underlying_vis, false);
2140 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
2142 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2144 /* tinfo visibility is based on the type it's for. */
2145 constrain_visibility
2146 (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))), false);
2148 /* Give the target a chance to override the visibility associated
2150 if (TREE_PUBLIC (decl)
2151 && !DECL_REALLY_EXTERN (decl)
2152 && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
2153 && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
2154 targetm.cxx.determine_class_data_visibility (decl);
2156 else if (use_template)
2157 /* Template instantiations and specializations get visibility based
2158 on their template unless they override it with an attribute. */;
2159 else if (! DECL_VISIBILITY_SPECIFIED (decl))
2161 if (determine_hidden_inline (decl))
2162 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2165 /* Set default visibility to whatever the user supplied with
2166 #pragma GCC visibility or a namespace visibility attribute. */
2167 DECL_VISIBILITY (decl) = default_visibility;
2168 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
2175 /* If the specialization doesn't specify visibility, use the
2176 visibility from the template. */
2177 tree tinfo = (TREE_CODE (decl) == TYPE_DECL
2178 ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2179 : DECL_TEMPLATE_INFO (decl));
2180 tree args = TI_ARGS (tinfo);
2182 if (args != error_mark_node)
2184 int depth = TMPL_ARGS_DEPTH (args);
2185 tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
2187 if (!DECL_VISIBILITY_SPECIFIED (decl))
2189 if (!DECL_VISIBILITY_SPECIFIED (pattern)
2190 && determine_hidden_inline (decl))
2191 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2194 DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
2195 DECL_VISIBILITY_SPECIFIED (decl)
2196 = DECL_VISIBILITY_SPECIFIED (pattern);
2200 /* FIXME should TMPL_ARGS_DEPTH really return 1 for null input? */
2201 if (args && depth > template_class_depth (class_type))
2202 /* Limit visibility based on its template arguments. */
2203 constrain_visibility_for_template (decl, args);
2208 determine_visibility_from_class (decl, class_type);
2210 if (decl_anon_ns_mem_p (decl))
2211 /* Names in an anonymous namespace get internal linkage.
2212 This might change once we implement export. */
2213 constrain_visibility (decl, VISIBILITY_ANON, false);
2214 else if (TREE_CODE (decl) != TYPE_DECL)
2216 /* Propagate anonymity from type to decl. */
2217 int tvis = type_visibility (TREE_TYPE (decl));
2218 if (tvis == VISIBILITY_ANON
2219 || ! DECL_VISIBILITY_SPECIFIED (decl))
2220 constrain_visibility (decl, tvis, false);
2222 else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true))
2223 /* DR 757: A type without linkage shall not be used as the type of a
2224 variable or function with linkage, unless
2225 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
2226 o the variable or function is not used (3.2 [basic.def.odr]) or is
2227 defined in the same translation unit.
2229 Since non-extern "C" decls need to be defined in the same
2230 translation unit, we can make the type internal. */
2231 constrain_visibility (decl, VISIBILITY_ANON, false);
2233 /* If visibility changed and DECL already has DECL_RTL, ensure
2234 symbol flags are updated. */
2235 if ((DECL_VISIBILITY (decl) != orig_visibility
2236 || DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
2237 && ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
2238 || TREE_CODE (decl) == FUNCTION_DECL)
2239 && DECL_RTL_SET_P (decl))
2240 make_decl_rtl (decl);
2243 /* By default, static data members and function members receive
2244 the visibility of their containing class. */
2247 determine_visibility_from_class (tree decl, tree class_type)
2249 if (DECL_VISIBILITY_SPECIFIED (decl))
2252 if (determine_hidden_inline (decl))
2253 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2256 /* Default to the class visibility. */
2257 DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
2258 DECL_VISIBILITY_SPECIFIED (decl)
2259 = CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
2262 /* Give the target a chance to override the visibility associated
2264 if (TREE_CODE (decl) == VAR_DECL
2265 && (DECL_TINFO_P (decl)
2266 || (DECL_VTABLE_OR_VTT_P (decl)
2267 /* Construction virtual tables are not exported because
2268 they cannot be referred to from other object files;
2269 their name is not standardized by the ABI. */
2270 && !DECL_CONSTRUCTION_VTABLE_P (decl)))
2271 && TREE_PUBLIC (decl)
2272 && !DECL_REALLY_EXTERN (decl)
2273 && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
2274 targetm.cxx.determine_class_data_visibility (decl);
2277 /* Returns true iff DECL is an inline that should get hidden visibility
2278 because of -fvisibility-inlines-hidden. */
2281 determine_hidden_inline (tree decl)
2283 return (visibility_options.inlines_hidden
2284 /* Don't do this for inline templates; specializations might not be
2285 inline, and we don't want them to inherit the hidden
2286 visibility. We'll set it here for all inline instantiations. */
2287 && !processing_template_decl
2288 && TREE_CODE (decl) == FUNCTION_DECL
2289 && DECL_DECLARED_INLINE_P (decl)
2290 && (! DECL_LANG_SPECIFIC (decl)
2291 || ! DECL_EXPLICIT_INSTANTIATION (decl)));
2294 /* Constrain the visibility of a class TYPE based on the visibility of its
2295 field types. Warn if any fields require lesser visibility. */
2298 constrain_class_visibility (tree type)
2304 int vis = type_visibility (type);
2306 if (vis == VISIBILITY_ANON
2307 || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
2310 /* Don't warn about visibility if the class has explicit visibility. */
2311 if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
2312 vis = VISIBILITY_INTERNAL;
2314 for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
2315 if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
2317 tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
2318 int subvis = type_visibility (ftype);
2320 if (subvis == VISIBILITY_ANON)
2322 if (!in_main_input_context ())
2324 %qT has a field %qD whose type uses the anonymous namespace",
2327 else if (MAYBE_CLASS_TYPE_P (ftype)
2328 && vis < VISIBILITY_HIDDEN
2329 && subvis >= VISIBILITY_HIDDEN)
2330 warning (OPT_Wattributes, "\
2331 %qT declared with greater visibility than the type of its field %qD",
2335 binfo = TYPE_BINFO (type);
2336 for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
2338 int subvis = type_visibility (TREE_TYPE (t));
2340 if (subvis == VISIBILITY_ANON)
2342 if (!in_main_input_context())
2344 %qT has a base %qT whose type uses the anonymous namespace",
2345 type, TREE_TYPE (t));
2347 else if (vis < VISIBILITY_HIDDEN
2348 && subvis >= VISIBILITY_HIDDEN)
2349 warning (OPT_Wattributes, "\
2350 %qT declared with greater visibility than its base %qT",
2351 type, TREE_TYPE (t));
2355 /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
2356 for DECL has not already been determined, do so now by setting
2357 DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
2358 function is called entities with vague linkage whose definitions
2359 are available must have TREE_PUBLIC set.
2361 If this function decides to place DECL in COMDAT, it will set
2362 appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
2363 the caller to decide whether or not to clear DECL_EXTERNAL. Some
2364 callers defer that decision until it is clear that DECL is actually
2368 import_export_decl (tree decl)
2373 tree class_type = NULL_TREE;
2375 if (DECL_INTERFACE_KNOWN (decl))
2378 /* We cannot determine what linkage to give to an entity with vague
2379 linkage until the end of the file. For example, a virtual table
2380 for a class will be defined if and only if the key method is
2381 defined in this translation unit. As a further example, consider
2382 that when compiling a translation unit that uses PCH file with
2383 "-frepo" it would be incorrect to make decisions about what
2384 entities to emit when building the PCH; those decisions must be
2385 delayed until the repository information has been processed. */
2386 gcc_assert (at_eof);
2387 /* Object file linkage for explicit instantiations is handled in
2388 mark_decl_instantiated. For static variables in functions with
2389 vague linkage, maybe_commonize_var is used.
2391 Therefore, the only declarations that should be provided to this
2392 function are those with external linkage that are:
2394 * implicit instantiations of function templates
2398 * implicit instantiations of static data members of class
2405 Furthermore, all entities that reach this point must have a
2406 definition available in this translation unit.
2408 The following assertions check these conditions. */
2409 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
2410 || TREE_CODE (decl) == VAR_DECL);
2411 /* Any code that creates entities with TREE_PUBLIC cleared should
2412 also set DECL_INTERFACE_KNOWN. */
2413 gcc_assert (TREE_PUBLIC (decl));
2414 if (TREE_CODE (decl) == FUNCTION_DECL)
2415 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2416 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
2417 || DECL_DECLARED_INLINE_P (decl));
2419 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2420 || DECL_VTABLE_OR_VTT_P (decl)
2421 || DECL_TINFO_P (decl));
2422 /* Check that a definition of DECL is available in this translation
2424 gcc_assert (!DECL_REALLY_EXTERN (decl));
2426 /* Assume that DECL will not have COMDAT linkage. */
2428 /* Assume that DECL will not be imported into this translation
2432 /* See if the repository tells us whether or not to emit DECL in
2433 this translation unit. */
2434 emit_p = repo_emit_p (decl);
2437 else if (emit_p == 1)
2439 /* The repository indicates that this entity should be defined
2440 here. Make sure the back end honors that request. */
2441 if (TREE_CODE (decl) == VAR_DECL)
2443 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
2444 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2447 FOR_EACH_CLONE (clone, decl)
2448 mark_needed (clone);
2452 /* Output the definition as an ordinary strong definition. */
2453 DECL_EXTERNAL (decl) = 0;
2454 DECL_INTERFACE_KNOWN (decl) = 1;
2459 /* We have already decided what to do with this DECL; there is no
2460 need to check anything further. */
2462 else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
2464 class_type = DECL_CONTEXT (decl);
2465 import_export_class (class_type);
2466 if (TYPE_FOR_JAVA (class_type))
2468 else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
2469 && CLASSTYPE_INTERFACE_ONLY (class_type))
2471 else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
2472 && !CLASSTYPE_USE_TEMPLATE (class_type)
2473 && CLASSTYPE_KEY_METHOD (class_type)
2474 && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
2475 /* The ABI requires that all virtual tables be emitted with
2476 COMDAT linkage. However, on systems where COMDAT symbols
2477 don't show up in the table of contents for a static
2478 archive, or on systems without weak symbols (where we
2479 approximate COMDAT linkage by using internal linkage), the
2480 linker will report errors about undefined symbols because
2481 it will not see the virtual table definition. Therefore,
2482 in the case that we know that the virtual table will be
2483 emitted in only one translation unit, we make the virtual
2484 table an ordinary definition with external linkage. */
2485 DECL_EXTERNAL (decl) = 0;
2486 else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
2488 /* CLASS_TYPE is being exported from this translation unit,
2489 so DECL should be defined here. */
2490 if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
2491 /* If a class is declared in a header with the "extern
2492 template" extension, then it will not be instantiated,
2493 even in translation units that would normally require
2494 it. Often such classes are explicitly instantiated in
2495 one translation unit. Therefore, the explicit
2496 instantiation must be made visible to other translation
2498 DECL_EXTERNAL (decl) = 0;
2501 /* The generic C++ ABI says that class data is always
2502 COMDAT, even if there is a key function. Some
2503 variants (e.g., the ARM EABI) says that class data
2504 only has COMDAT linkage if the class data might be
2505 emitted in more than one translation unit. When the
2506 key method can be inline and is inline, we still have
2507 to arrange for comdat even though
2508 class_data_always_comdat is false. */
2509 if (!CLASSTYPE_KEY_METHOD (class_type)
2510 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
2511 || targetm.cxx.class_data_always_comdat ())
2513 /* The ABI requires COMDAT linkage. Normally, we
2514 only emit COMDAT things when they are needed;
2515 make sure that we realize that this entity is
2522 else if (!flag_implicit_templates
2523 && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
2528 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2530 tree type = TREE_TYPE (DECL_NAME (decl));
2531 if (CLASS_TYPE_P (type))
2534 import_export_class (type);
2535 if (CLASSTYPE_INTERFACE_KNOWN (type)
2536 && TYPE_POLYMORPHIC_P (type)
2537 && CLASSTYPE_INTERFACE_ONLY (type)
2538 /* If -fno-rtti was specified, then we cannot be sure
2539 that RTTI information will be emitted with the
2540 virtual table of the class, so we must emit it
2541 wherever it is used. */
2546 if (CLASSTYPE_INTERFACE_KNOWN (type)
2547 && !CLASSTYPE_INTERFACE_ONLY (type))
2549 comdat_p = (targetm.cxx.class_data_always_comdat ()
2550 || (CLASSTYPE_KEY_METHOD (type)
2551 && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
2556 DECL_EXTERNAL (decl) = 0;
2566 else if (DECL_TEMPLATE_INSTANTIATION (decl)
2567 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2569 /* DECL is an implicit instantiation of a function or static
2571 if ((flag_implicit_templates
2572 && !flag_use_repository)
2573 || (flag_implicit_inline_templates
2574 && TREE_CODE (decl) == FUNCTION_DECL
2575 && DECL_DECLARED_INLINE_P (decl)))
2578 /* If we are not implicitly generating templates, then mark
2579 this entity as undefined in this translation unit. */
2582 else if (DECL_FUNCTION_MEMBER_P (decl))
2584 if (!DECL_DECLARED_INLINE_P (decl))
2586 tree ctype = DECL_CONTEXT (decl);
2587 import_export_class (ctype);
2588 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2590 DECL_NOT_REALLY_EXTERN (decl)
2591 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2592 || (DECL_DECLARED_INLINE_P (decl)
2593 && ! flag_implement_inlines
2594 && !DECL_VINDEX (decl)));
2596 if (!DECL_NOT_REALLY_EXTERN (decl))
2597 DECL_EXTERNAL (decl) = 1;
2599 /* Always make artificials weak. */
2600 if (DECL_ARTIFICIAL (decl) && flag_weak)
2603 maybe_make_one_only (decl);
2614 /* If we are importing DECL into this translation unit, mark is
2615 an undefined here. */
2616 DECL_EXTERNAL (decl) = 1;
2617 DECL_NOT_REALLY_EXTERN (decl) = 0;
2621 /* If we decided to put DECL in COMDAT, mark it accordingly at
2623 comdat_linkage (decl);
2626 DECL_INTERFACE_KNOWN (decl) = 1;
2629 /* Return an expression that performs the destruction of DECL, which
2630 must be a VAR_DECL whose type has a non-trivial destructor, or is
2631 an array whose (innermost) elements have a non-trivial destructor. */
2634 build_cleanup (tree decl)
2637 tree type = TREE_TYPE (decl);
2639 /* This function should only be called for declarations that really
2640 require cleanups. */
2641 gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
2643 /* Treat all objects with destructors as used; the destructor may do
2644 something substantive. */
2647 if (TREE_CODE (type) == ARRAY_TYPE)
2650 temp = build_address (decl);
2651 temp = build_delete (TREE_TYPE (temp), temp,
2652 sfk_complete_destructor,
2653 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0,
2654 tf_warning_or_error);
2658 /* Returns the initialization guard variable for the variable DECL,
2659 which has static storage duration. */
2662 get_guard (tree decl)
2667 sname = mangle_guard_variable (decl);
2668 guard = IDENTIFIER_GLOBAL_VALUE (sname);
2673 /* We use a type that is big enough to contain a mutex as well
2674 as an integer counter. */
2675 guard_type = targetm.cxx.guard_type ();
2676 guard = build_decl (DECL_SOURCE_LOCATION (decl),
2677 VAR_DECL, sname, guard_type);
2679 /* The guard should have the same linkage as what it guards. */
2680 TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
2681 TREE_STATIC (guard) = TREE_STATIC (decl);
2682 DECL_COMMON (guard) = DECL_COMMON (decl);
2683 DECL_COMDAT (guard) = DECL_COMDAT (decl);
2684 if (DECL_ONE_ONLY (decl))
2685 make_decl_one_only (guard, cxx_comdat_group (guard));
2686 if (TREE_PUBLIC (decl))
2687 DECL_WEAK (guard) = DECL_WEAK (decl);
2688 DECL_VISIBILITY (guard) = DECL_VISIBILITY (decl);
2689 DECL_VISIBILITY_SPECIFIED (guard) = DECL_VISIBILITY_SPECIFIED (decl);
2691 DECL_ARTIFICIAL (guard) = 1;
2692 DECL_IGNORED_P (guard) = 1;
2693 TREE_USED (guard) = 1;
2694 pushdecl_top_level_and_finish (guard, NULL_TREE);
2699 /* Return those bits of the GUARD variable that should be set when the
2700 guarded entity is actually initialized. */
2703 get_guard_bits (tree guard)
2705 if (!targetm.cxx.guard_mask_bit ())
2707 /* We only set the first byte of the guard, in order to leave room
2708 for a mutex in the high-order bits. */
2709 guard = build1 (ADDR_EXPR,
2710 build_pointer_type (TREE_TYPE (guard)),
2712 guard = build1 (NOP_EXPR,
2713 build_pointer_type (char_type_node),
2715 guard = build1 (INDIRECT_REF, char_type_node, guard);
2721 /* Return an expression which determines whether or not the GUARD
2722 variable has already been initialized. */
2725 get_guard_cond (tree guard)
2729 /* Check to see if the GUARD is zero. */
2730 guard = get_guard_bits (guard);
2732 /* Mask off all but the low bit. */
2733 if (targetm.cxx.guard_mask_bit ())
2735 guard_value = integer_one_node;
2736 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2737 guard_value = convert (TREE_TYPE (guard), guard_value);
2738 guard = cp_build_binary_op (input_location,
2739 BIT_AND_EXPR, guard, guard_value,
2740 tf_warning_or_error);
2743 guard_value = integer_zero_node;
2744 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2745 guard_value = convert (TREE_TYPE (guard), guard_value);
2746 return cp_build_binary_op (input_location,
2747 EQ_EXPR, guard, guard_value,
2748 tf_warning_or_error);
2751 /* Return an expression which sets the GUARD variable, indicating that
2752 the variable being guarded has been initialized. */
2755 set_guard (tree guard)
2759 /* Set the GUARD to one. */
2760 guard = get_guard_bits (guard);
2761 guard_init = integer_one_node;
2762 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
2763 guard_init = convert (TREE_TYPE (guard), guard_init);
2764 return cp_build_modify_expr (guard, NOP_EXPR, guard_init,
2765 tf_warning_or_error);
2768 /* Start the process of running a particular set of global constructors
2769 or destructors. Subroutine of do_[cd]tors. */
2772 start_objects (int method_type, int initp)
2778 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
2780 if (initp != DEFAULT_INIT_PRIORITY)
2790 sprintf (type, "sub_%c%c%.5u", method_type, joiner, initp);
2793 sprintf (type, "sub_%c", method_type);
2795 fndecl = build_lang_decl (FUNCTION_DECL,
2796 get_file_function_name (type),
2797 build_function_type_list (void_type_node,
2799 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
2801 TREE_PUBLIC (current_function_decl) = 0;
2803 /* Mark as artificial because it's not explicitly in the user's
2805 DECL_ARTIFICIAL (current_function_decl) = 1;
2807 /* Mark this declaration as used to avoid spurious warnings. */
2808 TREE_USED (current_function_decl) = 1;
2810 /* Mark this function as a global constructor or destructor. */
2811 if (method_type == 'I')
2812 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
2814 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
2816 body = begin_compound_stmt (BCS_FN_BODY);
2821 /* Finish the process of running a particular set of global constructors
2822 or destructors. Subroutine of do_[cd]tors. */
2825 finish_objects (int method_type, int initp, tree body)
2830 finish_compound_stmt (body);
2831 fn = finish_function (0);
2833 if (method_type == 'I')
2835 DECL_STATIC_CONSTRUCTOR (fn) = 1;
2836 decl_init_priority_insert (fn, initp);
2840 DECL_STATIC_DESTRUCTOR (fn) = 1;
2841 decl_fini_priority_insert (fn, initp);
2844 expand_or_defer_fn (fn);
2847 /* The names of the parameters to the function created to handle
2848 initializations and destructions for objects with static storage
2850 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2851 #define PRIORITY_IDENTIFIER "__priority"
2853 /* The name of the function we create to handle initializations and
2854 destructions for objects with static storage duration. */
2855 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2857 /* The declaration for the __INITIALIZE_P argument. */
2858 static GTY(()) tree initialize_p_decl;
2860 /* The declaration for the __PRIORITY argument. */
2861 static GTY(()) tree priority_decl;
2863 /* The declaration for the static storage duration function. */
2864 static GTY(()) tree ssdf_decl;
2866 /* All the static storage duration functions created in this
2867 translation unit. */
2868 static GTY(()) VEC(tree,gc) *ssdf_decls;
2870 /* A map from priority levels to information about that priority
2871 level. There may be many such levels, so efficient lookup is
2873 static splay_tree priority_info_map;
2875 /* Begins the generation of the function that will handle all
2876 initialization and destruction of objects with static storage
2877 duration. The function generated takes two parameters of type
2878 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2879 nonzero, it performs initializations. Otherwise, it performs
2880 destructions. It only performs those initializations or
2881 destructions with the indicated __PRIORITY. The generated function
2884 It is assumed that this function will only be called once per
2885 translation unit. */
2888 start_static_storage_duration_function (unsigned count)
2892 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2894 /* Create the identifier for this function. It will be of the form
2895 SSDF_IDENTIFIER_<number>. */
2896 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2898 type = build_function_type_list (void_type_node,
2899 integer_type_node, integer_type_node,
2902 /* Create the FUNCTION_DECL itself. */
2903 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2904 get_identifier (id),
2906 TREE_PUBLIC (ssdf_decl) = 0;
2907 DECL_ARTIFICIAL (ssdf_decl) = 1;
2909 /* Put this function in the list of functions to be called from the
2910 static constructors and destructors. */
2913 ssdf_decls = VEC_alloc (tree, gc, 32);
2915 /* Take this opportunity to initialize the map from priority
2916 numbers to information about that priority level. */
2917 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2918 /*delete_key_fn=*/0,
2919 /*delete_value_fn=*/
2920 (splay_tree_delete_value_fn) &free);
2922 /* We always need to generate functions for the
2923 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2924 priorities later, we'll be sure to find the
2925 DEFAULT_INIT_PRIORITY. */
2926 get_priority_info (DEFAULT_INIT_PRIORITY);
2929 VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
2931 /* Create the argument list. */
2932 initialize_p_decl = cp_build_parm_decl
2933 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2934 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2935 TREE_USED (initialize_p_decl) = 1;
2936 priority_decl = cp_build_parm_decl
2937 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2938 DECL_CONTEXT (priority_decl) = ssdf_decl;
2939 TREE_USED (priority_decl) = 1;
2941 DECL_CHAIN (initialize_p_decl) = priority_decl;
2942 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2944 /* Put the function in the global scope. */
2945 pushdecl (ssdf_decl);
2947 /* Start the function itself. This is equivalent to declaring the
2950 static void __ssdf (int __initialize_p, init __priority_p);
2952 It is static because we only need to call this function from the
2953 various constructor and destructor functions for this module. */
2954 start_preparsed_function (ssdf_decl,
2955 /*attrs=*/NULL_TREE,
2958 /* Set up the scope of the outermost block in the function. */
2959 body = begin_compound_stmt (BCS_FN_BODY);
2964 /* Finish the generation of the function which performs initialization
2965 and destruction of objects with static storage duration. After
2966 this point, no more such objects can be created. */
2969 finish_static_storage_duration_function (tree body)
2971 /* Close out the function. */
2972 finish_compound_stmt (body);
2973 expand_or_defer_fn (finish_function (0));
2976 /* Return the information about the indicated PRIORITY level. If no
2977 code to handle this level has yet been generated, generate the
2978 appropriate prologue. */
2980 static priority_info
2981 get_priority_info (int priority)
2986 n = splay_tree_lookup (priority_info_map,
2987 (splay_tree_key) priority);
2990 /* Create a new priority information structure, and insert it
2992 pi = XNEW (struct priority_info_s);
2993 pi->initializations_p = 0;
2994 pi->destructions_p = 0;
2995 splay_tree_insert (priority_info_map,
2996 (splay_tree_key) priority,
2997 (splay_tree_value) pi);
3000 pi = (priority_info) n->value;
3005 /* The effective initialization priority of a DECL. */
3007 #define DECL_EFFECTIVE_INIT_PRIORITY(decl) \
3008 ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
3009 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
3011 /* Whether a DECL needs a guard to protect it against multiple
3014 #define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \
3015 || DECL_ONE_ONLY (decl) \
3016 || DECL_WEAK (decl)))
3018 /* Called from one_static_initialization_or_destruction(),
3020 Walks the initializer list of a global variable and looks for
3021 temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0)
3022 and that have their DECL_CONTEXT() == NULL.
3023 For each such temporary variable, set their DECL_CONTEXT() to
3024 the current function. This is necessary because otherwise
3025 some optimizers (enabled by -O2 -fprofile-arcs) might crash
3026 when trying to refer to a temporary variable that does not have
3027 it's DECL_CONTECT() properly set. */
3029 fix_temporary_vars_context_r (tree *node,
3030 int *unused ATTRIBUTE_UNUSED,
3031 void *unused1 ATTRIBUTE_UNUSED)
3033 gcc_assert (current_function_decl);
3035 if (TREE_CODE (*node) == BIND_EXPR)
3039 for (var = BIND_EXPR_VARS (*node); var; var = DECL_CHAIN (var))
3040 if (TREE_CODE (var) == VAR_DECL
3042 && DECL_ARTIFICIAL (var)
3043 && !DECL_CONTEXT (var))
3044 DECL_CONTEXT (var) = current_function_decl;
3050 /* Set up to handle the initialization or destruction of DECL. If
3051 INITP is nonzero, we are initializing the variable. Otherwise, we
3052 are destroying it. */
3055 one_static_initialization_or_destruction (tree decl, tree init, bool initp)
3057 tree guard_if_stmt = NULL_TREE;
3060 /* If we are supposed to destruct and there's a trivial destructor,
3061 nothing has to be done. */
3063 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3066 /* Trick the compiler into thinking we are at the file and line
3067 where DECL was declared so that error-messages make sense, and so
3068 that the debugger will show somewhat sensible file and line
3070 input_location = DECL_SOURCE_LOCATION (decl);
3072 /* Make sure temporary variables in the initialiser all have
3073 their DECL_CONTEXT() set to a value different from NULL_TREE.
3074 This can happen when global variables initialisers are built.
3075 In that case, the DECL_CONTEXT() of the global variables _AND_ of all
3076 the temporary variables that might have been generated in the
3077 accompagning initialisers is NULL_TREE, meaning the variables have been
3078 declared in the global namespace.
3079 What we want to do here is to fix that and make sure the DECL_CONTEXT()
3080 of the temporaries are set to the current function decl. */
3081 cp_walk_tree_without_duplicates (&init,
3082 fix_temporary_vars_context_r,
3089 Access control for implicit calls to the constructors,
3090 the conversion functions, or the destructor called to
3091 create and destroy a static data member is performed as
3092 if these calls appeared in the scope of the member's
3095 we pretend we are in a static member function of the class of
3096 which the DECL is a member. */
3097 if (member_p (decl))
3099 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3100 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3103 /* Assume we don't need a guard. */
3105 /* We need a guard if this is an object with external linkage that
3106 might be initialized in more than one place. (For example, a
3107 static data member of a template, when the data member requires
3109 if (NEEDS_GUARD_P (decl))
3113 guard = get_guard (decl);
3115 /* When using __cxa_atexit, we just check the GUARD as we would
3116 for a local static. */
3117 if (flag_use_cxa_atexit)
3119 /* When using __cxa_atexit, we never try to destroy
3120 anything from a static destructor. */
3122 guard_cond = get_guard_cond (guard);
3124 /* If we don't have __cxa_atexit, then we will be running
3125 destructors from .fini sections, or their equivalents. So,
3126 we need to know how many times we've tried to initialize this
3127 object. We do initializations only if the GUARD is zero,
3128 i.e., if we are the first to initialize the variable. We do
3129 destructions only if the GUARD is one, i.e., if we are the
3130 last to destroy the variable. */
3133 = cp_build_binary_op (input_location,
3135 cp_build_unary_op (PREINCREMENT_EXPR,
3138 tf_warning_or_error),
3140 tf_warning_or_error);
3143 = cp_build_binary_op (input_location,
3145 cp_build_unary_op (PREDECREMENT_EXPR,
3148 tf_warning_or_error),
3150 tf_warning_or_error);
3152 guard_if_stmt = begin_if_stmt ();
3153 finish_if_stmt_cond (guard_cond, guard_if_stmt);
3157 /* If we're using __cxa_atexit, we have not already set the GUARD,
3158 so we must do so now. */
3159 if (guard && initp && flag_use_cxa_atexit)
3160 finish_expr_stmt (set_guard (guard));
3162 /* Perform the initialization or destruction. */
3166 finish_expr_stmt (init);
3168 /* If we're using __cxa_atexit, register a function that calls the
3169 destructor for the object. */
3170 if (flag_use_cxa_atexit)
3171 finish_expr_stmt (register_dtor_fn (decl));
3174 finish_expr_stmt (build_cleanup (decl));
3176 /* Finish the guard if-stmt, if necessary. */
3179 finish_then_clause (guard_if_stmt);
3180 finish_if_stmt (guard_if_stmt);
3183 /* Now that we're done with DECL we don't need to pretend to be a
3184 member of its class any longer. */
3185 DECL_CONTEXT (current_function_decl) = NULL_TREE;
3186 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3189 /* Generate code to do the initialization or destruction of the decls in VARS,
3190 a TREE_LIST of VAR_DECL with static storage duration.
3191 Whether initialization or destruction is performed is specified by INITP. */
3194 do_static_initialization_or_destruction (tree vars, bool initp)
3196 tree node, init_if_stmt, cond;
3198 /* Build the outer if-stmt to check for initialization or destruction. */
3199 init_if_stmt = begin_if_stmt ();
3200 cond = initp ? integer_one_node : integer_zero_node;
3201 cond = cp_build_binary_op (input_location,
3205 tf_warning_or_error);
3206 finish_if_stmt_cond (cond, init_if_stmt);
3210 tree decl = TREE_VALUE (node);
3211 tree priority_if_stmt;
3215 /* If we don't need a destructor, there's nothing to do. Avoid
3216 creating a possibly empty if-stmt. */
3217 if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3219 node = TREE_CHAIN (node);
3223 /* Remember that we had an initialization or finalization at this
3225 priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
3226 pi = get_priority_info (priority);
3228 pi->initializations_p = 1;
3230 pi->destructions_p = 1;
3232 /* Conditionalize this initialization on being in the right priority
3233 and being initializing/finalizing appropriately. */
3234 priority_if_stmt = begin_if_stmt ();
3235 cond = cp_build_binary_op (input_location,
3238 build_int_cst (NULL_TREE, priority),
3239 tf_warning_or_error);
3240 finish_if_stmt_cond (cond, priority_if_stmt);
3242 /* Process initializers with same priority. */
3244 && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
3245 node = TREE_CHAIN (node))
3246 /* Do one initialization or destruction. */
3247 one_static_initialization_or_destruction (TREE_VALUE (node),
3248 TREE_PURPOSE (node), initp);
3250 /* Finish up the priority if-stmt body. */
3251 finish_then_clause (priority_if_stmt);
3252 finish_if_stmt (priority_if_stmt);
3256 /* Finish up the init/destruct if-stmt body. */
3257 finish_then_clause (init_if_stmt);
3258 finish_if_stmt (init_if_stmt);
3261 /* VARS is a list of variables with static storage duration which may
3262 need initialization and/or finalization. Remove those variables
3263 that don't really need to be initialized or finalized, and return
3264 the resulting list. The order in which the variables appear in
3265 VARS is in reverse order of the order in which they should actually
3266 be initialized. The list we return is in the unreversed order;
3267 i.e., the first variable should be initialized first. */
3270 prune_vars_needing_no_initialization (tree *vars)
3273 tree result = NULL_TREE;
3278 tree decl = TREE_VALUE (t);
3279 tree init = TREE_PURPOSE (t);
3281 /* Deal gracefully with error. */
3282 if (decl == error_mark_node)
3284 var = &TREE_CHAIN (t);
3288 /* The only things that can be initialized are variables. */
3289 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3291 /* If this object is not defined, we don't need to do anything
3293 if (DECL_EXTERNAL (decl))
3295 var = &TREE_CHAIN (t);
3299 /* Also, if the initializer already contains errors, we can bail
3301 if (init && TREE_CODE (init) == TREE_LIST
3302 && value_member (error_mark_node, init))
3304 var = &TREE_CHAIN (t);
3308 /* This variable is going to need initialization and/or
3309 finalization, so we add it to the list. */
3310 *var = TREE_CHAIN (t);
3311 TREE_CHAIN (t) = result;
3318 /* Make sure we have told the back end about all the variables in
3322 write_out_vars (tree vars)
3326 for (v = vars; v; v = TREE_CHAIN (v))
3328 tree var = TREE_VALUE (v);
3329 if (!var_finalized_p (var))
3331 import_export_decl (var);
3332 rest_of_decl_compilation (var, 1, 1);
3337 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3338 (otherwise) that will initialize all global objects with static
3339 storage duration having the indicated PRIORITY. */
3342 generate_ctor_or_dtor_function (bool constructor_p, int priority,
3350 input_location = *locus;
3352 /* Was: locus->line++; */
3354 /* We use `I' to indicate initialization and `D' to indicate
3356 function_key = constructor_p ? 'I' : 'D';
3358 /* We emit the function lazily, to avoid generating empty
3359 global constructors and destructors. */
3362 /* For Objective-C++, we may need to initialize metadata found in this module.
3363 This must be done _before_ any other static initializations. */
3364 if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
3365 && constructor_p && objc_static_init_needed_p ())
3367 body = start_objects (function_key, priority);
3368 objc_generate_static_init_call (NULL_TREE);
3371 /* Call the static storage duration function with appropriate
3373 FOR_EACH_VEC_ELT (tree, ssdf_decls, i, fndecl)
3375 /* Calls to pure or const functions will expand to nothing. */
3376 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
3381 body = start_objects (function_key, priority);
3383 call = cp_build_function_call_nary (fndecl, tf_warning_or_error,
3384 build_int_cst (NULL_TREE,
3386 build_int_cst (NULL_TREE,
3389 finish_expr_stmt (call);
3393 /* Close out the function. */
3395 finish_objects (function_key, priority, body);
3398 /* Generate constructor and destructor functions for the priority
3402 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
3404 location_t *locus = (location_t *) data;
3405 int priority = (int) n->key;
3406 priority_info pi = (priority_info) n->value;
3408 /* Generate the functions themselves, but only if they are really
3410 if (pi->initializations_p)
3411 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
3412 if (pi->destructions_p)
3413 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
3415 /* Keep iterating. */
3419 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
3420 decls referenced from front-end specific constructs; it will be called
3421 only for language-specific tree nodes.
3423 Here we must deal with member pointers. */
3426 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED)
3430 switch (TREE_CODE (t))
3433 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
3434 cgraph_mark_address_taken_node (
3435 cgraph_get_create_node (PTRMEM_CST_MEMBER (t)));
3438 if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
3439 cgraph_mark_address_taken_node (
3440 cgraph_get_create_node (BASELINK_FUNCTIONS (t)));
3443 if (DECL_CONTEXT (t)
3444 && flag_use_repository
3445 && TREE_CODE (DECL_CONTEXT (t)) == FUNCTION_DECL)
3446 /* If we need a static variable in a function, then we
3447 need the containing function. */
3448 mark_decl_referenced (DECL_CONTEXT (t));
3457 /* Java requires that we be able to reference a local address for a
3458 method, and not be confused by PLT entries. If hidden aliases are
3459 supported, collect and return all the functions for which we should
3460 emit a hidden alias. */
3462 static struct pointer_set_t *
3463 collect_candidates_for_java_method_aliases (void)
3465 struct cgraph_node *node;
3466 struct pointer_set_t *candidates = NULL;
3468 #ifndef HAVE_GAS_HIDDEN
3472 for (node = cgraph_nodes; node ; node = node->next)
3474 tree fndecl = node->decl;
3476 if (DECL_CONTEXT (fndecl)
3477 && TYPE_P (DECL_CONTEXT (fndecl))
3478 && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
3479 && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
3481 if (candidates == NULL)
3482 candidates = pointer_set_create ();
3483 pointer_set_insert (candidates, fndecl);
3491 /* Java requires that we be able to reference a local address for a
3492 method, and not be confused by PLT entries. If hidden aliases are
3493 supported, emit one for each java function that we've emitted.
3494 CANDIDATES is the set of FUNCTION_DECLs that were gathered
3495 by collect_candidates_for_java_method_aliases. */
3498 build_java_method_aliases (struct pointer_set_t *candidates)
3500 struct cgraph_node *node;
3502 #ifndef HAVE_GAS_HIDDEN
3506 for (node = cgraph_nodes; node ; node = node->next)
3508 tree fndecl = node->decl;
3510 if (TREE_ASM_WRITTEN (fndecl)
3511 && pointer_set_contains (candidates, fndecl))
3513 /* Mangle the name in a predictable way; we need to reference
3514 this from a java compiled object file. */
3515 tree oid, nid, alias;
3519 oid = DECL_ASSEMBLER_NAME (fndecl);
3520 oname = IDENTIFIER_POINTER (oid);
3521 gcc_assert (oname[0] == '_' && oname[1] == 'Z');
3522 nname = ACONCAT (("_ZGA", oname+2, NULL));
3523 nid = get_identifier (nname);
3525 alias = make_alias_for (fndecl, nid);
3526 TREE_PUBLIC (alias) = 1;
3527 DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
3529 assemble_alias (alias, oid);
3534 /* Return C++ property of T, based on given operation OP. */
3537 cpp_check (tree t, cpp_operation op)
3542 return DECL_PURE_VIRTUAL_P (t);
3543 case IS_CONSTRUCTOR:
3544 return DECL_CONSTRUCTOR_P (t);
3546 return DECL_DESTRUCTOR_P (t);
3547 case IS_COPY_CONSTRUCTOR:
3548 return DECL_COPY_CONSTRUCTOR_P (t);
3550 return TREE_CODE (t) == TEMPLATE_DECL;
3556 /* Collect source file references recursively, starting from NAMESPC. */
3559 collect_source_refs (tree namespc)
3566 /* Iterate over names in this name space. */
3567 for (t = NAMESPACE_LEVEL (namespc)->names; t; t = TREE_CHAIN (t))
3568 if (!DECL_IS_BUILTIN (t) )
3569 collect_source_ref (DECL_SOURCE_FILE (t));
3571 /* Dump siblings, if any */
3572 collect_source_refs (TREE_CHAIN (namespc));
3574 /* Dump children, if any */
3575 collect_source_refs (NAMESPACE_LEVEL (namespc)->namespaces);
3578 /* Collect decls relevant to SOURCE_FILE from all namespaces recursively,
3579 starting from NAMESPC. */
3582 collect_ada_namespace (tree namespc, const char *source_file)
3587 /* Collect decls from this namespace */
3588 collect_ada_nodes (NAMESPACE_LEVEL (namespc)->names, source_file);
3590 /* Collect siblings, if any */
3591 collect_ada_namespace (TREE_CHAIN (namespc), source_file);
3593 /* Collect children, if any */
3594 collect_ada_namespace (NAMESPACE_LEVEL (namespc)->namespaces, source_file);
3597 /* Returns true iff there is a definition available for variable or
3601 decl_defined_p (tree decl)
3603 if (TREE_CODE (decl) == FUNCTION_DECL)
3604 return (DECL_INITIAL (decl) != NULL_TREE);
3607 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3608 return !DECL_EXTERNAL (decl);
3612 /* Nonzero for a VAR_DECL whose value can be used in a constant expression.
3616 An integral constant-expression can only involve ... const
3617 variables of integral or enumeration types initialized with
3618 constant expressions ...
3620 C++0x also allows constexpr variables and temporaries initialized
3621 with constant expressions. We handle the former here, but the latter
3622 are just folded away in cxx_eval_constant_expression.
3624 The standard does not require that the expression be non-volatile.
3625 G++ implements the proposed correction in DR 457. */
3628 decl_constant_var_p (tree decl)
3630 if (!decl_maybe_constant_var_p (decl))
3633 /* We don't know if a template static data member is initialized with
3634 a constant expression until we instantiate its initializer. Even
3635 in the case of a constexpr variable, we can't treat it as a
3636 constant until its initializer is complete in case it's used in
3637 its own initializer. */
3639 return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl);
3642 /* Returns true if DECL could be a symbolic constant variable, depending on
3646 decl_maybe_constant_var_p (tree decl)
3648 tree type = TREE_TYPE (decl);
3649 if (TREE_CODE (decl) != VAR_DECL)
3651 if (DECL_DECLARED_CONSTEXPR_P (decl))
3653 return (CP_TYPE_CONST_NON_VOLATILE_P (type)
3654 && INTEGRAL_OR_ENUMERATION_TYPE_P (type));
3657 /* Complain that DECL uses a type with no linkage but is never defined. */
3660 no_linkage_error (tree decl)
3662 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
3663 if (TYPE_ANONYMOUS_P (t))
3665 permerror (0, "%q+#D, declared using anonymous type, "
3666 "is used but never defined", decl);
3667 if (is_typedef_decl (TYPE_NAME (t)))
3668 permerror (0, "%q+#D does not refer to the unqualified type, "
3669 "so it is not used for linkage", TYPE_NAME (t));
3672 permerror (0, "%q+#D, declared using local type %qT, "
3673 "is used but never defined", decl, t);
3676 /* Collect declarations from all namespaces relevant to SOURCE_FILE. */
3679 collect_all_refs (const char *source_file)
3681 collect_ada_namespace (global_namespace, source_file);
3684 /* Clear DECL_EXTERNAL for NODE. */
3687 clear_decl_external (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
3689 DECL_EXTERNAL (node->decl) = 0;
3693 /* This routine is called at the end of compilation.
3694 Its job is to create all the code needed to initialize and
3695 destroy the global aggregates. We do the destruction
3696 first, since that way we only need to reverse the decls once. */
3699 cp_write_global_declarations (void)
3705 unsigned ssdf_count = 0;
3708 struct pointer_set_t *candidates;
3710 locus = input_location;
3713 /* Bad parse errors. Just forget about it. */
3714 if (! global_bindings_p () || current_class_type
3715 || !VEC_empty (tree,decl_namespace_list))
3719 c_common_write_pch ();
3721 cgraph_process_same_body_aliases ();
3723 /* Handle -fdump-ada-spec[-slim] */
3724 if (dump_enabled_p (TDI_ada))
3726 if (get_dump_file_info (TDI_ada)->flags & TDF_SLIM)
3727 collect_source_ref (main_input_filename);
3729 collect_source_refs (global_namespace);
3731 dump_ada_specs (collect_all_refs, cpp_check);
3734 /* FIXME - huh? was input_line -= 1;*/
3736 timevar_start (TV_PHASE_DEFERRED);
3738 /* We now have to write out all the stuff we put off writing out.
3741 o Template specializations that we have not yet instantiated,
3742 but which are needed.
3743 o Initialization and destruction for non-local objects with
3744 static storage duration. (Local objects with static storage
3745 duration are initialized when their scope is first entered,
3746 and are cleaned up via atexit.)
3747 o Virtual function tables.
3749 All of these may cause others to be needed. For example,
3750 instantiating one function may cause another to be needed, and
3751 generating the initializer for an object may cause templates to be
3752 instantiated, etc., etc. */
3754 emit_support_tinfos ();
3763 /* If there are templates that we've put off instantiating, do
3765 instantiate_pending_templates (retries);
3768 /* Write out virtual tables as required. Note that writing out
3769 the virtual table for a template class may cause the
3770 instantiation of members of that class. If we write out
3771 vtables then we remove the class from our list so we don't
3772 have to look at it again. */
3774 while (keyed_classes != NULL_TREE
3775 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
3778 keyed_classes = TREE_CHAIN (keyed_classes);
3784 tree next = TREE_CHAIN (t);
3788 if (maybe_emit_vtables (TREE_VALUE (next)))
3791 TREE_CHAIN (t) = TREE_CHAIN (next);
3796 next = TREE_CHAIN (t);
3800 /* Write out needed type info variables. We have to be careful
3801 looping through unemitted decls, because emit_tinfo_decl may
3802 cause other variables to be needed. New elements will be
3803 appended, and we remove from the vector those that actually
3805 for (i = VEC_length (tree, unemitted_tinfo_decls);
3806 VEC_iterate (tree, unemitted_tinfo_decls, --i, t);)
3807 if (emit_tinfo_decl (t))
3810 VEC_unordered_remove (tree, unemitted_tinfo_decls, i);
3813 /* The list of objects with static storage duration is built up
3814 in reverse order. We clear STATIC_AGGREGATES so that any new
3815 aggregates added during the initialization of these will be
3816 initialized in the correct order when we next come around the
3818 vars = prune_vars_needing_no_initialization (&static_aggregates);
3822 /* We need to start a new initialization function each time
3823 through the loop. That's because we need to know which
3824 vtables have been referenced, and TREE_SYMBOL_REFERENCED
3825 isn't computed until a function is finished, and written
3826 out. That's a deficiency in the back end. When this is
3827 fixed, these initialization functions could all become
3828 inline, with resulting performance improvements. */
3831 /* Set the line and file, so that it is obviously not from
3833 input_location = locus;
3834 ssdf_body = start_static_storage_duration_function (ssdf_count);
3836 /* Make sure the back end knows about all the variables. */
3837 write_out_vars (vars);
3839 /* First generate code to do all the initializations. */
3841 do_static_initialization_or_destruction (vars, /*initp=*/true);
3843 /* Then, generate code to do all the destructions. Do these
3844 in reverse order so that the most recently constructed
3845 variable is the first destroyed. If we're using
3846 __cxa_atexit, then we don't need to do this; functions
3847 were registered at initialization time to destroy the
3849 if (!flag_use_cxa_atexit && vars)
3851 vars = nreverse (vars);
3852 do_static_initialization_or_destruction (vars, /*initp=*/false);
3857 /* Finish up the static storage duration function for this
3859 input_location = locus;
3860 finish_static_storage_duration_function (ssdf_body);
3862 /* All those initializations and finalizations might cause
3863 us to need more inline functions, more template
3864 instantiations, etc. */
3867 /* ??? was: locus.line++; */
3870 /* Go through the set of inline functions whose bodies have not
3871 been emitted yet. If out-of-line copies of these functions
3872 are required, emit them. */
3873 FOR_EACH_VEC_ELT (tree, deferred_fns, i, decl)
3875 /* Does it need synthesizing? */
3876 if (DECL_DEFAULTED_FN (decl) && ! DECL_INITIAL (decl)
3877 && (! DECL_REALLY_EXTERN (decl) || possibly_inlined_p (decl)))
3879 /* Even though we're already at the top-level, we push
3880 there again. That way, when we pop back a few lines
3881 hence, all of our state is restored. Otherwise,
3882 finish_function doesn't clean things up, and we end
3883 up with CURRENT_FUNCTION_DECL set. */
3884 push_to_top_level ();
3885 /* The decl's location will mark where it was first
3886 needed. Save that so synthesize method can indicate
3887 where it was needed from, in case of error */
3888 input_location = DECL_SOURCE_LOCATION (decl);
3889 synthesize_method (decl);
3890 pop_from_top_level ();
3894 if (!DECL_SAVED_TREE (decl))
3897 /* We lie to the back end, pretending that some functions
3898 are not defined when they really are. This keeps these
3899 functions from being put out unnecessarily. But, we must
3900 stop lying when the functions are referenced, or if they
3901 are not comdat since they need to be put out now. If
3902 DECL_INTERFACE_KNOWN, then we have already set
3903 DECL_EXTERNAL appropriately, so there's no need to check
3904 again, and we do not want to clear DECL_EXTERNAL if a
3905 previous call to import_export_decl set it.
3907 This is done in a separate for cycle, because if some
3908 deferred function is contained in another deferred
3909 function later in deferred_fns varray,
3910 rest_of_compilation would skip this function and we
3911 really cannot expand the same function twice. */
3912 import_export_decl (decl);
3913 if (DECL_NOT_REALLY_EXTERN (decl)
3914 && DECL_INITIAL (decl)
3915 && decl_needed_p (decl))
3917 struct cgraph_node *node, *next;
3919 node = cgraph_get_node (decl);
3920 if (node->same_body_alias)
3921 node = cgraph_alias_aliased_node (node);
3923 cgraph_for_node_and_aliases (node, clear_decl_external,
3925 /* If we mark !DECL_EXTERNAL one of the symbols in some comdat
3926 group, we need to mark all symbols in the same comdat group
3928 if (node->same_comdat_group)
3929 for (next = node->same_comdat_group;
3931 next = next->same_comdat_group)
3932 cgraph_for_node_and_aliases (next, clear_decl_external,
3936 /* If we're going to need to write this function out, and
3937 there's already a body for it, create RTL for it now.
3938 (There might be no body if this is a method we haven't
3939 gotten around to synthesizing yet.) */
3940 if (!DECL_EXTERNAL (decl)
3941 && decl_needed_p (decl)
3942 && !TREE_ASM_WRITTEN (decl)
3943 && !cgraph_get_node (decl)->local.finalized)
3945 /* We will output the function; no longer consider it in this
3947 DECL_DEFER_OUTPUT (decl) = 0;
3948 /* Generate RTL for this function now that we know we
3950 expand_or_defer_fn (decl);
3951 /* If we're compiling -fsyntax-only pretend that this
3952 function has been written out so that we don't try to
3954 if (flag_syntax_only)
3955 TREE_ASM_WRITTEN (decl) = 1;
3960 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
3963 /* Static data members are just like namespace-scope globals. */
3964 FOR_EACH_VEC_ELT (tree, pending_statics, i, decl)
3966 if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl)
3967 /* Don't write it out if we haven't seen a definition. */
3968 || DECL_IN_AGGR_P (decl))
3970 import_export_decl (decl);
3971 /* If this static data member is needed, provide it to the
3973 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
3974 DECL_EXTERNAL (decl) = 0;
3976 if (VEC_length (tree, pending_statics) != 0
3977 && wrapup_global_declarations (VEC_address (tree, pending_statics),
3978 VEC_length (tree, pending_statics)))
3985 /* All used inline functions must have a definition at this point. */
3986 FOR_EACH_VEC_ELT (tree, deferred_fns, i, decl)
3988 if (/* Check online inline functions that were actually used. */
3989 DECL_ODR_USED (decl) && DECL_DECLARED_INLINE_P (decl)
3990 /* If the definition actually was available here, then the
3991 fact that the function was not defined merely represents
3992 that for some reason (use of a template repository,
3993 #pragma interface, etc.) we decided not to emit the
3995 && !DECL_INITIAL (decl)
3996 /* Don't complain if the template was defined. */
3997 && !(DECL_TEMPLATE_INSTANTIATION (decl)
3998 && DECL_INITIAL (DECL_TEMPLATE_RESULT
3999 (template_for_substitution (decl)))))
4001 warning (0, "inline function %q+D used but never defined", decl);
4002 /* Avoid a duplicate warning from check_global_declaration_1. */
4003 TREE_NO_WARNING (decl) = 1;
4007 /* So must decls that use a type with no linkage. */
4008 FOR_EACH_VEC_ELT (tree, no_linkage_decls, i, decl)
4009 if (!decl_defined_p (decl))
4010 no_linkage_error (decl);
4012 /* Then, do the Objective-C stuff. This is where all the
4013 Objective-C module stuff gets generated (symtab,
4014 class/protocol/selector lists etc). This must be done after C++
4015 templates, destructors etc. so that selectors used in C++
4016 templates are properly allocated. */
4017 if (c_dialect_objc ())
4018 objc_write_global_declarations ();
4020 /* We give C linkage to static constructors and destructors. */
4021 push_lang_context (lang_name_c);
4023 /* Generate initialization and destruction functions for all
4024 priorities for which they are required. */
4025 if (priority_info_map)
4026 splay_tree_foreach (priority_info_map,
4027 generate_ctor_and_dtor_functions_for_priority,
4029 else if (c_dialect_objc () && objc_static_init_needed_p ())
4030 /* If this is obj-c++ and we need a static init, call
4031 generate_ctor_or_dtor_function. */
4032 generate_ctor_or_dtor_function (/*constructor_p=*/true,
4033 DEFAULT_INIT_PRIORITY, &locus);
4035 /* We're done with the splay-tree now. */
4036 if (priority_info_map)
4037 splay_tree_delete (priority_info_map);
4039 /* Generate any missing aliases. */
4040 maybe_apply_pending_pragma_weaks ();
4042 /* We're done with static constructors, so we can go back to "C++"
4044 pop_lang_context ();
4046 /* Collect candidates for Java hidden aliases. */
4047 candidates = collect_candidates_for_java_method_aliases ();
4049 timevar_stop (TV_PHASE_DEFERRED);
4050 timevar_start (TV_PHASE_CGRAPH);
4052 cgraph_finalize_compilation_unit ();
4054 timevar_stop (TV_PHASE_CGRAPH);
4055 timevar_start (TV_PHASE_CHECK_DBGINFO);
4057 /* Now, issue warnings about static, but not defined, functions,
4058 etc., and emit debugging information. */
4059 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
4060 if (VEC_length (tree, pending_statics) != 0)
4062 check_global_declarations (VEC_address (tree, pending_statics),
4063 VEC_length (tree, pending_statics));
4064 emit_debug_global_declarations (VEC_address (tree, pending_statics),
4065 VEC_length (tree, pending_statics));
4068 perform_deferred_noexcept_checks ();
4070 /* Generate hidden aliases for Java. */
4073 build_java_method_aliases (candidates);
4074 pointer_set_destroy (candidates);
4079 /* The entire file is now complete. If requested, dump everything
4083 FILE *stream = dump_begin (TDI_tu, &flags);
4087 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
4088 dump_end (TDI_tu, stream);
4092 if (flag_detailed_statistics)
4094 dump_tree_statistics ();
4095 dump_time_statistics ();
4097 input_location = locus;
4099 #ifdef ENABLE_CHECKING
4100 validate_conversion_obstack ();
4101 #endif /* ENABLE_CHECKING */
4103 timevar_stop (TV_PHASE_CHECK_DBGINFO);
4106 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
4107 function to call in parse-tree form; it has not yet been
4108 semantically analyzed. ARGS are the arguments to the function.
4109 They have already been semantically analyzed. This may change
4113 build_offset_ref_call_from_tree (tree fn, VEC(tree,gc) **args)
4116 VEC(tree,gc) *orig_args = NULL;
4121 object = TREE_OPERAND (fn, 0);
4123 if (processing_template_decl)
4125 gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR
4126 || TREE_CODE (fn) == MEMBER_REF);
4127 if (type_dependent_expression_p (fn)
4128 || any_type_dependent_arguments_p (*args))
4129 return build_nt_call_vec (fn, *args);
4131 orig_args = make_tree_vector_copy (*args);
4133 /* Transform the arguments and add the implicit "this"
4134 parameter. That must be done before the FN is transformed
4135 because we depend on the form of FN. */
4136 make_args_non_dependent (*args);
4137 object = build_non_dependent_expr (object);
4138 if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE)
4140 if (TREE_CODE (fn) == DOTSTAR_EXPR)
4141 object = cp_build_addr_expr (object, tf_warning_or_error);
4142 VEC_safe_insert (tree, gc, *args, 0, object);
4144 /* Now that the arguments are done, transform FN. */
4145 fn = build_non_dependent_expr (fn);
4148 /* A qualified name corresponding to a bound pointer-to-member is
4149 represented as an OFFSET_REF:
4151 struct B { void g(); };
4153 void B::g() { (this->*p)(); } */
4154 if (TREE_CODE (fn) == OFFSET_REF)
4156 tree object_addr = cp_build_addr_expr (object, tf_warning_or_error);
4157 fn = TREE_OPERAND (fn, 1);
4158 fn = get_member_function_from_ptrfunc (&object_addr, fn);
4159 VEC_safe_insert (tree, gc, *args, 0, object_addr);
4162 if (CLASS_TYPE_P (TREE_TYPE (fn)))
4163 expr = build_op_call (fn, args, tf_warning_or_error);
4165 expr = cp_build_function_call_vec (fn, args, tf_warning_or_error);
4166 if (processing_template_decl && expr != error_mark_node)
4167 expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args);
4169 if (orig_args != NULL)
4170 release_tree_vector (orig_args);
4177 check_default_args (tree x)
4179 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
4180 bool saw_def = false;
4181 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
4182 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
4184 if (TREE_PURPOSE (arg))
4188 error ("default argument missing for parameter %P of %q+#D", i, x);
4189 TREE_PURPOSE (arg) = error_mark_node;
4194 /* Return true if function DECL can be inlined. This is used to force
4195 instantiation of methods that might be interesting for inlining. */
4197 possibly_inlined_p (tree decl)
4199 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
4200 if (DECL_UNINLINABLE (decl))
4202 if (!optimize || pragma_java_exceptions)
4203 return DECL_DECLARED_INLINE_P (decl);
4204 /* When optimizing, we might inline everything when flatten
4205 attribute or heuristics inlining for size or autoinlining
4210 /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
4211 If DECL is a specialization or implicitly declared class member,
4212 generate the actual definition. Return false if something goes
4213 wrong, true otherwise. */
4216 mark_used (tree decl)
4218 /* If DECL is a BASELINK for a single function, then treat it just
4219 like the DECL for the function. Otherwise, if the BASELINK is
4220 for an overloaded function, we don't know which function was
4221 actually used until after overload resolution. */
4222 if (BASELINK_P (decl))
4224 decl = BASELINK_FUNCTIONS (decl);
4225 if (really_overloaded_fn (decl))
4227 decl = OVL_CURRENT (decl);
4230 /* Set TREE_USED for the benefit of -Wunused. */
4231 TREE_USED (decl) = 1;
4232 if (DECL_CLONED_FUNCTION_P (decl))
4233 TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4235 if (TREE_CODE (decl) == FUNCTION_DECL
4236 && DECL_DELETED_FN (decl))
4238 if (DECL_ARTIFICIAL (decl))
4240 if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
4241 && LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
4243 /* We mark a lambda conversion op as deleted if we can't
4244 generate it properly; see maybe_add_lambda_conv_op. */
4245 sorry ("converting lambda which uses %<...%> to "
4246 "function pointer");
4250 error ("use of deleted function %qD", decl);
4251 if (!maybe_explain_implicit_delete (decl))
4252 error_at (DECL_SOURCE_LOCATION (decl), "declared here");
4256 /* We can only check DECL_ODR_USED on variables or functions with
4257 DECL_LANG_SPECIFIC set, and these are also the only decls that we
4258 might need special handling for. */
4259 if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4260 || DECL_LANG_SPECIFIC (decl) == NULL
4261 || DECL_THUNK_P (decl))
4264 /* We only want to do this processing once. We don't need to keep trying
4265 to instantiate inline templates, because unit-at-a-time will make sure
4266 we get them compiled before functions that want to inline them. */
4267 if (DECL_ODR_USED (decl))
4270 /* If within finish_function, defer the rest until that function
4271 finishes, otherwise it might recurse. */
4272 if (defer_mark_used_calls)
4274 VEC_safe_push (tree, gc, deferred_mark_used_calls, decl);
4278 if (TREE_CODE (decl) == FUNCTION_DECL)
4279 maybe_instantiate_noexcept (decl);
4281 /* Normally, we can wait until instantiation-time to synthesize DECL.
4282 However, if DECL is a static data member initialized with a constant
4283 or a constexpr function, we need it right now because a reference to
4284 such a data member or a call to such function is not value-dependent. */
4285 if ((decl_maybe_constant_var_p (decl)
4286 || (TREE_CODE (decl) == FUNCTION_DECL
4287 && DECL_DECLARED_CONSTEXPR_P (decl)))
4288 && DECL_LANG_SPECIFIC (decl)
4289 && DECL_TEMPLATE_INFO (decl)
4290 && !uses_template_parms (DECL_TI_ARGS (decl)))
4292 /* Instantiating a function will result in garbage collection. We
4293 must treat this situation as if we were within the body of a
4294 function so as to avoid collecting live data only referenced from
4295 the stack (such as overload resolution candidates). */
4297 instantiate_decl (decl, /*defer_ok=*/false,
4298 /*expl_inst_class_mem_p=*/false);
4302 /* If we don't need a value, then we don't need to synthesize DECL. */
4303 if (cp_unevaluated_operand != 0)
4306 if (processing_template_decl)
4309 /* Check this too in case we're within fold_non_dependent_expr. */
4310 if (DECL_TEMPLATE_INFO (decl)
4311 && uses_template_parms (DECL_TI_ARGS (decl)))
4314 DECL_ODR_USED (decl) = 1;
4315 if (DECL_CLONED_FUNCTION_P (decl))
4316 DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4318 /* DR 757: A type without linkage shall not be used as the type of a
4319 variable or function with linkage, unless
4320 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
4321 o the variable or function is not used (3.2 [basic.def.odr]) or is
4322 defined in the same translation unit. */
4323 if (cxx_dialect > cxx98
4324 && decl_linkage (decl) != lk_none
4325 && !DECL_EXTERN_C_P (decl)
4326 && !DECL_ARTIFICIAL (decl)
4327 && !decl_defined_p (decl)
4328 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
4330 if (is_local_extern (decl))
4331 /* There's no way to define a local extern, and adding it to
4332 the vector interferes with GC, so give an error now. */
4333 no_linkage_error (decl);
4335 VEC_safe_push (tree, gc, no_linkage_decls, decl);
4338 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4339 && !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
4340 /* Remember it, so we can check it was defined. */
4341 note_vague_linkage_fn (decl);
4343 /* Is it a synthesized method that needs to be synthesized? */
4344 if (TREE_CODE (decl) == FUNCTION_DECL
4345 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4346 && DECL_DEFAULTED_FN (decl)
4347 /* A function defaulted outside the class is synthesized either by
4348 cp_finish_decl or instantiate_decl. */
4349 && !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl)
4350 && ! DECL_INITIAL (decl))
4352 /* Defer virtual destructors so that thunks get the right
4354 if (DECL_VIRTUAL_P (decl) && !at_eof)
4356 note_vague_linkage_fn (decl);
4360 /* Remember the current location for a function we will end up
4361 synthesizing. Then we can inform the user where it was
4362 required in the case of error. */
4363 DECL_SOURCE_LOCATION (decl) = input_location;
4365 /* Synthesizing an implicitly defined member function will result in
4366 garbage collection. We must treat this situation as if we were
4367 within the body of a function so as to avoid collecting live data
4368 on the stack (such as overload resolution candidates).
4370 We could just let cp_write_global_declarations handle synthesizing
4371 this function by adding it to deferred_fns, but doing
4372 it at the use site produces better error messages. */
4374 synthesize_method (decl);
4376 /* If this is a synthesized method we don't need to
4377 do the instantiation test below. */
4379 else if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4380 && DECL_TEMPLATE_INFO (decl)
4381 && (!DECL_EXPLICIT_INSTANTIATION (decl)
4382 || always_instantiate_p (decl)))
4383 /* If this is a function or variable that is an instance of some
4384 template, we now know that we will need to actually do the
4385 instantiation. We check that DECL is not an explicit
4386 instantiation because that is not checked in instantiate_decl.
4388 We put off instantiating functions in order to improve compile
4389 times. Maintaining a stack of active functions is expensive,
4390 and the inliner knows to instantiate any functions it might
4391 need. Therefore, we always try to defer instantiation. */
4394 instantiate_decl (decl, /*defer_ok=*/true,
4395 /*expl_inst_class_mem_p=*/false);
4402 #include "gt-cp-decl2.h"