1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011, 2012 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
44 #include "c-family/c-common.h"
45 #include "c-family/c-objc.h"
47 #include "tree-inline.h"
48 #include "c-family/c-pragma.h"
49 #include "tree-dump.h"
52 #include "pointer-set.h"
53 #include "splay-tree.h"
54 #include "langhooks.h"
55 #include "c-family/c-ada-spec.h"
57 extern cpp_reader
*parse_in
;
59 /* This structure contains information about the initializations
60 and/or destructions required for a particular priority level. */
61 typedef struct priority_info_s
{
62 /* Nonzero if there have been any initializations at this priority
63 throughout the translation unit. */
64 int initializations_p
;
65 /* Nonzero if there have been any destructions at this priority
66 throughout the translation unit. */
70 static void mark_vtable_entries (tree
);
71 static bool maybe_emit_vtables (tree
);
72 static bool acceptable_java_type (tree
);
73 static tree
start_objects (int, int);
74 static void finish_objects (int, int, tree
);
75 static tree
start_static_storage_duration_function (unsigned);
76 static void finish_static_storage_duration_function (tree
);
77 static priority_info
get_priority_info (int);
78 static void do_static_initialization_or_destruction (tree
, bool);
79 static void one_static_initialization_or_destruction (tree
, tree
, bool);
80 static void generate_ctor_or_dtor_function (bool, int, location_t
*);
81 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node
,
83 static tree
prune_vars_needing_no_initialization (tree
*);
84 static void write_out_vars (tree
);
85 static void import_export_class (tree
);
86 static tree
get_guard_bits (tree
);
87 static void determine_visibility_from_class (tree
, tree
);
88 static bool determine_hidden_inline (tree
);
89 static bool decl_defined_p (tree
);
91 /* A list of static class variables. This is needed, because a
92 static class variable can be declared inside the class without
93 an initializer, and then initialized, statically, outside the class. */
94 static GTY(()) VEC(tree
,gc
) *pending_statics
;
96 /* A list of functions which were declared inline, but which we
97 may need to emit outline anyway. */
98 static GTY(()) VEC(tree
,gc
) *deferred_fns
;
100 /* A list of decls that use types with no linkage, which we need to make
102 static GTY(()) VEC(tree
,gc
) *no_linkage_decls
;
104 /* Nonzero if we're done parsing and into end-of-file activities. */
110 /* Return a member function type (a METHOD_TYPE), given FNTYPE (a
111 FUNCTION_TYPE), CTYPE (class type), and QUALS (the cv-qualifiers
112 that apply to the function). */
115 build_memfn_type (tree fntype
, tree ctype
, cp_cv_quals quals
)
121 if (fntype
== error_mark_node
|| ctype
== error_mark_node
)
122 return error_mark_node
;
124 gcc_assert (TREE_CODE (fntype
) == FUNCTION_TYPE
125 || TREE_CODE (fntype
) == METHOD_TYPE
);
127 type_quals
= quals
& ~TYPE_QUAL_RESTRICT
;
128 ctype
= cp_build_qualified_type (ctype
, type_quals
);
129 raises
= TYPE_RAISES_EXCEPTIONS (fntype
);
130 attrs
= TYPE_ATTRIBUTES (fntype
);
131 fntype
= build_method_type_directly (ctype
, TREE_TYPE (fntype
),
132 (TREE_CODE (fntype
) == METHOD_TYPE
133 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype
))
134 : TYPE_ARG_TYPES (fntype
)));
136 fntype
= build_exception_variant (fntype
, raises
);
138 fntype
= cp_build_type_attribute_variant (fntype
, attrs
);
143 /* Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
144 return type changed to NEW_RET. */
147 change_return_type (tree new_ret
, tree fntype
)
150 tree args
= TYPE_ARG_TYPES (fntype
);
151 tree raises
= TYPE_RAISES_EXCEPTIONS (fntype
);
152 tree attrs
= TYPE_ATTRIBUTES (fntype
);
154 if (new_ret
== error_mark_node
)
157 if (same_type_p (new_ret
, TREE_TYPE (fntype
)))
160 if (TREE_CODE (fntype
) == FUNCTION_TYPE
)
162 newtype
= build_function_type (new_ret
, args
);
163 newtype
= apply_memfn_quals (newtype
, type_memfn_quals (fntype
));
166 newtype
= build_method_type_directly
167 (class_of_this_parm (fntype
), new_ret
, TREE_CHAIN (args
));
169 newtype
= build_exception_variant (newtype
, raises
);
171 newtype
= cp_build_type_attribute_variant (newtype
, attrs
);
176 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
180 cp_build_parm_decl (tree name
, tree type
)
182 tree parm
= build_decl (input_location
,
183 PARM_DECL
, name
, type
);
184 /* DECL_ARG_TYPE is only used by the back end and the back end never
186 if (!processing_template_decl
)
187 DECL_ARG_TYPE (parm
) = type_passed_as (type
);
189 /* If the type is a pack expansion, then we have a function
191 if (type
&& TREE_CODE (type
) == TYPE_PACK_EXPANSION
)
192 FUNCTION_PARAMETER_PACK_P (parm
) = 1;
197 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
201 build_artificial_parm (tree name
, tree type
)
203 tree parm
= cp_build_parm_decl (name
, type
);
204 DECL_ARTIFICIAL (parm
) = 1;
205 /* All our artificial parms are implicitly `const'; they cannot be
207 TREE_READONLY (parm
) = 1;
211 /* Constructors for types with virtual baseclasses need an "in-charge" flag
212 saying whether this constructor is responsible for initialization of
213 virtual baseclasses or not. All destructors also need this "in-charge"
214 flag, which additionally determines whether or not the destructor should
215 free the memory for the object.
217 This function adds the "in-charge" flag to member function FN if
218 appropriate. It is called from grokclassfn and tsubst.
219 FN must be either a constructor or destructor.
221 The in-charge flag follows the 'this' parameter, and is followed by the
222 VTT parm (if any), then the user-written parms. */
225 maybe_retrofit_in_chrg (tree fn
)
227 tree basetype
, arg_types
, parms
, parm
, fntype
;
229 /* If we've already add the in-charge parameter don't do it again. */
230 if (DECL_HAS_IN_CHARGE_PARM_P (fn
))
233 /* When processing templates we can't know, in general, whether or
234 not we're going to have virtual baseclasses. */
235 if (processing_template_decl
)
238 /* We don't need an in-charge parameter for constructors that don't
239 have virtual bases. */
240 if (DECL_CONSTRUCTOR_P (fn
)
241 && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn
)))
244 arg_types
= TYPE_ARG_TYPES (TREE_TYPE (fn
));
245 basetype
= TREE_TYPE (TREE_VALUE (arg_types
));
246 arg_types
= TREE_CHAIN (arg_types
);
248 parms
= DECL_CHAIN (DECL_ARGUMENTS (fn
));
250 /* If this is a subobject constructor or destructor, our caller will
251 pass us a pointer to our VTT. */
252 if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn
)))
254 parm
= build_artificial_parm (vtt_parm_identifier
, vtt_parm_type
);
256 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */
257 DECL_CHAIN (parm
) = parms
;
260 /* ...and then to TYPE_ARG_TYPES. */
261 arg_types
= hash_tree_chain (vtt_parm_type
, arg_types
);
263 DECL_HAS_VTT_PARM_P (fn
) = 1;
266 /* Then add the in-charge parm (before the VTT parm). */
267 parm
= build_artificial_parm (in_charge_identifier
, integer_type_node
);
268 DECL_CHAIN (parm
) = parms
;
270 arg_types
= hash_tree_chain (integer_type_node
, arg_types
);
272 /* Insert our new parameter(s) into the list. */
273 DECL_CHAIN (DECL_ARGUMENTS (fn
)) = parms
;
275 /* And rebuild the function type. */
276 fntype
= build_method_type_directly (basetype
, TREE_TYPE (TREE_TYPE (fn
)),
278 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
)))
279 fntype
= build_exception_variant (fntype
,
280 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
)));
281 if (TYPE_ATTRIBUTES (TREE_TYPE (fn
)))
282 fntype
= (cp_build_type_attribute_variant
283 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (fn
))));
284 TREE_TYPE (fn
) = fntype
;
286 /* Now we've got the in-charge parameter. */
287 DECL_HAS_IN_CHARGE_PARM_P (fn
) = 1;
290 /* Classes overload their constituent function names automatically.
291 When a function name is declared in a record structure,
292 its name is changed to it overloaded name. Since names for
293 constructors and destructors can conflict, we place a leading
296 CNAME is the name of the class we are grokking for.
298 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
300 FLAGS contains bits saying what's special about today's
301 arguments. DTOR_FLAG == DESTRUCTOR.
303 If FUNCTION is a destructor, then we must add the `auto-delete' field
304 as a second parameter. There is some hair associated with the fact
305 that we must "declare" this variable in the manner consistent with the
306 way the rest of the arguments were declared.
308 QUALS are the qualifiers for the this pointer. */
311 grokclassfn (tree ctype
, tree function
, enum overload_flags flags
)
313 tree fn_name
= DECL_NAME (function
);
315 /* Even within an `extern "C"' block, members get C++ linkage. See
316 [dcl.link] for details. */
317 SET_DECL_LANGUAGE (function
, lang_cplusplus
);
319 if (fn_name
== NULL_TREE
)
321 error ("name missing for member function");
322 fn_name
= get_identifier ("<anonymous>");
323 DECL_NAME (function
) = fn_name
;
326 DECL_CONTEXT (function
) = ctype
;
328 if (flags
== DTOR_FLAG
)
329 DECL_DESTRUCTOR_P (function
) = 1;
331 if (flags
== DTOR_FLAG
|| DECL_CONSTRUCTOR_P (function
))
332 maybe_retrofit_in_chrg (function
);
335 /* Create an ARRAY_REF, checking for the user doing things backwards
339 grok_array_decl (location_t loc
, tree array_expr
, tree index_exp
)
343 tree orig_array_expr
= array_expr
;
344 tree orig_index_exp
= index_exp
;
346 if (error_operand_p (array_expr
) || error_operand_p (index_exp
))
347 return error_mark_node
;
349 if (processing_template_decl
)
351 if (type_dependent_expression_p (array_expr
)
352 || type_dependent_expression_p (index_exp
))
353 return build_min_nt (ARRAY_REF
, array_expr
, index_exp
,
354 NULL_TREE
, NULL_TREE
);
355 array_expr
= build_non_dependent_expr (array_expr
);
356 index_exp
= build_non_dependent_expr (index_exp
);
359 type
= TREE_TYPE (array_expr
);
361 type
= non_reference (type
);
363 /* If they have an `operator[]', use that. */
364 if (MAYBE_CLASS_TYPE_P (type
) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp
)))
365 expr
= build_new_op (loc
, ARRAY_REF
, LOOKUP_NORMAL
,
366 array_expr
, index_exp
, NULL_TREE
,
367 /*overload=*/NULL
, tf_warning_or_error
);
372 /* Otherwise, create an ARRAY_REF for a pointer or array type.
373 It is a little-known fact that, if `a' is an array and `i' is
374 an int, you can write `i[a]', which means the same thing as
376 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == VECTOR_TYPE
)
379 p1
= build_expr_type_conversion (WANT_POINTER
, array_expr
, false);
381 if (TREE_CODE (TREE_TYPE (index_exp
)) == ARRAY_TYPE
)
384 p2
= build_expr_type_conversion (WANT_POINTER
, index_exp
, false);
386 i1
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, array_expr
,
388 i2
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
, index_exp
,
391 if ((p1
&& i2
) && (i1
&& p2
))
392 error ("ambiguous conversion for array subscript");
395 array_expr
= p1
, index_exp
= i2
;
397 array_expr
= p2
, index_exp
= i1
;
400 error ("invalid types %<%T[%T]%> for array subscript",
401 type
, TREE_TYPE (index_exp
));
402 return error_mark_node
;
405 if (array_expr
== error_mark_node
|| index_exp
== error_mark_node
)
406 error ("ambiguous conversion for array subscript");
408 expr
= build_array_ref (input_location
, array_expr
, index_exp
);
410 if (processing_template_decl
&& expr
!= error_mark_node
)
411 return build_min_non_dep (ARRAY_REF
, expr
, orig_array_expr
, orig_index_exp
,
412 NULL_TREE
, NULL_TREE
);
416 /* Given the cast expression EXP, checking out its validity. Either return
417 an error_mark_node if there was an unavoidable error, return a cast to
418 void for trying to delete a pointer w/ the value 0, or return the
419 call to delete. If DOING_VEC is true, we handle things differently
420 for doing an array delete.
421 Implements ARM $5.3.4. This is called from the parser. */
424 delete_sanity (tree exp
, tree size
, bool doing_vec
, int use_global_delete
,
425 tsubst_flags_t complain
)
429 if (exp
== error_mark_node
)
432 if (processing_template_decl
)
434 t
= build_min (DELETE_EXPR
, void_type_node
, exp
, size
);
435 DELETE_EXPR_USE_GLOBAL (t
) = use_global_delete
;
436 DELETE_EXPR_USE_VEC (t
) = doing_vec
;
437 TREE_SIDE_EFFECTS (t
) = 1;
441 /* An array can't have been allocated by new, so complain. */
442 if (TREE_CODE (exp
) == VAR_DECL
443 && TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
444 warning (0, "deleting array %q#D", exp
);
446 t
= build_expr_type_conversion (WANT_POINTER
, exp
, true);
448 if (t
== NULL_TREE
|| t
== error_mark_node
)
450 error ("type %q#T argument given to %<delete%>, expected pointer",
452 return error_mark_node
;
455 type
= TREE_TYPE (t
);
457 /* As of Valley Forge, you can delete a pointer to const. */
459 /* You can't delete functions. */
460 if (TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
462 error ("cannot delete a function. Only pointer-to-objects are "
463 "valid arguments to %<delete%>");
464 return error_mark_node
;
467 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */
468 if (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
)
470 warning (0, "deleting %qT is undefined", type
);
474 /* Deleting a pointer with the value zero is valid and has no effect. */
475 if (integer_zerop (t
))
476 return build1 (NOP_EXPR
, void_type_node
, t
);
479 return build_vec_delete (t
, /*maxindex=*/NULL_TREE
,
480 sfk_deleting_destructor
,
481 use_global_delete
, complain
);
483 return build_delete (type
, t
, sfk_deleting_destructor
,
484 LOOKUP_NORMAL
, use_global_delete
,
488 /* Report an error if the indicated template declaration is not the
489 sort of thing that should be a member template. */
492 check_member_template (tree tmpl
)
496 gcc_assert (TREE_CODE (tmpl
) == TEMPLATE_DECL
);
497 decl
= DECL_TEMPLATE_RESULT (tmpl
);
499 if (TREE_CODE (decl
) == FUNCTION_DECL
500 || DECL_ALIAS_TEMPLATE_P (tmpl
)
501 || (TREE_CODE (decl
) == TYPE_DECL
502 && MAYBE_CLASS_TYPE_P (TREE_TYPE (decl
))))
504 /* The parser rejects template declarations in local classes. */
505 gcc_assert (!current_function_decl
);
506 /* The parser rejects any use of virtual in a function template. */
507 gcc_assert (!(TREE_CODE (decl
) == FUNCTION_DECL
508 && DECL_VIRTUAL_P (decl
)));
510 /* The debug-information generating code doesn't know what to do
511 with member templates. */
512 DECL_IGNORED_P (tmpl
) = 1;
515 error ("template declaration of %q#D", decl
);
518 /* Return true iff TYPE is a valid Java parameter or return type. */
521 acceptable_java_type (tree type
)
523 if (type
== error_mark_node
)
526 if (TREE_CODE (type
) == VOID_TYPE
|| TYPE_FOR_JAVA (type
))
528 if (TREE_CODE (type
) == POINTER_TYPE
|| TREE_CODE (type
) == REFERENCE_TYPE
)
530 type
= TREE_TYPE (type
);
531 if (TREE_CODE (type
) == RECORD_TYPE
)
534 if (! TYPE_FOR_JAVA (type
))
536 if (! CLASSTYPE_TEMPLATE_INFO (type
))
538 args
= CLASSTYPE_TI_ARGS (type
);
539 i
= TREE_VEC_LENGTH (args
);
542 type
= TREE_VEC_ELT (args
, i
);
543 if (TREE_CODE (type
) == POINTER_TYPE
)
544 type
= TREE_TYPE (type
);
545 if (! TYPE_FOR_JAVA (type
))
554 /* For a METHOD in a Java class CTYPE, return true if
555 the parameter and return types are valid Java types.
556 Otherwise, print appropriate error messages, and return false. */
559 check_java_method (tree method
)
562 tree arg_types
= TYPE_ARG_TYPES (TREE_TYPE (method
));
563 tree ret_type
= TREE_TYPE (TREE_TYPE (method
));
565 if (!acceptable_java_type (ret_type
))
567 error ("Java method %qD has non-Java return type %qT",
572 arg_types
= TREE_CHAIN (arg_types
);
573 if (DECL_HAS_IN_CHARGE_PARM_P (method
))
574 arg_types
= TREE_CHAIN (arg_types
);
575 if (DECL_HAS_VTT_PARM_P (method
))
576 arg_types
= TREE_CHAIN (arg_types
);
578 for (; arg_types
!= NULL_TREE
; arg_types
= TREE_CHAIN (arg_types
))
580 tree type
= TREE_VALUE (arg_types
);
581 if (!acceptable_java_type (type
))
583 if (type
!= error_mark_node
)
584 error ("Java method %qD has non-Java parameter type %qT",
592 /* Sanity check: report error if this function FUNCTION is not
593 really a member of the class (CTYPE) it is supposed to belong to.
594 TEMPLATE_PARMS is used to specify the template parameters of a member
595 template passed as FUNCTION_DECL. If the member template is passed as a
596 TEMPLATE_DECL, it can be NULL since the parameters can be extracted
597 from the declaration. If the function is not a function template, it
599 It returns the original declaration for the function, NULL_TREE if
600 no declaration was found, error_mark_node if an error was emitted. */
603 check_classfn (tree ctype
, tree function
, tree template_parms
)
609 if (DECL_USE_TEMPLATE (function
)
610 && !(TREE_CODE (function
) == TEMPLATE_DECL
611 && DECL_TEMPLATE_SPECIALIZATION (function
))
612 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function
)))
613 /* Since this is a specialization of a member template,
614 we're not going to find the declaration in the class.
617 struct S { template <typename T> void f(T); };
618 template <> void S::f(int);
620 we're not going to find `S::f(int)', but there's no
621 reason we should, either. We let our callers know we didn't
622 find the method, but we don't complain. */
625 /* Basic sanity check: for a template function, the template parameters
626 either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
627 if (TREE_CODE (function
) == TEMPLATE_DECL
)
630 && !comp_template_parms (template_parms
,
631 DECL_TEMPLATE_PARMS (function
)))
633 error ("template parameter lists provided don%'t match the "
634 "template parameters of %qD", function
);
635 return error_mark_node
;
637 template_parms
= DECL_TEMPLATE_PARMS (function
);
640 /* OK, is this a definition of a member template? */
641 is_template
= (template_parms
!= NULL_TREE
);
643 /* We must enter the scope here, because conversion operators are
644 named by target type, and type equivalence relies on typenames
645 resolving within the scope of CTYPE. */
646 pushed_scope
= push_scope (ctype
);
647 ix
= class_method_index_for_fn (complete_type (ctype
), function
);
650 VEC(tree
,gc
) *methods
= CLASSTYPE_METHOD_VEC (ctype
);
651 tree fndecls
, fndecl
= 0;
653 const char *format
= NULL
;
655 for (fndecls
= VEC_index (tree
, methods
, ix
);
656 fndecls
; fndecls
= OVL_NEXT (fndecls
))
660 fndecl
= OVL_CURRENT (fndecls
);
661 p1
= TYPE_ARG_TYPES (TREE_TYPE (function
));
662 p2
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
664 /* We cannot simply call decls_match because this doesn't
665 work for static member functions that are pretending to
666 be methods, and because the name may have been changed by
669 /* Get rid of the this parameter on functions that become
671 if (DECL_STATIC_FUNCTION_P (fndecl
)
672 && TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
)
673 p1
= TREE_CHAIN (p1
);
675 /* A member template definition only matches a member template
677 if (is_template
!= (TREE_CODE (fndecl
) == TEMPLATE_DECL
))
680 if (same_type_p (TREE_TYPE (TREE_TYPE (function
)),
681 TREE_TYPE (TREE_TYPE (fndecl
)))
682 && compparms (p1
, p2
)
684 || comp_template_parms (template_parms
,
685 DECL_TEMPLATE_PARMS (fndecl
)))
686 && (DECL_TEMPLATE_SPECIALIZATION (function
)
687 == DECL_TEMPLATE_SPECIALIZATION (fndecl
))
688 && (!DECL_TEMPLATE_SPECIALIZATION (function
)
689 || (DECL_TI_TEMPLATE (function
)
690 == DECL_TI_TEMPLATE (fndecl
))))
696 pop_scope (pushed_scope
);
697 return OVL_CURRENT (fndecls
);
700 error_at (DECL_SOURCE_LOCATION (function
),
701 "prototype for %q#D does not match any in class %qT",
703 is_conv_op
= DECL_CONV_FN_P (fndecl
);
706 ix
= CLASSTYPE_FIRST_CONVERSION_SLOT
;
707 fndecls
= VEC_index (tree
, methods
, ix
);
710 fndecl
= OVL_CURRENT (fndecls
);
711 fndecls
= OVL_NEXT (fndecls
);
713 if (!fndecls
&& is_conv_op
)
715 if (VEC_length (tree
, methods
) > (size_t) ++ix
)
717 fndecls
= VEC_index (tree
, methods
, ix
);
718 if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls
)))
730 format
= N_("candidates are: %+#D");
732 format
= N_("candidate is: %+#D");
733 error (format
, fndecl
);
736 else if (!COMPLETE_TYPE_P (ctype
))
737 cxx_incomplete_type_error (function
, ctype
);
739 error ("no %q#D member function declared in class %qT",
743 pop_scope (pushed_scope
);
744 return error_mark_node
;
747 /* DECL is a function with vague linkage. Remember it so that at the
748 end of the translation unit we can decide whether or not to emit
752 note_vague_linkage_fn (tree decl
)
754 DECL_DEFER_OUTPUT (decl
) = 1;
755 VEC_safe_push (tree
, gc
, deferred_fns
, decl
);
758 /* We have just processed the DECL, which is a static data member.
759 The other parameters are as for cp_finish_decl. */
762 finish_static_data_member_decl (tree decl
,
763 tree init
, bool init_const_expr_p
,
767 DECL_CONTEXT (decl
) = current_class_type
;
769 /* We cannot call pushdecl here, because that would fill in the
770 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
771 the right thing, namely, to put this decl out straight away. */
773 if (! processing_template_decl
)
774 VEC_safe_push (tree
, gc
, pending_statics
, decl
);
776 if (LOCAL_CLASS_P (current_class_type
))
777 permerror (input_location
, "local class %q#T shall not have static data member %q#D",
778 current_class_type
, decl
);
780 DECL_IN_AGGR_P (decl
) = 1;
782 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
783 && TYPE_DOMAIN (TREE_TYPE (decl
)) == NULL_TREE
)
784 SET_VAR_HAD_UNKNOWN_BOUND (decl
);
786 cp_finish_decl (decl
, init
, init_const_expr_p
, asmspec_tree
, flags
);
789 /* DECLARATOR and DECLSPECS correspond to a class member. The other
790 parameters are as for cp_finish_decl. Return the DECL for the
791 class member declared. */
794 grokfield (const cp_declarator
*declarator
,
795 cp_decl_specifier_seq
*declspecs
,
796 tree init
, bool init_const_expr_p
,
801 const char *asmspec
= 0;
806 && TREE_CODE (init
) == TREE_LIST
807 && TREE_VALUE (init
) == error_mark_node
808 && TREE_CHAIN (init
) == NULL_TREE
)
811 value
= grokdeclarator (declarator
, declspecs
, FIELD
, init
!= 0, &attrlist
);
812 if (! value
|| error_operand_p (value
))
813 /* friend or constructor went bad. */
814 return error_mark_node
;
816 if (TREE_CODE (value
) == TYPE_DECL
&& init
)
818 error ("typedef %qD is initialized (use decltype instead)", value
);
822 /* Pass friendly classes back. */
823 if (value
== void_type_node
)
826 /* Pass friend decls back. */
827 if ((TREE_CODE (value
) == FUNCTION_DECL
828 || TREE_CODE (value
) == TEMPLATE_DECL
)
829 && DECL_CONTEXT (value
) != current_class_type
)
832 name
= DECL_NAME (value
);
834 if (name
!= NULL_TREE
)
836 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
838 error ("explicit template argument list not allowed");
839 return error_mark_node
;
842 if (IDENTIFIER_POINTER (name
)[0] == '_'
843 && ! strcmp (IDENTIFIER_POINTER (name
), "_vptr"))
844 error ("member %qD conflicts with virtual function table field name",
848 /* Stash away type declarations. */
849 if (TREE_CODE (value
) == TYPE_DECL
)
851 DECL_NONLOCAL (value
) = 1;
852 DECL_CONTEXT (value
) = current_class_type
;
858 /* If this is a typedef that names the class for linkage purposes
859 (7.1.3p8), apply any attributes directly to the type. */
860 if (TAGGED_TYPE_P (TREE_TYPE (value
))
861 && value
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value
))))
862 attrflags
= ATTR_FLAG_TYPE_IN_PLACE
;
864 cplus_decl_attributes (&value
, attrlist
, attrflags
);
867 if (declspecs
->specs
[(int)ds_typedef
]
868 && TREE_TYPE (value
) != error_mark_node
869 && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value
))) != value
)
870 set_underlying_type (value
);
872 /* It's important that push_template_decl below follows
873 set_underlying_type above so that the created template
874 carries the properly set type of VALUE. */
875 if (processing_template_decl
)
876 value
= push_template_decl (value
);
878 record_locally_defined_typedef (value
);
882 if (DECL_IN_AGGR_P (value
))
884 error ("%qD is already defined in %qT", value
, DECL_CONTEXT (value
));
885 return void_type_node
;
888 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
889 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
893 if (TREE_CODE (value
) == FUNCTION_DECL
)
895 /* Initializers for functions are rejected early in the parser.
896 If we get here, it must be a pure specifier for a method. */
897 if (init
== ridpointers
[(int)RID_DELETE
])
899 DECL_DELETED_FN (value
) = 1;
900 DECL_DECLARED_INLINE_P (value
) = 1;
901 DECL_INITIAL (value
) = error_mark_node
;
903 else if (init
== ridpointers
[(int)RID_DEFAULT
])
905 if (defaultable_fn_check (value
))
907 DECL_DEFAULTED_FN (value
) = 1;
908 DECL_INITIALIZED_IN_CLASS_P (value
) = 1;
909 DECL_DECLARED_INLINE_P (value
) = 1;
912 else if (TREE_CODE (init
) == DEFAULT_ARG
)
913 error ("invalid initializer for member function %qD", value
);
914 else if (TREE_CODE (TREE_TYPE (value
)) == METHOD_TYPE
)
916 if (integer_zerop (init
))
917 DECL_PURE_VIRTUAL_P (value
) = 1;
918 else if (error_operand_p (init
))
919 ; /* An error has already been reported. */
921 error ("invalid initializer for member function %qD",
926 gcc_assert (TREE_CODE (TREE_TYPE (value
)) == FUNCTION_TYPE
);
927 error ("initializer specified for static member function %qD",
931 else if (TREE_CODE (value
) == FIELD_DECL
)
932 /* C++11 NSDMI, keep going. */;
933 else if (TREE_CODE (value
) != VAR_DECL
)
935 else if (!processing_template_decl
)
937 if (TREE_CODE (init
) == CONSTRUCTOR
)
938 init
= digest_init (TREE_TYPE (value
), init
, tf_warning_or_error
);
939 init
= maybe_constant_init (init
);
941 if (init
!= error_mark_node
&& !TREE_CONSTANT (init
))
943 /* We can allow references to things that are effectively
944 static, since references are initialized with the
946 if (TREE_CODE (TREE_TYPE (value
)) != REFERENCE_TYPE
947 || (TREE_STATIC (init
) == 0
948 && (!DECL_P (init
) || DECL_EXTERNAL (init
) == 0)))
950 error ("field initializer is not constant");
951 init
= error_mark_node
;
957 if (processing_template_decl
958 && (TREE_CODE (value
) == VAR_DECL
|| TREE_CODE (value
) == FUNCTION_DECL
))
960 value
= push_template_decl (value
);
961 if (error_operand_p (value
))
962 return error_mark_node
;
966 cplus_decl_attributes (&value
, attrlist
, 0);
968 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
969 && CONSTRUCTOR_IS_DIRECT_INIT (init
))
970 flags
= LOOKUP_NORMAL
;
972 flags
= LOOKUP_IMPLICIT
;
974 switch (TREE_CODE (value
))
977 finish_static_data_member_decl (value
, init
, init_const_expr_p
,
978 asmspec_tree
, flags
);
983 error ("%<asm%> specifiers are not permitted on non-static data members");
984 if (DECL_INITIAL (value
) == error_mark_node
)
985 init
= error_mark_node
;
986 cp_finish_decl (value
, init
, /*init_const_expr_p=*/false,
988 DECL_IN_AGGR_P (value
) = 1;
993 set_user_assembler_name (value
, asmspec
);
995 cp_finish_decl (value
,
997 /*init_const_expr_p=*/false,
998 asmspec_tree
, flags
);
1000 /* Pass friends back this way. */
1001 if (DECL_FRIEND_P (value
))
1002 return void_type_node
;
1004 DECL_IN_AGGR_P (value
) = 1;
1013 /* Like `grokfield', but for bitfields.
1014 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1017 grokbitfield (const cp_declarator
*declarator
,
1018 cp_decl_specifier_seq
*declspecs
, tree width
,
1021 tree value
= grokdeclarator (declarator
, declspecs
, BITFIELD
, 0, &attrlist
);
1023 if (value
== error_mark_node
)
1024 return NULL_TREE
; /* friends went bad. */
1026 /* Pass friendly classes back. */
1027 if (TREE_CODE (value
) == VOID_TYPE
)
1028 return void_type_node
;
1030 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))
1031 && (POINTER_TYPE_P (value
)
1032 || !dependent_type_p (TREE_TYPE (value
))))
1034 error ("bit-field %qD with non-integral type", value
);
1035 return error_mark_node
;
1038 if (TREE_CODE (value
) == TYPE_DECL
)
1040 error ("cannot declare %qD to be a bit-field type", value
);
1044 /* Usually, finish_struct_1 catches bitfields with invalid types.
1045 But, in the case of bitfields with function type, we confuse
1046 ourselves into thinking they are member functions, so we must
1048 if (TREE_CODE (value
) == FUNCTION_DECL
)
1050 error ("cannot declare bit-field %qD with function type",
1055 if (DECL_IN_AGGR_P (value
))
1057 error ("%qD is already defined in the class %qT", value
,
1058 DECL_CONTEXT (value
));
1059 return void_type_node
;
1062 if (TREE_STATIC (value
))
1064 error ("static member %qD cannot be a bit-field", value
);
1067 cp_finish_decl (value
, NULL_TREE
, false, NULL_TREE
, 0);
1069 if (width
!= error_mark_node
)
1071 /* The width must be an integer type. */
1072 if (!type_dependent_expression_p (width
)
1073 && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (width
)))
1074 error ("width of bit-field %qD has non-integral type %qT", value
,
1076 DECL_INITIAL (value
) = width
;
1077 SET_DECL_C_BIT_FIELD (value
);
1080 DECL_IN_AGGR_P (value
) = 1;
1083 cplus_decl_attributes (&value
, attrlist
, /*flags=*/0);
1089 /* Returns true iff ATTR is an attribute which needs to be applied at
1090 instantiation time rather than template definition time. */
1093 is_late_template_attribute (tree attr
, tree decl
)
1095 tree name
= TREE_PURPOSE (attr
);
1096 tree args
= TREE_VALUE (attr
);
1097 const struct attribute_spec
*spec
= lookup_attribute_spec (name
);
1101 /* Unknown attribute. */
1104 /* Attribute weak handling wants to write out assembly right away. */
1105 if (is_attribute_p ("weak", name
))
1108 /* If any of the arguments are dependent expressions, we can't evaluate
1109 the attribute until instantiation time. */
1110 for (arg
= args
; arg
; arg
= TREE_CHAIN (arg
))
1112 tree t
= TREE_VALUE (arg
);
1114 /* If the first attribute argument is an identifier, only consider
1115 second and following arguments. Attributes like mode, format,
1116 cleanup and several target specific attributes aren't late
1117 just because they have an IDENTIFIER_NODE as first argument. */
1118 if (arg
== args
&& TREE_CODE (t
) == IDENTIFIER_NODE
)
1121 if (value_dependent_expression_p (t
)
1122 || type_dependent_expression_p (t
))
1126 if (TREE_CODE (decl
) == TYPE_DECL
1128 || spec
->type_required
)
1130 tree type
= TYPE_P (decl
) ? decl
: TREE_TYPE (decl
);
1132 /* We can't apply any attributes to a completely unknown type until
1133 instantiation time. */
1134 enum tree_code code
= TREE_CODE (type
);
1135 if (code
== TEMPLATE_TYPE_PARM
1136 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
1137 || code
== TYPENAME_TYPE
)
1139 /* Also defer most attributes on dependent types. This is not
1140 necessary in all cases, but is the better default. */
1141 else if (dependent_type_p (type
)
1142 /* But attribute visibility specifically works on
1144 && !is_attribute_p ("visibility", name
))
1153 /* ATTR_P is a list of attributes. Remove any attributes which need to be
1154 applied at instantiation time and return them. If IS_DEPENDENT is true,
1155 the declaration itself is dependent, so all attributes should be applied
1156 at instantiation time. */
1159 splice_template_attributes (tree
*attr_p
, tree decl
)
1162 tree late_attrs
= NULL_TREE
;
1163 tree
*q
= &late_attrs
;
1170 if (is_late_template_attribute (*p
, decl
))
1172 ATTR_IS_DEPENDENT (*p
) = 1;
1174 *p
= TREE_CHAIN (*p
);
1175 q
= &TREE_CHAIN (*q
);
1179 p
= &TREE_CHAIN (*p
);
1185 /* Remove any late attributes from the list in ATTR_P and attach them to
1189 save_template_attributes (tree
*attr_p
, tree
*decl_p
)
1191 tree late_attrs
= splice_template_attributes (attr_p
, *decl_p
);
1193 tree old_attrs
= NULL_TREE
;
1198 if (DECL_P (*decl_p
))
1199 q
= &DECL_ATTRIBUTES (*decl_p
);
1201 q
= &TYPE_ATTRIBUTES (*decl_p
);
1205 /* Merge the late attributes at the beginning with the attribute
1207 late_attrs
= merge_attributes (late_attrs
, *q
);
1210 if (!DECL_P (*decl_p
) && *decl_p
== TYPE_MAIN_VARIANT (*decl_p
))
1212 /* We've added new attributes directly to the main variant, so
1213 now we need to update all of the other variants to include
1214 these new attributes. */
1216 for (variant
= TYPE_NEXT_VARIANT (*decl_p
); variant
;
1217 variant
= TYPE_NEXT_VARIANT (variant
))
1219 gcc_assert (TYPE_ATTRIBUTES (variant
) == old_attrs
);
1220 TYPE_ATTRIBUTES (variant
) = TYPE_ATTRIBUTES (*decl_p
);
1225 /* Like reconstruct_complex_type, but handle also template trees. */
1228 cp_reconstruct_complex_type (tree type
, tree bottom
)
1232 if (TREE_CODE (type
) == POINTER_TYPE
)
1234 inner
= cp_reconstruct_complex_type (TREE_TYPE (type
), bottom
);
1235 outer
= build_pointer_type_for_mode (inner
, TYPE_MODE (type
),
1236 TYPE_REF_CAN_ALIAS_ALL (type
));
1238 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
1240 inner
= cp_reconstruct_complex_type (TREE_TYPE (type
), bottom
);
1241 outer
= build_reference_type_for_mode (inner
, TYPE_MODE (type
),
1242 TYPE_REF_CAN_ALIAS_ALL (type
));
1244 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1246 inner
= cp_reconstruct_complex_type (TREE_TYPE (type
), bottom
);
1247 outer
= build_cplus_array_type (inner
, TYPE_DOMAIN (type
));
1248 /* Don't call cp_build_qualified_type on ARRAY_TYPEs, the
1249 element type qualification will be handled by the recursive
1250 cp_reconstruct_complex_type call and cp_build_qualified_type
1251 for ARRAY_TYPEs changes the element type. */
1254 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
1256 inner
= cp_reconstruct_complex_type (TREE_TYPE (type
), bottom
);
1257 outer
= build_function_type (inner
, TYPE_ARG_TYPES (type
));
1258 outer
= apply_memfn_quals (outer
, type_memfn_quals (type
));
1260 else if (TREE_CODE (type
) == METHOD_TYPE
)
1262 inner
= cp_reconstruct_complex_type (TREE_TYPE (type
), bottom
);
1263 /* The build_method_type_directly() routine prepends 'this' to argument list,
1264 so we must compensate by getting rid of it. */
1266 = build_method_type_directly
1267 (class_of_this_parm (type
), inner
,
1268 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
1270 else if (TREE_CODE (type
) == OFFSET_TYPE
)
1272 inner
= cp_reconstruct_complex_type (TREE_TYPE (type
), bottom
);
1273 outer
= build_offset_type (TYPE_OFFSET_BASETYPE (type
), inner
);
1278 if (TYPE_ATTRIBUTES (type
))
1279 outer
= cp_build_type_attribute_variant (outer
, TYPE_ATTRIBUTES (type
));
1280 return cp_build_qualified_type (outer
, cp_type_quals (type
));
1283 /* Replaces any constexpr expression that may be into the attributes
1284 arguments with their reduced value. */
1287 cp_check_const_attributes (tree attributes
)
1290 for (attr
= attributes
; attr
; attr
= TREE_CHAIN (attr
))
1293 for (arg
= TREE_VALUE (attr
); arg
; arg
= TREE_CHAIN (arg
))
1295 tree expr
= TREE_VALUE (arg
);
1297 TREE_VALUE (arg
) = maybe_constant_value (expr
);
1302 /* Like decl_attributes, but handle C++ complexity. */
1305 cplus_decl_attributes (tree
*decl
, tree attributes
, int flags
)
1307 if (*decl
== NULL_TREE
|| *decl
== void_type_node
1308 || *decl
== error_mark_node
1309 || attributes
== NULL_TREE
)
1312 if (processing_template_decl
)
1314 if (check_for_bare_parameter_packs (attributes
))
1317 save_template_attributes (&attributes
, decl
);
1318 if (attributes
== NULL_TREE
)
1322 cp_check_const_attributes (attributes
);
1324 if (TREE_CODE (*decl
) == TEMPLATE_DECL
)
1325 decl
= &DECL_TEMPLATE_RESULT (*decl
);
1327 decl_attributes (decl
, attributes
, flags
);
1329 if (TREE_CODE (*decl
) == TYPE_DECL
)
1330 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl
), TREE_TYPE (*decl
));
1333 /* Walks through the namespace- or function-scope anonymous union
1334 OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
1335 Returns one of the fields for use in the mangled name. */
1338 build_anon_union_vars (tree type
, tree object
)
1340 tree main_decl
= NULL_TREE
;
1343 /* Rather than write the code to handle the non-union case,
1344 just give an error. */
1345 if (TREE_CODE (type
) != UNION_TYPE
)
1347 error ("anonymous struct not inside named type");
1348 return error_mark_node
;
1351 for (field
= TYPE_FIELDS (type
);
1353 field
= DECL_CHAIN (field
))
1358 if (DECL_ARTIFICIAL (field
))
1360 if (TREE_CODE (field
) != FIELD_DECL
)
1362 permerror (input_location
, "%q+#D invalid; an anonymous union can only "
1363 "have non-static data members", field
);
1367 if (TREE_PRIVATE (field
))
1368 permerror (input_location
, "private member %q+#D in anonymous union", field
);
1369 else if (TREE_PROTECTED (field
))
1370 permerror (input_location
, "protected member %q+#D in anonymous union", field
);
1372 if (processing_template_decl
)
1373 ref
= build_min_nt (COMPONENT_REF
, object
,
1374 DECL_NAME (field
), NULL_TREE
);
1376 ref
= build_class_member_access_expr (object
, field
, NULL_TREE
,
1377 false, tf_warning_or_error
);
1379 if (DECL_NAME (field
))
1383 decl
= build_decl (input_location
,
1384 VAR_DECL
, DECL_NAME (field
), TREE_TYPE (field
));
1385 DECL_ANON_UNION_VAR_P (decl
) = 1;
1386 DECL_ARTIFICIAL (decl
) = 1;
1388 base
= get_base_address (object
);
1389 TREE_PUBLIC (decl
) = TREE_PUBLIC (base
);
1390 TREE_STATIC (decl
) = TREE_STATIC (base
);
1391 DECL_EXTERNAL (decl
) = DECL_EXTERNAL (base
);
1393 SET_DECL_VALUE_EXPR (decl
, ref
);
1394 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
1396 decl
= pushdecl (decl
);
1398 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field
)))
1399 decl
= build_anon_union_vars (TREE_TYPE (field
), ref
);
1403 if (main_decl
== NULL_TREE
)
1410 /* Finish off the processing of a UNION_TYPE structure. If the union is an
1411 anonymous union, then all members must be laid out together. PUBLIC_P
1412 is nonzero if this union is not declared static. */
1415 finish_anon_union (tree anon_union_decl
)
1421 if (anon_union_decl
== error_mark_node
)
1424 type
= TREE_TYPE (anon_union_decl
);
1425 public_p
= TREE_PUBLIC (anon_union_decl
);
1427 /* The VAR_DECL's context is the same as the TYPE's context. */
1428 DECL_CONTEXT (anon_union_decl
) = DECL_CONTEXT (TYPE_NAME (type
));
1430 if (TYPE_FIELDS (type
) == NULL_TREE
)
1435 error ("namespace-scope anonymous aggregates must be static");
1439 main_decl
= build_anon_union_vars (type
, anon_union_decl
);
1440 if (main_decl
== error_mark_node
)
1442 if (main_decl
== NULL_TREE
)
1444 warning (0, "anonymous union with no members");
1448 if (!processing_template_decl
)
1450 /* Use main_decl to set the mangled name. */
1451 DECL_NAME (anon_union_decl
) = DECL_NAME (main_decl
);
1452 maybe_commonize_var (anon_union_decl
);
1453 if (TREE_STATIC (anon_union_decl
) || DECL_EXTERNAL (anon_union_decl
))
1454 mangle_decl (anon_union_decl
);
1455 DECL_NAME (anon_union_decl
) = NULL_TREE
;
1458 pushdecl (anon_union_decl
);
1459 cp_finish_decl (anon_union_decl
, NULL_TREE
, false, NULL_TREE
, 0);
1462 /* Auxiliary functions to make type signatures for
1463 `operator new' and `operator delete' correspond to
1464 what compiler will be expecting. */
1467 coerce_new_type (tree type
)
1470 tree args
= TYPE_ARG_TYPES (type
);
1472 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
1474 if (!same_type_p (TREE_TYPE (type
), ptr_type_node
))
1477 error ("%<operator new%> must return type %qT", ptr_type_node
);
1480 if (args
&& args
!= void_list_node
)
1482 if (TREE_PURPOSE (args
))
1484 /* [basic.stc.dynamic.allocation]
1486 The first parameter shall not have an associated default
1488 error ("the first parameter of %<operator new%> cannot "
1489 "have a default argument");
1490 /* Throw away the default argument. */
1491 TREE_PURPOSE (args
) = NULL_TREE
;
1494 if (!same_type_p (TREE_VALUE (args
), size_type_node
))
1497 args
= TREE_CHAIN (args
);
1504 permerror (input_location
, "%<operator new%> takes type %<size_t%> (%qT) "
1505 "as first parameter", size_type_node
);
1510 args
= tree_cons (NULL_TREE
, size_type_node
, args
);
1513 type
= build_exception_variant
1514 (build_function_type (ptr_type_node
, args
),
1515 TYPE_RAISES_EXCEPTIONS (type
));
1523 coerce_delete_type (tree type
)
1526 tree args
= TYPE_ARG_TYPES (type
);
1528 gcc_assert (TREE_CODE (type
) == FUNCTION_TYPE
);
1530 if (!same_type_p (TREE_TYPE (type
), void_type_node
))
1533 error ("%<operator delete%> must return type %qT", void_type_node
);
1536 if (!args
|| args
== void_list_node
1537 || !same_type_p (TREE_VALUE (args
), ptr_type_node
))
1540 if (args
&& args
!= void_list_node
)
1541 args
= TREE_CHAIN (args
);
1542 error ("%<operator delete%> takes type %qT as first parameter",
1548 args
= tree_cons (NULL_TREE
, ptr_type_node
, args
);
1551 type
= build_exception_variant
1552 (build_function_type (void_type_node
, args
),
1553 TYPE_RAISES_EXCEPTIONS (type
));
1561 /* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
1562 and mark them as needed. */
1565 mark_vtable_entries (tree decl
)
1568 unsigned HOST_WIDE_INT idx
;
1570 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl
)),
1575 STRIP_NOPS (fnaddr
);
1577 if (TREE_CODE (fnaddr
) != ADDR_EXPR
1578 && TREE_CODE (fnaddr
) != FDESC_EXPR
)
1579 /* This entry is an offset: a virtual base class offset, a
1580 virtual call offset, an RTTI offset, etc. */
1583 fn
= TREE_OPERAND (fnaddr
, 0);
1584 TREE_ADDRESSABLE (fn
) = 1;
1585 /* When we don't have vcall offsets, we output thunks whenever
1586 we output the vtables that contain them. With vcall offsets,
1587 we know all the thunks we'll need when we emit a virtual
1588 function, so we emit the thunks there instead. */
1589 if (DECL_THUNK_P (fn
))
1590 use_thunk (fn
, /*emit_p=*/0);
1595 /* Set DECL up to have the closest approximation of "initialized common"
1596 linkage available. */
1599 comdat_linkage (tree decl
)
1602 make_decl_one_only (decl
, cxx_comdat_group (decl
));
1603 else if (TREE_CODE (decl
) == FUNCTION_DECL
1604 || (TREE_CODE (decl
) == VAR_DECL
&& DECL_ARTIFICIAL (decl
)))
1605 /* We can just emit function and compiler-generated variables
1606 statically; having multiple copies is (for the most part) only
1609 There are two correctness issues, however: the address of a
1610 template instantiation with external linkage should be the
1611 same, independent of what translation unit asks for the
1612 address, and this will not hold when we emit multiple copies of
1613 the function. However, there's little else we can do.
1615 Also, by default, the typeinfo implementation assumes that
1616 there will be only one copy of the string used as the name for
1617 each type. Therefore, if weak symbols are unavailable, the
1618 run-time library should perform a more conservative check; it
1619 should perform a string comparison, rather than an address
1621 TREE_PUBLIC (decl
) = 0;
1624 /* Static data member template instantiations, however, cannot
1625 have multiple copies. */
1626 if (DECL_INITIAL (decl
) == 0
1627 || DECL_INITIAL (decl
) == error_mark_node
)
1628 DECL_COMMON (decl
) = 1;
1629 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
)))
1631 DECL_COMMON (decl
) = 1;
1632 DECL_INITIAL (decl
) = error_mark_node
;
1634 else if (!DECL_EXPLICIT_INSTANTIATION (decl
))
1636 /* We can't do anything useful; leave vars for explicit
1638 DECL_EXTERNAL (decl
) = 1;
1639 DECL_NOT_REALLY_EXTERN (decl
) = 0;
1643 DECL_COMDAT (decl
) = 1;
1646 /* For win32 we also want to put explicit instantiations in
1647 linkonce sections, so that they will be merged with implicit
1648 instantiations; otherwise we get duplicate symbol errors.
1649 For Darwin we do not want explicit instantiations to be
1653 maybe_make_one_only (tree decl
)
1655 /* We used to say that this was not necessary on targets that support weak
1656 symbols, because the implicit instantiations will defer to the explicit
1657 one. However, that's not actually the case in SVR4; a strong definition
1658 after a weak one is an error. Also, not making explicit
1659 instantiations one_only means that we can end up with two copies of
1660 some template instantiations. */
1664 /* We can't set DECL_COMDAT on functions, or cp_finish_file will think
1665 we can get away with not emitting them if they aren't used. We need
1666 to for variables so that cp_finish_decl will update their linkage,
1667 because their DECL_INITIAL may not have been set properly yet. */
1669 if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
1670 || (! DECL_EXPLICIT_INSTANTIATION (decl
)
1671 && ! DECL_TEMPLATE_SPECIALIZATION (decl
)))
1673 make_decl_one_only (decl
, cxx_comdat_group (decl
));
1675 if (TREE_CODE (decl
) == VAR_DECL
)
1677 DECL_COMDAT (decl
) = 1;
1678 /* Mark it needed so we don't forget to emit it. */
1679 mark_decl_referenced (decl
);
1680 TREE_USED (decl
) = 1;
1685 /* Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage.
1686 This predicate will give the right answer during parsing of the
1687 function, which other tests may not. */
1690 vague_linkage_p (tree decl
)
1692 /* Unfortunately, import_export_decl has not always been called
1693 before the function is processed, so we cannot simply check
1695 return (DECL_COMDAT (decl
)
1696 || (((TREE_CODE (decl
) == FUNCTION_DECL
1697 && DECL_DECLARED_INLINE_P (decl
))
1698 || (DECL_LANG_SPECIFIC (decl
)
1699 && DECL_TEMPLATE_INSTANTIATION (decl
)))
1700 && TREE_PUBLIC (decl
)));
1703 /* Determine whether or not we want to specifically import or export CTYPE,
1704 using various heuristics. */
1707 import_export_class (tree ctype
)
1709 /* -1 for imported, 1 for exported. */
1710 int import_export
= 0;
1712 /* It only makes sense to call this function at EOF. The reason is
1713 that this function looks at whether or not the first non-inline
1714 non-abstract virtual member function has been defined in this
1715 translation unit. But, we can't possibly know that until we've
1716 seen the entire translation unit. */
1717 gcc_assert (at_eof
);
1719 if (CLASSTYPE_INTERFACE_KNOWN (ctype
))
1722 /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
1723 we will have CLASSTYPE_INTERFACE_ONLY set but not
1724 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
1725 heuristic because someone will supply a #pragma implementation
1726 elsewhere, and deducing it here would produce a conflict. */
1727 if (CLASSTYPE_INTERFACE_ONLY (ctype
))
1730 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype
)))
1732 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype
)))
1734 else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype
)
1735 && !flag_implicit_templates
)
1736 /* For a template class, without -fimplicit-templates, check the
1737 repository. If the virtual table is assigned to this
1738 translation unit, then export the class; otherwise, import
1740 import_export
= repo_export_class_p (ctype
) ? 1 : -1;
1741 else if (TYPE_POLYMORPHIC_P (ctype
))
1743 /* The ABI specifies that the virtual table and associated
1744 information are emitted with the key method, if any. */
1745 tree method
= CLASSTYPE_KEY_METHOD (ctype
);
1746 /* If weak symbol support is not available, then we must be
1747 careful not to emit the vtable when the key function is
1748 inline. An inline function can be defined in multiple
1749 translation units. If we were to emit the vtable in each
1750 translation unit containing a definition, we would get
1751 multiple definition errors at link-time. */
1752 if (method
&& (flag_weak
|| ! DECL_DECLARED_INLINE_P (method
)))
1753 import_export
= (DECL_REALLY_EXTERN (method
) ? -1 : 1);
1756 /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
1757 a definition anywhere else. */
1758 if (MULTIPLE_SYMBOL_SPACES
&& import_export
== -1)
1761 /* Allow back ends the chance to overrule the decision. */
1762 if (targetm
.cxx
.import_export_class
)
1763 import_export
= targetm
.cxx
.import_export_class (ctype
, import_export
);
1767 SET_CLASSTYPE_INTERFACE_KNOWN (ctype
);
1768 CLASSTYPE_INTERFACE_ONLY (ctype
) = (import_export
< 0);
1772 /* Return true if VAR has already been provided to the back end; in that
1773 case VAR should not be modified further by the front end. */
1775 var_finalized_p (tree var
)
1777 return varpool_node (var
)->finalized
;
1780 /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
1781 must be emitted in this translation unit. Mark it as such. */
1784 mark_needed (tree decl
)
1786 TREE_USED (decl
) = 1;
1787 mark_decl_referenced (decl
);
1790 /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
1791 returns true if a definition of this entity should be provided in
1792 this object file. Callers use this function to determine whether
1793 or not to let the back end know that a definition of DECL is
1794 available in this translation unit. */
1797 decl_needed_p (tree decl
)
1799 gcc_assert (TREE_CODE (decl
) == VAR_DECL
1800 || TREE_CODE (decl
) == FUNCTION_DECL
);
1801 /* This function should only be called at the end of the translation
1802 unit. We cannot be sure of whether or not something will be
1803 COMDAT until that point. */
1804 gcc_assert (at_eof
);
1806 /* All entities with external linkage that are not COMDAT should be
1807 emitted; they may be referred to from other object files. */
1808 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
1810 /* If this entity was used, let the back end see it; it will decide
1811 whether or not to emit it into the object file. */
1812 if (TREE_USED (decl
))
1814 /* Functions marked "dllexport" must be emitted so that they are
1815 visible to other DLLs. */
1816 if (flag_keep_inline_dllexport
1817 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl
)))
1819 /* Otherwise, DECL does not need to be emitted -- yet. A subsequent
1820 reference to DECL might cause it to be emitted later. */
1824 /* If necessary, write out the vtables for the dynamic class CTYPE.
1825 Returns true if any vtables were emitted. */
1828 maybe_emit_vtables (tree ctype
)
1833 struct varpool_node
*current
= NULL
, *last
= NULL
;
1835 /* If the vtables for this class have already been emitted there is
1836 nothing more to do. */
1837 primary_vtbl
= CLASSTYPE_VTABLES (ctype
);
1838 if (var_finalized_p (primary_vtbl
))
1840 /* Ignore dummy vtables made by get_vtable_decl. */
1841 if (TREE_TYPE (primary_vtbl
) == void_type_node
)
1844 /* On some targets, we cannot determine the key method until the end
1845 of the translation unit -- which is when this function is
1847 if (!targetm
.cxx
.key_method_may_be_inline ())
1848 determine_key_method (ctype
);
1850 /* See if any of the vtables are needed. */
1851 for (vtbl
= CLASSTYPE_VTABLES (ctype
); vtbl
; vtbl
= DECL_CHAIN (vtbl
))
1853 import_export_decl (vtbl
);
1854 if (DECL_NOT_REALLY_EXTERN (vtbl
) && decl_needed_p (vtbl
))
1859 /* If the references to this class' vtables are optimized away,
1860 still emit the appropriate debugging information. See
1862 if (DECL_COMDAT (primary_vtbl
)
1863 && CLASSTYPE_DEBUG_REQUESTED (ctype
))
1864 note_debug_info_needed (ctype
);
1868 /* The ABI requires that we emit all of the vtables if we emit any
1870 for (vtbl
= CLASSTYPE_VTABLES (ctype
); vtbl
; vtbl
= DECL_CHAIN (vtbl
))
1872 /* Mark entities references from the virtual table as used. */
1873 mark_vtable_entries (vtbl
);
1875 if (TREE_TYPE (DECL_INITIAL (vtbl
)) == 0)
1877 VEC(tree
,gc
)* cleanups
= NULL
;
1878 tree expr
= store_init_value (vtbl
, DECL_INITIAL (vtbl
), &cleanups
,
1881 /* It had better be all done at compile-time. */
1882 gcc_assert (!expr
&& !cleanups
);
1886 DECL_EXTERNAL (vtbl
) = 0;
1887 rest_of_decl_compilation (vtbl
, 1, 1);
1889 /* Because we're only doing syntax-checking, we'll never end up
1890 actually marking the variable as written. */
1891 if (flag_syntax_only
)
1892 TREE_ASM_WRITTEN (vtbl
) = 1;
1893 else if (DECL_ONE_ONLY (vtbl
))
1895 current
= varpool_node (vtbl
);
1897 symtab_add_to_same_comdat_group ((symtab_node
) current
, (symtab_node
) last
);
1902 /* Since we're writing out the vtable here, also write the debug
1904 note_debug_info_needed (ctype
);
1909 /* A special return value from type_visibility meaning internal
1912 enum { VISIBILITY_ANON
= VISIBILITY_INTERNAL
+1 };
1914 /* walk_tree helper function for type_visibility. */
1917 min_vis_r (tree
*tp
, int *walk_subtrees
, void *data
)
1919 int *vis_p
= (int *)data
;
1924 else if (CLASS_TYPE_P (*tp
))
1926 if (!TREE_PUBLIC (TYPE_MAIN_DECL (*tp
)))
1928 *vis_p
= VISIBILITY_ANON
;
1931 else if (CLASSTYPE_VISIBILITY (*tp
) > *vis_p
)
1932 *vis_p
= CLASSTYPE_VISIBILITY (*tp
);
1937 /* Returns the visibility of TYPE, which is the minimum visibility of its
1941 type_visibility (tree type
)
1943 int vis
= VISIBILITY_DEFAULT
;
1944 cp_walk_tree_without_duplicates (&type
, min_vis_r
, &vis
);
1948 /* Limit the visibility of DECL to VISIBILITY, if not explicitly
1949 specified (or if VISIBILITY is static). If TMPL is true, this
1950 constraint is for a template argument, and takes precedence
1951 over explicitly-specified visibility on the template. */
1954 constrain_visibility (tree decl
, int visibility
, bool tmpl
)
1956 if (visibility
== VISIBILITY_ANON
)
1958 /* extern "C" declarations aren't affected by the anonymous
1960 if (!DECL_EXTERN_C_P (decl
))
1962 TREE_PUBLIC (decl
) = 0;
1963 DECL_WEAK (decl
) = 0;
1964 DECL_COMMON (decl
) = 0;
1965 DECL_COMDAT_GROUP (decl
) = NULL_TREE
;
1966 DECL_INTERFACE_KNOWN (decl
) = 1;
1967 if (DECL_LANG_SPECIFIC (decl
))
1968 DECL_NOT_REALLY_EXTERN (decl
) = 1;
1971 else if (visibility
> DECL_VISIBILITY (decl
)
1972 && (tmpl
|| !DECL_VISIBILITY_SPECIFIED (decl
)))
1974 DECL_VISIBILITY (decl
) = (enum symbol_visibility
) visibility
;
1975 /* This visibility was not specified. */
1976 DECL_VISIBILITY_SPECIFIED (decl
) = false;
1980 /* Constrain the visibility of DECL based on the visibility of its template
1984 constrain_visibility_for_template (tree decl
, tree targs
)
1986 /* If this is a template instantiation, check the innermost
1987 template args for visibility constraints. The outer template
1988 args are covered by the class check. */
1989 tree args
= INNERMOST_TEMPLATE_ARGS (targs
);
1991 for (i
= TREE_VEC_LENGTH (args
); i
> 0; --i
)
1995 tree arg
= TREE_VEC_ELT (args
, i
-1);
1997 vis
= type_visibility (arg
);
1998 else if (TREE_TYPE (arg
) && POINTER_TYPE_P (TREE_TYPE (arg
)))
2001 if (TREE_CODE (arg
) == ADDR_EXPR
)
2002 arg
= TREE_OPERAND (arg
, 0);
2003 if (TREE_CODE (arg
) == VAR_DECL
2004 || TREE_CODE (arg
) == FUNCTION_DECL
)
2006 if (! TREE_PUBLIC (arg
))
2007 vis
= VISIBILITY_ANON
;
2009 vis
= DECL_VISIBILITY (arg
);
2013 constrain_visibility (decl
, vis
, true);
2017 /* Like c_determine_visibility, but with additional C++-specific
2020 Function-scope entities can rely on the function's visibility because
2021 it is set in start_preparsed_function.
2023 Class-scope entities cannot rely on the class's visibility until the end
2024 of the enclosing class definition.
2026 Note that because namespaces have multiple independent definitions,
2027 namespace visibility is handled elsewhere using the #pragma visibility
2028 machinery rather than by decorating the namespace declaration.
2030 The goal is for constraints from the type to give a diagnostic, and
2031 other constraints to be applied silently. */
2034 determine_visibility (tree decl
)
2036 tree class_type
= NULL_TREE
;
2038 bool orig_visibility_specified
;
2039 enum symbol_visibility orig_visibility
;
2041 /* Remember that all decls get VISIBILITY_DEFAULT when built. */
2043 /* Only relevant for names with external linkage. */
2044 if (!TREE_PUBLIC (decl
))
2047 /* Cloned constructors and destructors get the same visibility as
2048 the underlying function. That should be set up in
2049 maybe_clone_body. */
2050 gcc_assert (!DECL_CLONED_FUNCTION_P (decl
));
2052 orig_visibility_specified
= DECL_VISIBILITY_SPECIFIED (decl
);
2053 orig_visibility
= DECL_VISIBILITY (decl
);
2055 if (TREE_CODE (decl
) == TYPE_DECL
)
2057 if (CLASS_TYPE_P (TREE_TYPE (decl
)))
2058 use_template
= CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl
));
2059 else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl
)))
2064 else if (DECL_LANG_SPECIFIC (decl
))
2065 use_template
= DECL_USE_TEMPLATE (decl
);
2069 /* If DECL is a member of a class, visibility specifiers on the
2070 class can influence the visibility of the DECL. */
2071 if (DECL_CLASS_SCOPE_P (decl
))
2072 class_type
= DECL_CONTEXT (decl
);
2075 /* Not a class member. */
2077 /* Virtual tables have DECL_CONTEXT set to their associated class,
2078 so they are automatically handled above. */
2079 gcc_assert (TREE_CODE (decl
) != VAR_DECL
2080 || !DECL_VTABLE_OR_VTT_P (decl
));
2082 if (DECL_FUNCTION_SCOPE_P (decl
) && ! DECL_VISIBILITY_SPECIFIED (decl
))
2084 /* Local statics and classes get the visibility of their
2085 containing function by default, except that
2086 -fvisibility-inlines-hidden doesn't affect them. */
2087 tree fn
= DECL_CONTEXT (decl
);
2088 if (DECL_VISIBILITY_SPECIFIED (fn
))
2090 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (fn
);
2091 DECL_VISIBILITY_SPECIFIED (decl
) =
2092 DECL_VISIBILITY_SPECIFIED (fn
);
2096 if (DECL_CLASS_SCOPE_P (fn
))
2097 determine_visibility_from_class (decl
, DECL_CONTEXT (fn
));
2098 else if (determine_hidden_inline (fn
))
2100 DECL_VISIBILITY (decl
) = default_visibility
;
2101 DECL_VISIBILITY_SPECIFIED (decl
) =
2102 visibility_options
.inpragma
;
2106 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (fn
);
2107 DECL_VISIBILITY_SPECIFIED (decl
) =
2108 DECL_VISIBILITY_SPECIFIED (fn
);
2112 /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
2113 but have no TEMPLATE_INFO, so don't try to check it. */
2116 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_TINFO_P (decl
)
2117 && flag_visibility_ms_compat
)
2119 /* Under -fvisibility-ms-compat, types are visible by default,
2120 even though their contents aren't. */
2121 tree underlying_type
= TREE_TYPE (DECL_NAME (decl
));
2122 int underlying_vis
= type_visibility (underlying_type
);
2123 if (underlying_vis
== VISIBILITY_ANON
2124 || (CLASS_TYPE_P (underlying_type
)
2125 && CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type
)))
2126 constrain_visibility (decl
, underlying_vis
, false);
2128 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
2130 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_TINFO_P (decl
))
2132 /* tinfo visibility is based on the type it's for. */
2133 constrain_visibility
2134 (decl
, type_visibility (TREE_TYPE (DECL_NAME (decl
))), false);
2136 /* Give the target a chance to override the visibility associated
2138 if (TREE_PUBLIC (decl
)
2139 && !DECL_REALLY_EXTERN (decl
)
2140 && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl
)))
2141 && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl
))))
2142 targetm
.cxx
.determine_class_data_visibility (decl
);
2144 else if (use_template
)
2145 /* Template instantiations and specializations get visibility based
2146 on their template unless they override it with an attribute. */;
2147 else if (! DECL_VISIBILITY_SPECIFIED (decl
))
2149 if (determine_hidden_inline (decl
))
2150 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
2153 /* Set default visibility to whatever the user supplied with
2154 #pragma GCC visibility or a namespace visibility attribute. */
2155 DECL_VISIBILITY (decl
) = default_visibility
;
2156 DECL_VISIBILITY_SPECIFIED (decl
) = visibility_options
.inpragma
;
2163 /* If the specialization doesn't specify visibility, use the
2164 visibility from the template. */
2165 tree tinfo
= (TREE_CODE (decl
) == TYPE_DECL
2166 ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl
))
2167 : DECL_TEMPLATE_INFO (decl
));
2168 tree args
= TI_ARGS (tinfo
);
2169 tree attribs
= (TREE_CODE (decl
) == TYPE_DECL
2170 ? TYPE_ATTRIBUTES (TREE_TYPE (decl
))
2171 : DECL_ATTRIBUTES (decl
));
2173 if (args
!= error_mark_node
)
2175 tree pattern
= DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo
));
2177 if (!DECL_VISIBILITY_SPECIFIED (decl
))
2179 if (!DECL_VISIBILITY_SPECIFIED (pattern
)
2180 && determine_hidden_inline (decl
))
2181 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
2184 DECL_VISIBILITY (decl
) = DECL_VISIBILITY (pattern
);
2185 DECL_VISIBILITY_SPECIFIED (decl
)
2186 = DECL_VISIBILITY_SPECIFIED (pattern
);
2191 /* Template argument visibility outweighs #pragma or namespace
2192 visibility, but not an explicit attribute. */
2193 && !lookup_attribute ("visibility", attribs
))
2195 int depth
= TMPL_ARGS_DEPTH (args
);
2196 int class_depth
= 0;
2197 if (class_type
&& CLASSTYPE_TEMPLATE_INFO (class_type
))
2198 class_depth
= TMPL_ARGS_DEPTH (CLASSTYPE_TI_ARGS (class_type
));
2199 if (DECL_VISIBILITY_SPECIFIED (decl
))
2201 /* A class template member with explicit visibility
2202 overrides the class visibility, so we need to apply
2203 all the levels of template args directly. */
2205 for (i
= 1; i
<= depth
; ++i
)
2207 tree lev
= TMPL_ARGS_LEVEL (args
, i
);
2208 constrain_visibility_for_template (decl
, lev
);
2211 else if (depth
> class_depth
)
2212 /* Limit visibility based on its template arguments. */
2213 constrain_visibility_for_template (decl
, args
);
2219 determine_visibility_from_class (decl
, class_type
);
2221 if (decl_anon_ns_mem_p (decl
))
2222 /* Names in an anonymous namespace get internal linkage.
2223 This might change once we implement export. */
2224 constrain_visibility (decl
, VISIBILITY_ANON
, false);
2225 else if (TREE_CODE (decl
) != TYPE_DECL
)
2227 /* Propagate anonymity from type to decl. */
2228 int tvis
= type_visibility (TREE_TYPE (decl
));
2229 if (tvis
== VISIBILITY_ANON
2230 || ! DECL_VISIBILITY_SPECIFIED (decl
))
2231 constrain_visibility (decl
, tvis
, false);
2233 else if (no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/true))
2234 /* DR 757: A type without linkage shall not be used as the type of a
2235 variable or function with linkage, unless
2236 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
2237 o the variable or function is not used (3.2 [basic.def.odr]) or is
2238 defined in the same translation unit.
2240 Since non-extern "C" decls need to be defined in the same
2241 translation unit, we can make the type internal. */
2242 constrain_visibility (decl
, VISIBILITY_ANON
, false);
2244 /* If visibility changed and DECL already has DECL_RTL, ensure
2245 symbol flags are updated. */
2246 if ((DECL_VISIBILITY (decl
) != orig_visibility
2247 || DECL_VISIBILITY_SPECIFIED (decl
) != orig_visibility_specified
)
2248 && ((TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
2249 || TREE_CODE (decl
) == FUNCTION_DECL
)
2250 && DECL_RTL_SET_P (decl
))
2251 make_decl_rtl (decl
);
2254 /* By default, static data members and function members receive
2255 the visibility of their containing class. */
2258 determine_visibility_from_class (tree decl
, tree class_type
)
2260 if (DECL_VISIBILITY_SPECIFIED (decl
))
2263 if (determine_hidden_inline (decl
))
2264 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
2267 /* Default to the class visibility. */
2268 DECL_VISIBILITY (decl
) = CLASSTYPE_VISIBILITY (class_type
);
2269 DECL_VISIBILITY_SPECIFIED (decl
)
2270 = CLASSTYPE_VISIBILITY_SPECIFIED (class_type
);
2273 /* Give the target a chance to override the visibility associated
2275 if (TREE_CODE (decl
) == VAR_DECL
2276 && (DECL_TINFO_P (decl
)
2277 || (DECL_VTABLE_OR_VTT_P (decl
)
2278 /* Construction virtual tables are not exported because
2279 they cannot be referred to from other object files;
2280 their name is not standardized by the ABI. */
2281 && !DECL_CONSTRUCTION_VTABLE_P (decl
)))
2282 && TREE_PUBLIC (decl
)
2283 && !DECL_REALLY_EXTERN (decl
)
2284 && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type
))
2285 targetm
.cxx
.determine_class_data_visibility (decl
);
2288 /* Returns true iff DECL is an inline that should get hidden visibility
2289 because of -fvisibility-inlines-hidden. */
2292 determine_hidden_inline (tree decl
)
2294 return (visibility_options
.inlines_hidden
2295 /* Don't do this for inline templates; specializations might not be
2296 inline, and we don't want them to inherit the hidden
2297 visibility. We'll set it here for all inline instantiations. */
2298 && !processing_template_decl
2299 && TREE_CODE (decl
) == FUNCTION_DECL
2300 && DECL_DECLARED_INLINE_P (decl
)
2301 && (! DECL_LANG_SPECIFIC (decl
)
2302 || ! DECL_EXPLICIT_INSTANTIATION (decl
)));
2305 /* Constrain the visibility of a class TYPE based on the visibility of its
2306 field types. Warn if any fields require lesser visibility. */
2309 constrain_class_visibility (tree type
)
2315 int vis
= type_visibility (type
);
2317 if (vis
== VISIBILITY_ANON
2318 || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type
)))
2321 /* Don't warn about visibility if the class has explicit visibility. */
2322 if (CLASSTYPE_VISIBILITY_SPECIFIED (type
))
2323 vis
= VISIBILITY_INTERNAL
;
2325 for (t
= TYPE_FIELDS (type
); t
; t
= DECL_CHAIN (t
))
2326 if (TREE_CODE (t
) == FIELD_DECL
&& TREE_TYPE (t
) != error_mark_node
)
2328 tree ftype
= strip_pointer_or_array_types (TREE_TYPE (t
));
2329 int subvis
= type_visibility (ftype
);
2331 if (subvis
== VISIBILITY_ANON
)
2333 if (!in_main_input_context ())
2335 %qT has a field %qD whose type uses the anonymous namespace",
2338 else if (MAYBE_CLASS_TYPE_P (ftype
)
2339 && vis
< VISIBILITY_HIDDEN
2340 && subvis
>= VISIBILITY_HIDDEN
)
2341 warning (OPT_Wattributes
, "\
2342 %qT declared with greater visibility than the type of its field %qD",
2346 binfo
= TYPE_BINFO (type
);
2347 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, t
); ++i
)
2349 int subvis
= type_visibility (TREE_TYPE (t
));
2351 if (subvis
== VISIBILITY_ANON
)
2353 if (!in_main_input_context())
2355 %qT has a base %qT whose type uses the anonymous namespace",
2356 type
, TREE_TYPE (t
));
2358 else if (vis
< VISIBILITY_HIDDEN
2359 && subvis
>= VISIBILITY_HIDDEN
)
2360 warning (OPT_Wattributes
, "\
2361 %qT declared with greater visibility than its base %qT",
2362 type
, TREE_TYPE (t
));
2366 /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
2367 for DECL has not already been determined, do so now by setting
2368 DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
2369 function is called entities with vague linkage whose definitions
2370 are available must have TREE_PUBLIC set.
2372 If this function decides to place DECL in COMDAT, it will set
2373 appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
2374 the caller to decide whether or not to clear DECL_EXTERNAL. Some
2375 callers defer that decision until it is clear that DECL is actually
2379 import_export_decl (tree decl
)
2384 tree class_type
= NULL_TREE
;
2386 if (DECL_INTERFACE_KNOWN (decl
))
2389 /* We cannot determine what linkage to give to an entity with vague
2390 linkage until the end of the file. For example, a virtual table
2391 for a class will be defined if and only if the key method is
2392 defined in this translation unit. As a further example, consider
2393 that when compiling a translation unit that uses PCH file with
2394 "-frepo" it would be incorrect to make decisions about what
2395 entities to emit when building the PCH; those decisions must be
2396 delayed until the repository information has been processed. */
2397 gcc_assert (at_eof
);
2398 /* Object file linkage for explicit instantiations is handled in
2399 mark_decl_instantiated. For static variables in functions with
2400 vague linkage, maybe_commonize_var is used.
2402 Therefore, the only declarations that should be provided to this
2403 function are those with external linkage that are:
2405 * implicit instantiations of function templates
2409 * implicit instantiations of static data members of class
2416 Furthermore, all entities that reach this point must have a
2417 definition available in this translation unit.
2419 The following assertions check these conditions. */
2420 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
2421 || TREE_CODE (decl
) == VAR_DECL
);
2422 /* Any code that creates entities with TREE_PUBLIC cleared should
2423 also set DECL_INTERFACE_KNOWN. */
2424 gcc_assert (TREE_PUBLIC (decl
));
2425 if (TREE_CODE (decl
) == FUNCTION_DECL
)
2426 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl
)
2427 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl
)
2428 || DECL_DECLARED_INLINE_P (decl
));
2430 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl
)
2431 || DECL_VTABLE_OR_VTT_P (decl
)
2432 || DECL_TINFO_P (decl
));
2433 /* Check that a definition of DECL is available in this translation
2435 gcc_assert (!DECL_REALLY_EXTERN (decl
));
2437 /* Assume that DECL will not have COMDAT linkage. */
2439 /* Assume that DECL will not be imported into this translation
2443 /* See if the repository tells us whether or not to emit DECL in
2444 this translation unit. */
2445 emit_p
= repo_emit_p (decl
);
2448 else if (emit_p
== 1)
2450 /* The repository indicates that this entity should be defined
2451 here. Make sure the back end honors that request. */
2452 if (TREE_CODE (decl
) == VAR_DECL
)
2454 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)
2455 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
))
2458 FOR_EACH_CLONE (clone
, decl
)
2459 mark_needed (clone
);
2463 /* Output the definition as an ordinary strong definition. */
2464 DECL_EXTERNAL (decl
) = 0;
2465 DECL_INTERFACE_KNOWN (decl
) = 1;
2470 /* We have already decided what to do with this DECL; there is no
2471 need to check anything further. */
2473 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VTABLE_OR_VTT_P (decl
))
2475 class_type
= DECL_CONTEXT (decl
);
2476 import_export_class (class_type
);
2477 if (TYPE_FOR_JAVA (class_type
))
2479 else if (CLASSTYPE_INTERFACE_KNOWN (class_type
)
2480 && CLASSTYPE_INTERFACE_ONLY (class_type
))
2482 else if ((!flag_weak
|| TARGET_WEAK_NOT_IN_ARCHIVE_TOC
)
2483 && !CLASSTYPE_USE_TEMPLATE (class_type
)
2484 && CLASSTYPE_KEY_METHOD (class_type
)
2485 && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type
)))
2486 /* The ABI requires that all virtual tables be emitted with
2487 COMDAT linkage. However, on systems where COMDAT symbols
2488 don't show up in the table of contents for a static
2489 archive, or on systems without weak symbols (where we
2490 approximate COMDAT linkage by using internal linkage), the
2491 linker will report errors about undefined symbols because
2492 it will not see the virtual table definition. Therefore,
2493 in the case that we know that the virtual table will be
2494 emitted in only one translation unit, we make the virtual
2495 table an ordinary definition with external linkage. */
2496 DECL_EXTERNAL (decl
) = 0;
2497 else if (CLASSTYPE_INTERFACE_KNOWN (class_type
))
2499 /* CLASS_TYPE is being exported from this translation unit,
2500 so DECL should be defined here. */
2501 if (!flag_weak
&& CLASSTYPE_EXPLICIT_INSTANTIATION (class_type
))
2502 /* If a class is declared in a header with the "extern
2503 template" extension, then it will not be instantiated,
2504 even in translation units that would normally require
2505 it. Often such classes are explicitly instantiated in
2506 one translation unit. Therefore, the explicit
2507 instantiation must be made visible to other translation
2509 DECL_EXTERNAL (decl
) = 0;
2512 /* The generic C++ ABI says that class data is always
2513 COMDAT, even if there is a key function. Some
2514 variants (e.g., the ARM EABI) says that class data
2515 only has COMDAT linkage if the class data might be
2516 emitted in more than one translation unit. When the
2517 key method can be inline and is inline, we still have
2518 to arrange for comdat even though
2519 class_data_always_comdat is false. */
2520 if (!CLASSTYPE_KEY_METHOD (class_type
)
2521 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type
))
2522 || targetm
.cxx
.class_data_always_comdat ())
2524 /* The ABI requires COMDAT linkage. Normally, we
2525 only emit COMDAT things when they are needed;
2526 make sure that we realize that this entity is
2533 else if (!flag_implicit_templates
2534 && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type
))
2539 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_TINFO_P (decl
))
2541 tree type
= TREE_TYPE (DECL_NAME (decl
));
2542 if (CLASS_TYPE_P (type
))
2545 import_export_class (type
);
2546 if (CLASSTYPE_INTERFACE_KNOWN (type
)
2547 && TYPE_POLYMORPHIC_P (type
)
2548 && CLASSTYPE_INTERFACE_ONLY (type
)
2549 /* If -fno-rtti was specified, then we cannot be sure
2550 that RTTI information will be emitted with the
2551 virtual table of the class, so we must emit it
2552 wherever it is used. */
2557 if (CLASSTYPE_INTERFACE_KNOWN (type
)
2558 && !CLASSTYPE_INTERFACE_ONLY (type
))
2560 comdat_p
= (targetm
.cxx
.class_data_always_comdat ()
2561 || (CLASSTYPE_KEY_METHOD (type
)
2562 && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type
))));
2567 DECL_EXTERNAL (decl
) = 0;
2577 else if (DECL_TEMPLATE_INSTANTIATION (decl
)
2578 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl
))
2580 /* DECL is an implicit instantiation of a function or static
2582 if ((flag_implicit_templates
2583 && !flag_use_repository
)
2584 || (flag_implicit_inline_templates
2585 && TREE_CODE (decl
) == FUNCTION_DECL
2586 && DECL_DECLARED_INLINE_P (decl
)))
2589 /* If we are not implicitly generating templates, then mark
2590 this entity as undefined in this translation unit. */
2593 else if (DECL_FUNCTION_MEMBER_P (decl
))
2595 if (!DECL_DECLARED_INLINE_P (decl
))
2597 tree ctype
= DECL_CONTEXT (decl
);
2598 import_export_class (ctype
);
2599 if (CLASSTYPE_INTERFACE_KNOWN (ctype
))
2601 DECL_NOT_REALLY_EXTERN (decl
)
2602 = ! (CLASSTYPE_INTERFACE_ONLY (ctype
)
2603 || (DECL_DECLARED_INLINE_P (decl
)
2604 && ! flag_implement_inlines
2605 && !DECL_VINDEX (decl
)));
2607 if (!DECL_NOT_REALLY_EXTERN (decl
))
2608 DECL_EXTERNAL (decl
) = 1;
2610 /* Always make artificials weak. */
2611 if (DECL_ARTIFICIAL (decl
) && flag_weak
)
2614 maybe_make_one_only (decl
);
2625 /* If we are importing DECL into this translation unit, mark is
2626 an undefined here. */
2627 DECL_EXTERNAL (decl
) = 1;
2628 DECL_NOT_REALLY_EXTERN (decl
) = 0;
2632 /* If we decided to put DECL in COMDAT, mark it accordingly at
2634 comdat_linkage (decl
);
2637 DECL_INTERFACE_KNOWN (decl
) = 1;
2640 /* Return an expression that performs the destruction of DECL, which
2641 must be a VAR_DECL whose type has a non-trivial destructor, or is
2642 an array whose (innermost) elements have a non-trivial destructor. */
2645 build_cleanup (tree decl
)
2648 tree type
= TREE_TYPE (decl
);
2650 /* This function should only be called for declarations that really
2651 require cleanups. */
2652 gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type
));
2654 /* Treat all objects with destructors as used; the destructor may do
2655 something substantive. */
2658 if (TREE_CODE (type
) == ARRAY_TYPE
)
2661 temp
= build_address (decl
);
2662 temp
= build_delete (TREE_TYPE (temp
), temp
,
2663 sfk_complete_destructor
,
2664 LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
, 0,
2665 tf_warning_or_error
);
2669 /* Returns the initialization guard variable for the variable DECL,
2670 which has static storage duration. */
2673 get_guard (tree decl
)
2678 sname
= mangle_guard_variable (decl
);
2679 guard
= IDENTIFIER_GLOBAL_VALUE (sname
);
2684 /* We use a type that is big enough to contain a mutex as well
2685 as an integer counter. */
2686 guard_type
= targetm
.cxx
.guard_type ();
2687 guard
= build_decl (DECL_SOURCE_LOCATION (decl
),
2688 VAR_DECL
, sname
, guard_type
);
2690 /* The guard should have the same linkage as what it guards. */
2691 TREE_PUBLIC (guard
) = TREE_PUBLIC (decl
);
2692 TREE_STATIC (guard
) = TREE_STATIC (decl
);
2693 DECL_COMMON (guard
) = DECL_COMMON (decl
);
2694 DECL_COMDAT (guard
) = DECL_COMDAT (decl
);
2695 if (DECL_ONE_ONLY (decl
))
2696 make_decl_one_only (guard
, cxx_comdat_group (guard
));
2697 if (TREE_PUBLIC (decl
))
2698 DECL_WEAK (guard
) = DECL_WEAK (decl
);
2699 DECL_VISIBILITY (guard
) = DECL_VISIBILITY (decl
);
2700 DECL_VISIBILITY_SPECIFIED (guard
) = DECL_VISIBILITY_SPECIFIED (decl
);
2702 DECL_ARTIFICIAL (guard
) = 1;
2703 DECL_IGNORED_P (guard
) = 1;
2704 TREE_USED (guard
) = 1;
2705 pushdecl_top_level_and_finish (guard
, NULL_TREE
);
2710 /* Return those bits of the GUARD variable that should be set when the
2711 guarded entity is actually initialized. */
2714 get_guard_bits (tree guard
)
2716 if (!targetm
.cxx
.guard_mask_bit ())
2718 /* We only set the first byte of the guard, in order to leave room
2719 for a mutex in the high-order bits. */
2720 guard
= build1 (ADDR_EXPR
,
2721 build_pointer_type (TREE_TYPE (guard
)),
2723 guard
= build1 (NOP_EXPR
,
2724 build_pointer_type (char_type_node
),
2726 guard
= build1 (INDIRECT_REF
, char_type_node
, guard
);
2732 /* Return an expression which determines whether or not the GUARD
2733 variable has already been initialized. */
2736 get_guard_cond (tree guard
)
2740 /* Check to see if the GUARD is zero. */
2741 guard
= get_guard_bits (guard
);
2743 /* Mask off all but the low bit. */
2744 if (targetm
.cxx
.guard_mask_bit ())
2746 guard_value
= integer_one_node
;
2747 if (!same_type_p (TREE_TYPE (guard_value
), TREE_TYPE (guard
)))
2748 guard_value
= convert (TREE_TYPE (guard
), guard_value
);
2749 guard
= cp_build_binary_op (input_location
,
2750 BIT_AND_EXPR
, guard
, guard_value
,
2751 tf_warning_or_error
);
2754 guard_value
= integer_zero_node
;
2755 if (!same_type_p (TREE_TYPE (guard_value
), TREE_TYPE (guard
)))
2756 guard_value
= convert (TREE_TYPE (guard
), guard_value
);
2757 return cp_build_binary_op (input_location
,
2758 EQ_EXPR
, guard
, guard_value
,
2759 tf_warning_or_error
);
2762 /* Return an expression which sets the GUARD variable, indicating that
2763 the variable being guarded has been initialized. */
2766 set_guard (tree guard
)
2770 /* Set the GUARD to one. */
2771 guard
= get_guard_bits (guard
);
2772 guard_init
= integer_one_node
;
2773 if (!same_type_p (TREE_TYPE (guard_init
), TREE_TYPE (guard
)))
2774 guard_init
= convert (TREE_TYPE (guard
), guard_init
);
2775 return cp_build_modify_expr (guard
, NOP_EXPR
, guard_init
,
2776 tf_warning_or_error
);
2779 /* Start the process of running a particular set of global constructors
2780 or destructors. Subroutine of do_[cd]tors. */
2783 start_objects (int method_type
, int initp
)
2789 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
2791 if (initp
!= DEFAULT_INIT_PRIORITY
)
2801 sprintf (type
, "sub_%c%c%.5u", method_type
, joiner
, initp
);
2804 sprintf (type
, "sub_%c", method_type
);
2806 fndecl
= build_lang_decl (FUNCTION_DECL
,
2807 get_file_function_name (type
),
2808 build_function_type_list (void_type_node
,
2810 start_preparsed_function (fndecl
, /*attrs=*/NULL_TREE
, SF_PRE_PARSED
);
2812 TREE_PUBLIC (current_function_decl
) = 0;
2814 /* Mark as artificial because it's not explicitly in the user's
2816 DECL_ARTIFICIAL (current_function_decl
) = 1;
2818 /* Mark this declaration as used to avoid spurious warnings. */
2819 TREE_USED (current_function_decl
) = 1;
2821 /* Mark this function as a global constructor or destructor. */
2822 if (method_type
== 'I')
2823 DECL_GLOBAL_CTOR_P (current_function_decl
) = 1;
2825 DECL_GLOBAL_DTOR_P (current_function_decl
) = 1;
2827 body
= begin_compound_stmt (BCS_FN_BODY
);
2832 /* Finish the process of running a particular set of global constructors
2833 or destructors. Subroutine of do_[cd]tors. */
2836 finish_objects (int method_type
, int initp
, tree body
)
2841 finish_compound_stmt (body
);
2842 fn
= finish_function (0);
2844 if (method_type
== 'I')
2846 DECL_STATIC_CONSTRUCTOR (fn
) = 1;
2847 decl_init_priority_insert (fn
, initp
);
2851 DECL_STATIC_DESTRUCTOR (fn
) = 1;
2852 decl_fini_priority_insert (fn
, initp
);
2855 expand_or_defer_fn (fn
);
2858 /* The names of the parameters to the function created to handle
2859 initializations and destructions for objects with static storage
2861 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2862 #define PRIORITY_IDENTIFIER "__priority"
2864 /* The name of the function we create to handle initializations and
2865 destructions for objects with static storage duration. */
2866 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2868 /* The declaration for the __INITIALIZE_P argument. */
2869 static GTY(()) tree initialize_p_decl
;
2871 /* The declaration for the __PRIORITY argument. */
2872 static GTY(()) tree priority_decl
;
2874 /* The declaration for the static storage duration function. */
2875 static GTY(()) tree ssdf_decl
;
2877 /* All the static storage duration functions created in this
2878 translation unit. */
2879 static GTY(()) VEC(tree
,gc
) *ssdf_decls
;
2881 /* A map from priority levels to information about that priority
2882 level. There may be many such levels, so efficient lookup is
2884 static splay_tree priority_info_map
;
2886 /* Begins the generation of the function that will handle all
2887 initialization and destruction of objects with static storage
2888 duration. The function generated takes two parameters of type
2889 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2890 nonzero, it performs initializations. Otherwise, it performs
2891 destructions. It only performs those initializations or
2892 destructions with the indicated __PRIORITY. The generated function
2895 It is assumed that this function will only be called once per
2896 translation unit. */
2899 start_static_storage_duration_function (unsigned count
)
2903 char id
[sizeof (SSDF_IDENTIFIER
) + 1 /* '\0' */ + 32];
2905 /* Create the identifier for this function. It will be of the form
2906 SSDF_IDENTIFIER_<number>. */
2907 sprintf (id
, "%s_%u", SSDF_IDENTIFIER
, count
);
2909 type
= build_function_type_list (void_type_node
,
2910 integer_type_node
, integer_type_node
,
2913 /* Create the FUNCTION_DECL itself. */
2914 ssdf_decl
= build_lang_decl (FUNCTION_DECL
,
2915 get_identifier (id
),
2917 TREE_PUBLIC (ssdf_decl
) = 0;
2918 DECL_ARTIFICIAL (ssdf_decl
) = 1;
2920 /* Put this function in the list of functions to be called from the
2921 static constructors and destructors. */
2924 ssdf_decls
= VEC_alloc (tree
, gc
, 32);
2926 /* Take this opportunity to initialize the map from priority
2927 numbers to information about that priority level. */
2928 priority_info_map
= splay_tree_new (splay_tree_compare_ints
,
2929 /*delete_key_fn=*/0,
2930 /*delete_value_fn=*/
2931 (splay_tree_delete_value_fn
) &free
);
2933 /* We always need to generate functions for the
2934 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2935 priorities later, we'll be sure to find the
2936 DEFAULT_INIT_PRIORITY. */
2937 get_priority_info (DEFAULT_INIT_PRIORITY
);
2940 VEC_safe_push (tree
, gc
, ssdf_decls
, ssdf_decl
);
2942 /* Create the argument list. */
2943 initialize_p_decl
= cp_build_parm_decl
2944 (get_identifier (INITIALIZE_P_IDENTIFIER
), integer_type_node
);
2945 DECL_CONTEXT (initialize_p_decl
) = ssdf_decl
;
2946 TREE_USED (initialize_p_decl
) = 1;
2947 priority_decl
= cp_build_parm_decl
2948 (get_identifier (PRIORITY_IDENTIFIER
), integer_type_node
);
2949 DECL_CONTEXT (priority_decl
) = ssdf_decl
;
2950 TREE_USED (priority_decl
) = 1;
2952 DECL_CHAIN (initialize_p_decl
) = priority_decl
;
2953 DECL_ARGUMENTS (ssdf_decl
) = initialize_p_decl
;
2955 /* Put the function in the global scope. */
2956 pushdecl (ssdf_decl
);
2958 /* Start the function itself. This is equivalent to declaring the
2961 static void __ssdf (int __initialize_p, init __priority_p);
2963 It is static because we only need to call this function from the
2964 various constructor and destructor functions for this module. */
2965 start_preparsed_function (ssdf_decl
,
2966 /*attrs=*/NULL_TREE
,
2969 /* Set up the scope of the outermost block in the function. */
2970 body
= begin_compound_stmt (BCS_FN_BODY
);
2975 /* Finish the generation of the function which performs initialization
2976 and destruction of objects with static storage duration. After
2977 this point, no more such objects can be created. */
2980 finish_static_storage_duration_function (tree body
)
2982 /* Close out the function. */
2983 finish_compound_stmt (body
);
2984 expand_or_defer_fn (finish_function (0));
2987 /* Return the information about the indicated PRIORITY level. If no
2988 code to handle this level has yet been generated, generate the
2989 appropriate prologue. */
2991 static priority_info
2992 get_priority_info (int priority
)
2997 n
= splay_tree_lookup (priority_info_map
,
2998 (splay_tree_key
) priority
);
3001 /* Create a new priority information structure, and insert it
3003 pi
= XNEW (struct priority_info_s
);
3004 pi
->initializations_p
= 0;
3005 pi
->destructions_p
= 0;
3006 splay_tree_insert (priority_info_map
,
3007 (splay_tree_key
) priority
,
3008 (splay_tree_value
) pi
);
3011 pi
= (priority_info
) n
->value
;
3016 /* The effective initialization priority of a DECL. */
3018 #define DECL_EFFECTIVE_INIT_PRIORITY(decl) \
3019 ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
3020 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
3022 /* Whether a DECL needs a guard to protect it against multiple
3025 #define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \
3026 || DECL_ONE_ONLY (decl) \
3027 || DECL_WEAK (decl)))
3029 /* Called from one_static_initialization_or_destruction(),
3031 Walks the initializer list of a global variable and looks for
3032 temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0)
3033 and that have their DECL_CONTEXT() == NULL.
3034 For each such temporary variable, set their DECL_CONTEXT() to
3035 the current function. This is necessary because otherwise
3036 some optimizers (enabled by -O2 -fprofile-arcs) might crash
3037 when trying to refer to a temporary variable that does not have
3038 it's DECL_CONTECT() properly set. */
3040 fix_temporary_vars_context_r (tree
*node
,
3041 int *unused ATTRIBUTE_UNUSED
,
3042 void *unused1 ATTRIBUTE_UNUSED
)
3044 gcc_assert (current_function_decl
);
3046 if (TREE_CODE (*node
) == BIND_EXPR
)
3050 for (var
= BIND_EXPR_VARS (*node
); var
; var
= DECL_CHAIN (var
))
3051 if (TREE_CODE (var
) == VAR_DECL
3053 && DECL_ARTIFICIAL (var
)
3054 && !DECL_CONTEXT (var
))
3055 DECL_CONTEXT (var
) = current_function_decl
;
3061 /* Set up to handle the initialization or destruction of DECL. If
3062 INITP is nonzero, we are initializing the variable. Otherwise, we
3063 are destroying it. */
3066 one_static_initialization_or_destruction (tree decl
, tree init
, bool initp
)
3068 tree guard_if_stmt
= NULL_TREE
;
3071 /* If we are supposed to destruct and there's a trivial destructor,
3072 nothing has to be done. */
3074 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
3077 /* Trick the compiler into thinking we are at the file and line
3078 where DECL was declared so that error-messages make sense, and so
3079 that the debugger will show somewhat sensible file and line
3081 input_location
= DECL_SOURCE_LOCATION (decl
);
3083 /* Make sure temporary variables in the initialiser all have
3084 their DECL_CONTEXT() set to a value different from NULL_TREE.
3085 This can happen when global variables initialisers are built.
3086 In that case, the DECL_CONTEXT() of the global variables _AND_ of all
3087 the temporary variables that might have been generated in the
3088 accompagning initialisers is NULL_TREE, meaning the variables have been
3089 declared in the global namespace.
3090 What we want to do here is to fix that and make sure the DECL_CONTEXT()
3091 of the temporaries are set to the current function decl. */
3092 cp_walk_tree_without_duplicates (&init
,
3093 fix_temporary_vars_context_r
,
3100 Access control for implicit calls to the constructors,
3101 the conversion functions, or the destructor called to
3102 create and destroy a static data member is performed as
3103 if these calls appeared in the scope of the member's
3106 we pretend we are in a static member function of the class of
3107 which the DECL is a member. */
3108 if (member_p (decl
))
3110 DECL_CONTEXT (current_function_decl
) = DECL_CONTEXT (decl
);
3111 DECL_STATIC_FUNCTION_P (current_function_decl
) = 1;
3114 /* Assume we don't need a guard. */
3116 /* We need a guard if this is an object with external linkage that
3117 might be initialized in more than one place. (For example, a
3118 static data member of a template, when the data member requires
3120 if (NEEDS_GUARD_P (decl
))
3124 guard
= get_guard (decl
);
3126 /* When using __cxa_atexit, we just check the GUARD as we would
3127 for a local static. */
3128 if (flag_use_cxa_atexit
)
3130 /* When using __cxa_atexit, we never try to destroy
3131 anything from a static destructor. */
3133 guard_cond
= get_guard_cond (guard
);
3135 /* If we don't have __cxa_atexit, then we will be running
3136 destructors from .fini sections, or their equivalents. So,
3137 we need to know how many times we've tried to initialize this
3138 object. We do initializations only if the GUARD is zero,
3139 i.e., if we are the first to initialize the variable. We do
3140 destructions only if the GUARD is one, i.e., if we are the
3141 last to destroy the variable. */
3144 = cp_build_binary_op (input_location
,
3146 cp_build_unary_op (PREINCREMENT_EXPR
,
3149 tf_warning_or_error
),
3151 tf_warning_or_error
);
3154 = cp_build_binary_op (input_location
,
3156 cp_build_unary_op (PREDECREMENT_EXPR
,
3159 tf_warning_or_error
),
3161 tf_warning_or_error
);
3163 guard_if_stmt
= begin_if_stmt ();
3164 finish_if_stmt_cond (guard_cond
, guard_if_stmt
);
3168 /* If we're using __cxa_atexit, we have not already set the GUARD,
3169 so we must do so now. */
3170 if (guard
&& initp
&& flag_use_cxa_atexit
)
3171 finish_expr_stmt (set_guard (guard
));
3173 /* Perform the initialization or destruction. */
3177 finish_expr_stmt (init
);
3179 /* If we're using __cxa_atexit, register a function that calls the
3180 destructor for the object. */
3181 if (flag_use_cxa_atexit
)
3182 finish_expr_stmt (register_dtor_fn (decl
));
3185 finish_expr_stmt (build_cleanup (decl
));
3187 /* Finish the guard if-stmt, if necessary. */
3190 finish_then_clause (guard_if_stmt
);
3191 finish_if_stmt (guard_if_stmt
);
3194 /* Now that we're done with DECL we don't need to pretend to be a
3195 member of its class any longer. */
3196 DECL_CONTEXT (current_function_decl
) = NULL_TREE
;
3197 DECL_STATIC_FUNCTION_P (current_function_decl
) = 0;
3200 /* Generate code to do the initialization or destruction of the decls in VARS,
3201 a TREE_LIST of VAR_DECL with static storage duration.
3202 Whether initialization or destruction is performed is specified by INITP. */
3205 do_static_initialization_or_destruction (tree vars
, bool initp
)
3207 tree node
, init_if_stmt
, cond
;
3209 /* Build the outer if-stmt to check for initialization or destruction. */
3210 init_if_stmt
= begin_if_stmt ();
3211 cond
= initp
? integer_one_node
: integer_zero_node
;
3212 cond
= cp_build_binary_op (input_location
,
3216 tf_warning_or_error
);
3217 finish_if_stmt_cond (cond
, init_if_stmt
);
3221 tree decl
= TREE_VALUE (node
);
3222 tree priority_if_stmt
;
3226 /* If we don't need a destructor, there's nothing to do. Avoid
3227 creating a possibly empty if-stmt. */
3228 if (!initp
&& TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
3230 node
= TREE_CHAIN (node
);
3234 /* Remember that we had an initialization or finalization at this
3236 priority
= DECL_EFFECTIVE_INIT_PRIORITY (decl
);
3237 pi
= get_priority_info (priority
);
3239 pi
->initializations_p
= 1;
3241 pi
->destructions_p
= 1;
3243 /* Conditionalize this initialization on being in the right priority
3244 and being initializing/finalizing appropriately. */
3245 priority_if_stmt
= begin_if_stmt ();
3246 cond
= cp_build_binary_op (input_location
,
3249 build_int_cst (NULL_TREE
, priority
),
3250 tf_warning_or_error
);
3251 finish_if_stmt_cond (cond
, priority_if_stmt
);
3253 /* Process initializers with same priority. */
3255 && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node
)) == priority
;
3256 node
= TREE_CHAIN (node
))
3257 /* Do one initialization or destruction. */
3258 one_static_initialization_or_destruction (TREE_VALUE (node
),
3259 TREE_PURPOSE (node
), initp
);
3261 /* Finish up the priority if-stmt body. */
3262 finish_then_clause (priority_if_stmt
);
3263 finish_if_stmt (priority_if_stmt
);
3267 /* Finish up the init/destruct if-stmt body. */
3268 finish_then_clause (init_if_stmt
);
3269 finish_if_stmt (init_if_stmt
);
3272 /* VARS is a list of variables with static storage duration which may
3273 need initialization and/or finalization. Remove those variables
3274 that don't really need to be initialized or finalized, and return
3275 the resulting list. The order in which the variables appear in
3276 VARS is in reverse order of the order in which they should actually
3277 be initialized. The list we return is in the unreversed order;
3278 i.e., the first variable should be initialized first. */
3281 prune_vars_needing_no_initialization (tree
*vars
)
3284 tree result
= NULL_TREE
;
3289 tree decl
= TREE_VALUE (t
);
3290 tree init
= TREE_PURPOSE (t
);
3292 /* Deal gracefully with error. */
3293 if (decl
== error_mark_node
)
3295 var
= &TREE_CHAIN (t
);
3299 /* The only things that can be initialized are variables. */
3300 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
3302 /* If this object is not defined, we don't need to do anything
3304 if (DECL_EXTERNAL (decl
))
3306 var
= &TREE_CHAIN (t
);
3310 /* Also, if the initializer already contains errors, we can bail
3312 if (init
&& TREE_CODE (init
) == TREE_LIST
3313 && value_member (error_mark_node
, init
))
3315 var
= &TREE_CHAIN (t
);
3319 /* This variable is going to need initialization and/or
3320 finalization, so we add it to the list. */
3321 *var
= TREE_CHAIN (t
);
3322 TREE_CHAIN (t
) = result
;
3329 /* Make sure we have told the back end about all the variables in
3333 write_out_vars (tree vars
)
3337 for (v
= vars
; v
; v
= TREE_CHAIN (v
))
3339 tree var
= TREE_VALUE (v
);
3340 if (!var_finalized_p (var
))
3342 import_export_decl (var
);
3343 rest_of_decl_compilation (var
, 1, 1);
3348 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3349 (otherwise) that will initialize all global objects with static
3350 storage duration having the indicated PRIORITY. */
3353 generate_ctor_or_dtor_function (bool constructor_p
, int priority
,
3361 input_location
= *locus
;
3363 /* Was: locus->line++; */
3365 /* We use `I' to indicate initialization and `D' to indicate
3367 function_key
= constructor_p
? 'I' : 'D';
3369 /* We emit the function lazily, to avoid generating empty
3370 global constructors and destructors. */
3373 /* For Objective-C++, we may need to initialize metadata found in this module.
3374 This must be done _before_ any other static initializations. */
3375 if (c_dialect_objc () && (priority
== DEFAULT_INIT_PRIORITY
)
3376 && constructor_p
&& objc_static_init_needed_p ())
3378 body
= start_objects (function_key
, priority
);
3379 objc_generate_static_init_call (NULL_TREE
);
3382 /* Call the static storage duration function with appropriate
3384 FOR_EACH_VEC_ELT (tree
, ssdf_decls
, i
, fndecl
)
3386 /* Calls to pure or const functions will expand to nothing. */
3387 if (! (flags_from_decl_or_type (fndecl
) & (ECF_CONST
| ECF_PURE
)))
3392 body
= start_objects (function_key
, priority
);
3394 call
= cp_build_function_call_nary (fndecl
, tf_warning_or_error
,
3395 build_int_cst (NULL_TREE
,
3397 build_int_cst (NULL_TREE
,
3400 finish_expr_stmt (call
);
3404 /* Close out the function. */
3406 finish_objects (function_key
, priority
, body
);
3409 /* Generate constructor and destructor functions for the priority
3413 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n
, void * data
)
3415 location_t
*locus
= (location_t
*) data
;
3416 int priority
= (int) n
->key
;
3417 priority_info pi
= (priority_info
) n
->value
;
3419 /* Generate the functions themselves, but only if they are really
3421 if (pi
->initializations_p
)
3422 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority
, locus
);
3423 if (pi
->destructions_p
)
3424 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority
, locus
);
3426 /* Keep iterating. */
3430 /* Java requires that we be able to reference a local address for a
3431 method, and not be confused by PLT entries. If hidden aliases are
3432 supported, collect and return all the functions for which we should
3433 emit a hidden alias. */
3435 static struct pointer_set_t
*
3436 collect_candidates_for_java_method_aliases (void)
3438 struct cgraph_node
*node
;
3439 struct pointer_set_t
*candidates
= NULL
;
3441 #ifndef HAVE_GAS_HIDDEN
3445 FOR_EACH_FUNCTION (node
)
3447 tree fndecl
= node
->symbol
.decl
;
3449 if (DECL_CONTEXT (fndecl
)
3450 && TYPE_P (DECL_CONTEXT (fndecl
))
3451 && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl
))
3452 && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl
))
3454 if (candidates
== NULL
)
3455 candidates
= pointer_set_create ();
3456 pointer_set_insert (candidates
, fndecl
);
3464 /* Java requires that we be able to reference a local address for a
3465 method, and not be confused by PLT entries. If hidden aliases are
3466 supported, emit one for each java function that we've emitted.
3467 CANDIDATES is the set of FUNCTION_DECLs that were gathered
3468 by collect_candidates_for_java_method_aliases. */
3471 build_java_method_aliases (struct pointer_set_t
*candidates
)
3473 struct cgraph_node
*node
;
3475 #ifndef HAVE_GAS_HIDDEN
3479 FOR_EACH_FUNCTION (node
)
3481 tree fndecl
= node
->symbol
.decl
;
3483 if (TREE_ASM_WRITTEN (fndecl
)
3484 && pointer_set_contains (candidates
, fndecl
))
3486 /* Mangle the name in a predictable way; we need to reference
3487 this from a java compiled object file. */
3488 tree oid
, nid
, alias
;
3492 oid
= DECL_ASSEMBLER_NAME (fndecl
);
3493 oname
= IDENTIFIER_POINTER (oid
);
3494 gcc_assert (oname
[0] == '_' && oname
[1] == 'Z');
3495 nname
= ACONCAT (("_ZGA", oname
+2, NULL
));
3496 nid
= get_identifier (nname
);
3498 alias
= make_alias_for (fndecl
, nid
);
3499 TREE_PUBLIC (alias
) = 1;
3500 DECL_VISIBILITY (alias
) = VISIBILITY_HIDDEN
;
3502 assemble_alias (alias
, oid
);
3507 /* Return C++ property of T, based on given operation OP. */
3510 cpp_check (tree t
, cpp_operation op
)
3515 return DECL_PURE_VIRTUAL_P (t
);
3516 case IS_CONSTRUCTOR
:
3517 return DECL_CONSTRUCTOR_P (t
);
3519 return DECL_DESTRUCTOR_P (t
);
3520 case IS_COPY_CONSTRUCTOR
:
3521 return DECL_COPY_CONSTRUCTOR_P (t
);
3523 return TREE_CODE (t
) == TEMPLATE_DECL
;
3529 /* Collect source file references recursively, starting from NAMESPC. */
3532 collect_source_refs (tree namespc
)
3539 /* Iterate over names in this name space. */
3540 for (t
= NAMESPACE_LEVEL (namespc
)->names
; t
; t
= TREE_CHAIN (t
))
3541 if (!DECL_IS_BUILTIN (t
) )
3542 collect_source_ref (DECL_SOURCE_FILE (t
));
3544 /* Dump siblings, if any */
3545 collect_source_refs (TREE_CHAIN (namespc
));
3547 /* Dump children, if any */
3548 collect_source_refs (NAMESPACE_LEVEL (namespc
)->namespaces
);
3551 /* Collect decls relevant to SOURCE_FILE from all namespaces recursively,
3552 starting from NAMESPC. */
3555 collect_ada_namespace (tree namespc
, const char *source_file
)
3560 /* Collect decls from this namespace */
3561 collect_ada_nodes (NAMESPACE_LEVEL (namespc
)->names
, source_file
);
3563 /* Collect siblings, if any */
3564 collect_ada_namespace (TREE_CHAIN (namespc
), source_file
);
3566 /* Collect children, if any */
3567 collect_ada_namespace (NAMESPACE_LEVEL (namespc
)->namespaces
, source_file
);
3570 /* Returns true iff there is a definition available for variable or
3574 decl_defined_p (tree decl
)
3576 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3577 return (DECL_INITIAL (decl
) != NULL_TREE
);
3580 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
3581 return !DECL_EXTERNAL (decl
);
3585 /* Nonzero for a VAR_DECL whose value can be used in a constant expression.
3589 An integral constant-expression can only involve ... const
3590 variables of integral or enumeration types initialized with
3591 constant expressions ...
3593 C++0x also allows constexpr variables and temporaries initialized
3594 with constant expressions. We handle the former here, but the latter
3595 are just folded away in cxx_eval_constant_expression.
3597 The standard does not require that the expression be non-volatile.
3598 G++ implements the proposed correction in DR 457. */
3601 decl_constant_var_p (tree decl
)
3603 if (!decl_maybe_constant_var_p (decl
))
3606 /* We don't know if a template static data member is initialized with
3607 a constant expression until we instantiate its initializer. Even
3608 in the case of a constexpr variable, we can't treat it as a
3609 constant until its initializer is complete in case it's used in
3610 its own initializer. */
3612 return DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
);
3615 /* Returns true if DECL could be a symbolic constant variable, depending on
3619 decl_maybe_constant_var_p (tree decl
)
3621 tree type
= TREE_TYPE (decl
);
3622 if (TREE_CODE (decl
) != VAR_DECL
)
3624 if (DECL_DECLARED_CONSTEXPR_P (decl
))
3626 return (CP_TYPE_CONST_NON_VOLATILE_P (type
)
3627 && INTEGRAL_OR_ENUMERATION_TYPE_P (type
));
3630 /* Complain that DECL uses a type with no linkage but is never defined. */
3633 no_linkage_error (tree decl
)
3635 tree t
= no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false);
3636 if (TYPE_ANONYMOUS_P (t
))
3638 permerror (0, "%q+#D, declared using anonymous type, "
3639 "is used but never defined", decl
);
3640 if (is_typedef_decl (TYPE_NAME (t
)))
3641 permerror (0, "%q+#D does not refer to the unqualified type, "
3642 "so it is not used for linkage", TYPE_NAME (t
));
3645 permerror (0, "%q+#D, declared using local type %qT, "
3646 "is used but never defined", decl
, t
);
3649 /* Collect declarations from all namespaces relevant to SOURCE_FILE. */
3652 collect_all_refs (const char *source_file
)
3654 collect_ada_namespace (global_namespace
, source_file
);
3657 /* Clear DECL_EXTERNAL for NODE. */
3660 clear_decl_external (struct cgraph_node
*node
, void *data ATTRIBUTE_UNUSED
)
3662 DECL_EXTERNAL (node
->symbol
.decl
) = 0;
3666 /* This routine is called at the end of compilation.
3667 Its job is to create all the code needed to initialize and
3668 destroy the global aggregates. We do the destruction
3669 first, since that way we only need to reverse the decls once. */
3672 cp_write_global_declarations (void)
3678 unsigned ssdf_count
= 0;
3681 struct pointer_set_t
*candidates
;
3683 locus
= input_location
;
3686 /* Bad parse errors. Just forget about it. */
3687 if (! global_bindings_p () || current_class_type
3688 || !VEC_empty (tree
,decl_namespace_list
))
3692 c_common_write_pch ();
3694 cgraph_process_same_body_aliases ();
3696 /* Handle -fdump-ada-spec[-slim] */
3697 if (dump_enabled_p (TDI_ada
))
3699 if (get_dump_file_info (TDI_ada
)->flags
& TDF_SLIM
)
3700 collect_source_ref (main_input_filename
);
3702 collect_source_refs (global_namespace
);
3704 dump_ada_specs (collect_all_refs
, cpp_check
);
3707 /* FIXME - huh? was input_line -= 1;*/
3709 timevar_start (TV_PHASE_DEFERRED
);
3711 /* We now have to write out all the stuff we put off writing out.
3714 o Template specializations that we have not yet instantiated,
3715 but which are needed.
3716 o Initialization and destruction for non-local objects with
3717 static storage duration. (Local objects with static storage
3718 duration are initialized when their scope is first entered,
3719 and are cleaned up via atexit.)
3720 o Virtual function tables.
3722 All of these may cause others to be needed. For example,
3723 instantiating one function may cause another to be needed, and
3724 generating the initializer for an object may cause templates to be
3725 instantiated, etc., etc. */
3727 emit_support_tinfos ();
3736 /* If there are templates that we've put off instantiating, do
3738 instantiate_pending_templates (retries
);
3741 /* Write out virtual tables as required. Note that writing out
3742 the virtual table for a template class may cause the
3743 instantiation of members of that class. If we write out
3744 vtables then we remove the class from our list so we don't
3745 have to look at it again. */
3747 while (keyed_classes
!= NULL_TREE
3748 && maybe_emit_vtables (TREE_VALUE (keyed_classes
)))
3751 keyed_classes
= TREE_CHAIN (keyed_classes
);
3757 tree next
= TREE_CHAIN (t
);
3761 if (maybe_emit_vtables (TREE_VALUE (next
)))
3764 TREE_CHAIN (t
) = TREE_CHAIN (next
);
3769 next
= TREE_CHAIN (t
);
3773 /* Write out needed type info variables. We have to be careful
3774 looping through unemitted decls, because emit_tinfo_decl may
3775 cause other variables to be needed. New elements will be
3776 appended, and we remove from the vector those that actually
3778 for (i
= VEC_length (tree
, unemitted_tinfo_decls
);
3779 VEC_iterate (tree
, unemitted_tinfo_decls
, --i
, t
);)
3780 if (emit_tinfo_decl (t
))
3783 VEC_unordered_remove (tree
, unemitted_tinfo_decls
, i
);
3786 /* The list of objects with static storage duration is built up
3787 in reverse order. We clear STATIC_AGGREGATES so that any new
3788 aggregates added during the initialization of these will be
3789 initialized in the correct order when we next come around the
3791 vars
= prune_vars_needing_no_initialization (&static_aggregates
);
3795 /* We need to start a new initialization function each time
3796 through the loop. That's because we need to know which
3797 vtables have been referenced, and TREE_SYMBOL_REFERENCED
3798 isn't computed until a function is finished, and written
3799 out. That's a deficiency in the back end. When this is
3800 fixed, these initialization functions could all become
3801 inline, with resulting performance improvements. */
3804 /* Set the line and file, so that it is obviously not from
3806 input_location
= locus
;
3807 ssdf_body
= start_static_storage_duration_function (ssdf_count
);
3809 /* Make sure the back end knows about all the variables. */
3810 write_out_vars (vars
);
3812 /* First generate code to do all the initializations. */
3814 do_static_initialization_or_destruction (vars
, /*initp=*/true);
3816 /* Then, generate code to do all the destructions. Do these
3817 in reverse order so that the most recently constructed
3818 variable is the first destroyed. If we're using
3819 __cxa_atexit, then we don't need to do this; functions
3820 were registered at initialization time to destroy the
3822 if (!flag_use_cxa_atexit
&& vars
)
3824 vars
= nreverse (vars
);
3825 do_static_initialization_or_destruction (vars
, /*initp=*/false);
3830 /* Finish up the static storage duration function for this
3832 input_location
= locus
;
3833 finish_static_storage_duration_function (ssdf_body
);
3835 /* All those initializations and finalizations might cause
3836 us to need more inline functions, more template
3837 instantiations, etc. */
3840 /* ??? was: locus.line++; */
3843 /* Go through the set of inline functions whose bodies have not
3844 been emitted yet. If out-of-line copies of these functions
3845 are required, emit them. */
3846 FOR_EACH_VEC_ELT (tree
, deferred_fns
, i
, decl
)
3848 /* Does it need synthesizing? */
3849 if (DECL_DEFAULTED_FN (decl
) && ! DECL_INITIAL (decl
)
3850 && (! DECL_REALLY_EXTERN (decl
) || possibly_inlined_p (decl
)))
3852 /* Even though we're already at the top-level, we push
3853 there again. That way, when we pop back a few lines
3854 hence, all of our state is restored. Otherwise,
3855 finish_function doesn't clean things up, and we end
3856 up with CURRENT_FUNCTION_DECL set. */
3857 push_to_top_level ();
3858 /* The decl's location will mark where it was first
3859 needed. Save that so synthesize method can indicate
3860 where it was needed from, in case of error */
3861 input_location
= DECL_SOURCE_LOCATION (decl
);
3862 synthesize_method (decl
);
3863 pop_from_top_level ();
3867 if (!DECL_SAVED_TREE (decl
))
3870 /* We lie to the back end, pretending that some functions
3871 are not defined when they really are. This keeps these
3872 functions from being put out unnecessarily. But, we must
3873 stop lying when the functions are referenced, or if they
3874 are not comdat since they need to be put out now. If
3875 DECL_INTERFACE_KNOWN, then we have already set
3876 DECL_EXTERNAL appropriately, so there's no need to check
3877 again, and we do not want to clear DECL_EXTERNAL if a
3878 previous call to import_export_decl set it.
3880 This is done in a separate for cycle, because if some
3881 deferred function is contained in another deferred
3882 function later in deferred_fns varray,
3883 rest_of_compilation would skip this function and we
3884 really cannot expand the same function twice. */
3885 import_export_decl (decl
);
3886 if (DECL_NOT_REALLY_EXTERN (decl
)
3887 && DECL_INITIAL (decl
)
3888 && decl_needed_p (decl
))
3890 struct cgraph_node
*node
, *next
;
3892 node
= cgraph_get_node (decl
);
3893 if (node
->same_body_alias
)
3894 node
= cgraph_alias_aliased_node (node
);
3896 cgraph_for_node_and_aliases (node
, clear_decl_external
,
3898 /* If we mark !DECL_EXTERNAL one of the symbols in some comdat
3899 group, we need to mark all symbols in the same comdat group
3901 if (node
->symbol
.same_comdat_group
)
3902 for (next
= cgraph (node
->symbol
.same_comdat_group
);
3904 next
= cgraph (next
->symbol
.same_comdat_group
))
3905 cgraph_for_node_and_aliases (next
, clear_decl_external
,
3909 /* If we're going to need to write this function out, and
3910 there's already a body for it, create RTL for it now.
3911 (There might be no body if this is a method we haven't
3912 gotten around to synthesizing yet.) */
3913 if (!DECL_EXTERNAL (decl
)
3914 && decl_needed_p (decl
)
3915 && !TREE_ASM_WRITTEN (decl
)
3916 && !cgraph_get_node (decl
)->local
.finalized
)
3918 /* We will output the function; no longer consider it in this
3920 DECL_DEFER_OUTPUT (decl
) = 0;
3921 /* Generate RTL for this function now that we know we
3923 expand_or_defer_fn (decl
);
3924 /* If we're compiling -fsyntax-only pretend that this
3925 function has been written out so that we don't try to
3927 if (flag_syntax_only
)
3928 TREE_ASM_WRITTEN (decl
) = 1;
3933 if (walk_namespaces (wrapup_globals_for_namespace
, /*data=*/0))
3936 /* Static data members are just like namespace-scope globals. */
3937 FOR_EACH_VEC_ELT (tree
, pending_statics
, i
, decl
)
3939 if (var_finalized_p (decl
) || DECL_REALLY_EXTERN (decl
)
3940 /* Don't write it out if we haven't seen a definition. */
3941 || DECL_IN_AGGR_P (decl
))
3943 import_export_decl (decl
);
3944 /* If this static data member is needed, provide it to the
3946 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
3947 DECL_EXTERNAL (decl
) = 0;
3949 if (VEC_length (tree
, pending_statics
) != 0
3950 && wrapup_global_declarations (VEC_address (tree
, pending_statics
),
3951 VEC_length (tree
, pending_statics
)))
3958 /* All used inline functions must have a definition at this point. */
3959 FOR_EACH_VEC_ELT (tree
, deferred_fns
, i
, decl
)
3961 if (/* Check online inline functions that were actually used. */
3962 DECL_ODR_USED (decl
) && DECL_DECLARED_INLINE_P (decl
)
3963 /* If the definition actually was available here, then the
3964 fact that the function was not defined merely represents
3965 that for some reason (use of a template repository,
3966 #pragma interface, etc.) we decided not to emit the
3968 && !DECL_INITIAL (decl
)
3969 /* Don't complain if the template was defined. */
3970 && !(DECL_TEMPLATE_INSTANTIATION (decl
)
3971 && DECL_INITIAL (DECL_TEMPLATE_RESULT
3972 (template_for_substitution (decl
)))))
3974 warning (0, "inline function %q+D used but never defined", decl
);
3975 /* Avoid a duplicate warning from check_global_declaration_1. */
3976 TREE_NO_WARNING (decl
) = 1;
3980 /* So must decls that use a type with no linkage. */
3981 FOR_EACH_VEC_ELT (tree
, no_linkage_decls
, i
, decl
)
3982 if (!decl_defined_p (decl
))
3983 no_linkage_error (decl
);
3985 /* Then, do the Objective-C stuff. This is where all the
3986 Objective-C module stuff gets generated (symtab,
3987 class/protocol/selector lists etc). This must be done after C++
3988 templates, destructors etc. so that selectors used in C++
3989 templates are properly allocated. */
3990 if (c_dialect_objc ())
3991 objc_write_global_declarations ();
3993 /* We give C linkage to static constructors and destructors. */
3994 push_lang_context (lang_name_c
);
3996 /* Generate initialization and destruction functions for all
3997 priorities for which they are required. */
3998 if (priority_info_map
)
3999 splay_tree_foreach (priority_info_map
,
4000 generate_ctor_and_dtor_functions_for_priority
,
4002 else if (c_dialect_objc () && objc_static_init_needed_p ())
4003 /* If this is obj-c++ and we need a static init, call
4004 generate_ctor_or_dtor_function. */
4005 generate_ctor_or_dtor_function (/*constructor_p=*/true,
4006 DEFAULT_INIT_PRIORITY
, &locus
);
4008 /* We're done with the splay-tree now. */
4009 if (priority_info_map
)
4010 splay_tree_delete (priority_info_map
);
4012 /* Generate any missing aliases. */
4013 maybe_apply_pending_pragma_weaks ();
4015 /* We're done with static constructors, so we can go back to "C++"
4017 pop_lang_context ();
4019 /* Collect candidates for Java hidden aliases. */
4020 candidates
= collect_candidates_for_java_method_aliases ();
4022 timevar_stop (TV_PHASE_DEFERRED
);
4023 timevar_start (TV_PHASE_CGRAPH
);
4025 finalize_compilation_unit ();
4027 timevar_stop (TV_PHASE_CGRAPH
);
4028 timevar_start (TV_PHASE_CHECK_DBGINFO
);
4030 /* Now, issue warnings about static, but not defined, functions,
4031 etc., and emit debugging information. */
4032 walk_namespaces (wrapup_globals_for_namespace
, /*data=*/&reconsider
);
4033 if (VEC_length (tree
, pending_statics
) != 0)
4035 check_global_declarations (VEC_address (tree
, pending_statics
),
4036 VEC_length (tree
, pending_statics
));
4037 emit_debug_global_declarations (VEC_address (tree
, pending_statics
),
4038 VEC_length (tree
, pending_statics
));
4041 perform_deferred_noexcept_checks ();
4043 /* Generate hidden aliases for Java. */
4046 build_java_method_aliases (candidates
);
4047 pointer_set_destroy (candidates
);
4052 /* The entire file is now complete. If requested, dump everything
4056 FILE *stream
= dump_begin (TDI_tu
, &flags
);
4060 dump_node (global_namespace
, flags
& ~TDF_SLIM
, stream
);
4061 dump_end (TDI_tu
, stream
);
4065 if (flag_detailed_statistics
)
4067 dump_tree_statistics ();
4068 dump_time_statistics ();
4070 input_location
= locus
;
4072 #ifdef ENABLE_CHECKING
4073 validate_conversion_obstack ();
4074 #endif /* ENABLE_CHECKING */
4076 timevar_stop (TV_PHASE_CHECK_DBGINFO
);
4079 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
4080 function to call in parse-tree form; it has not yet been
4081 semantically analyzed. ARGS are the arguments to the function.
4082 They have already been semantically analyzed. This may change
4086 build_offset_ref_call_from_tree (tree fn
, VEC(tree
,gc
) **args
)
4089 VEC(tree
,gc
) *orig_args
= NULL
;
4094 object
= TREE_OPERAND (fn
, 0);
4096 if (processing_template_decl
)
4098 gcc_assert (TREE_CODE (fn
) == DOTSTAR_EXPR
4099 || TREE_CODE (fn
) == MEMBER_REF
);
4100 if (type_dependent_expression_p (fn
)
4101 || any_type_dependent_arguments_p (*args
))
4102 return build_nt_call_vec (fn
, *args
);
4104 orig_args
= make_tree_vector_copy (*args
);
4106 /* Transform the arguments and add the implicit "this"
4107 parameter. That must be done before the FN is transformed
4108 because we depend on the form of FN. */
4109 make_args_non_dependent (*args
);
4110 object
= build_non_dependent_expr (object
);
4111 if (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
)
4113 if (TREE_CODE (fn
) == DOTSTAR_EXPR
)
4114 object
= cp_build_addr_expr (object
, tf_warning_or_error
);
4115 VEC_safe_insert (tree
, gc
, *args
, 0, object
);
4117 /* Now that the arguments are done, transform FN. */
4118 fn
= build_non_dependent_expr (fn
);
4121 /* A qualified name corresponding to a bound pointer-to-member is
4122 represented as an OFFSET_REF:
4124 struct B { void g(); };
4126 void B::g() { (this->*p)(); } */
4127 if (TREE_CODE (fn
) == OFFSET_REF
)
4129 tree object_addr
= cp_build_addr_expr (object
, tf_warning_or_error
);
4130 fn
= TREE_OPERAND (fn
, 1);
4131 fn
= get_member_function_from_ptrfunc (&object_addr
, fn
,
4132 tf_warning_or_error
);
4133 VEC_safe_insert (tree
, gc
, *args
, 0, object_addr
);
4136 if (CLASS_TYPE_P (TREE_TYPE (fn
)))
4137 expr
= build_op_call (fn
, args
, tf_warning_or_error
);
4139 expr
= cp_build_function_call_vec (fn
, args
, tf_warning_or_error
);
4140 if (processing_template_decl
&& expr
!= error_mark_node
)
4141 expr
= build_min_non_dep_call_vec (expr
, orig_fn
, orig_args
);
4143 if (orig_args
!= NULL
)
4144 release_tree_vector (orig_args
);
4151 check_default_args (tree x
)
4153 tree arg
= TYPE_ARG_TYPES (TREE_TYPE (x
));
4154 bool saw_def
= false;
4155 int i
= 0 - (TREE_CODE (TREE_TYPE (x
)) == METHOD_TYPE
);
4156 for (; arg
&& arg
!= void_list_node
; arg
= TREE_CHAIN (arg
), ++i
)
4158 if (TREE_PURPOSE (arg
))
4162 error ("default argument missing for parameter %P of %q+#D", i
, x
);
4163 TREE_PURPOSE (arg
) = error_mark_node
;
4168 /* Return true if function DECL can be inlined. This is used to force
4169 instantiation of methods that might be interesting for inlining. */
4171 possibly_inlined_p (tree decl
)
4173 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
);
4174 if (DECL_UNINLINABLE (decl
))
4176 if (!optimize
|| pragma_java_exceptions
)
4177 return DECL_DECLARED_INLINE_P (decl
);
4178 /* When optimizing, we might inline everything when flatten
4179 attribute or heuristics inlining for size or autoinlining
4184 /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
4185 If DECL is a specialization or implicitly declared class member,
4186 generate the actual definition. Return false if something goes
4187 wrong, true otherwise. */
4190 mark_used (tree decl
)
4192 /* If DECL is a BASELINK for a single function, then treat it just
4193 like the DECL for the function. Otherwise, if the BASELINK is
4194 for an overloaded function, we don't know which function was
4195 actually used until after overload resolution. */
4196 if (BASELINK_P (decl
))
4198 decl
= BASELINK_FUNCTIONS (decl
);
4199 if (really_overloaded_fn (decl
))
4201 decl
= OVL_CURRENT (decl
);
4204 /* Set TREE_USED for the benefit of -Wunused. */
4205 TREE_USED (decl
) = 1;
4206 if (DECL_CLONED_FUNCTION_P (decl
))
4207 TREE_USED (DECL_CLONED_FUNCTION (decl
)) = 1;
4209 if (TREE_CODE (decl
) == FUNCTION_DECL
4210 && DECL_DELETED_FN (decl
))
4212 if (DECL_ARTIFICIAL (decl
))
4214 if (DECL_OVERLOADED_OPERATOR_P (decl
) == TYPE_EXPR
4215 && LAMBDA_TYPE_P (DECL_CONTEXT (decl
)))
4217 /* We mark a lambda conversion op as deleted if we can't
4218 generate it properly; see maybe_add_lambda_conv_op. */
4219 sorry ("converting lambda which uses %<...%> to "
4220 "function pointer");
4224 error ("use of deleted function %qD", decl
);
4225 if (!maybe_explain_implicit_delete (decl
))
4226 error_at (DECL_SOURCE_LOCATION (decl
), "declared here");
4230 /* We can only check DECL_ODR_USED on variables or functions with
4231 DECL_LANG_SPECIFIC set, and these are also the only decls that we
4232 might need special handling for. */
4233 if ((TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
4234 || DECL_LANG_SPECIFIC (decl
) == NULL
4235 || DECL_THUNK_P (decl
))
4237 if (!processing_template_decl
&& type_uses_auto (TREE_TYPE (decl
)))
4238 error ("use of %qD before deduction of %<auto%>", decl
);
4242 /* We only want to do this processing once. We don't need to keep trying
4243 to instantiate inline templates, because unit-at-a-time will make sure
4244 we get them compiled before functions that want to inline them. */
4245 if (DECL_ODR_USED (decl
))
4248 /* If within finish_function, defer the rest until that function
4249 finishes, otherwise it might recurse. */
4250 if (defer_mark_used_calls
)
4252 VEC_safe_push (tree
, gc
, deferred_mark_used_calls
, decl
);
4256 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4257 maybe_instantiate_noexcept (decl
);
4259 /* Normally, we can wait until instantiation-time to synthesize DECL.
4260 However, if DECL is a static data member initialized with a constant
4261 or a constexpr function, we need it right now because a reference to
4262 such a data member or a call to such function is not value-dependent.
4263 For a function that uses auto in the return type, we need to instantiate
4264 it to find out its type. */
4265 if ((decl_maybe_constant_var_p (decl
)
4266 || (TREE_CODE (decl
) == FUNCTION_DECL
4267 && (DECL_DECLARED_CONSTEXPR_P (decl
)
4268 || type_uses_auto (TREE_TYPE (TREE_TYPE (decl
))))))
4269 && DECL_LANG_SPECIFIC (decl
)
4270 && DECL_TEMPLATE_INFO (decl
)
4271 && !uses_template_parms (DECL_TI_ARGS (decl
)))
4273 /* Instantiating a function will result in garbage collection. We
4274 must treat this situation as if we were within the body of a
4275 function so as to avoid collecting live data only referenced from
4276 the stack (such as overload resolution candidates). */
4278 instantiate_decl (decl
, /*defer_ok=*/false,
4279 /*expl_inst_class_mem_p=*/false);
4283 if (type_uses_auto (TREE_TYPE (decl
)))
4284 error ("use of %qD before deduction of %<auto%>", decl
);
4286 /* If we don't need a value, then we don't need to synthesize DECL. */
4287 if (cp_unevaluated_operand
!= 0)
4290 if (processing_template_decl
)
4293 /* Check this too in case we're within fold_non_dependent_expr. */
4294 if (DECL_TEMPLATE_INFO (decl
)
4295 && uses_template_parms (DECL_TI_ARGS (decl
)))
4298 DECL_ODR_USED (decl
) = 1;
4299 if (DECL_CLONED_FUNCTION_P (decl
))
4300 DECL_ODR_USED (DECL_CLONED_FUNCTION (decl
)) = 1;
4302 /* DR 757: A type without linkage shall not be used as the type of a
4303 variable or function with linkage, unless
4304 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
4305 o the variable or function is not used (3.2 [basic.def.odr]) or is
4306 defined in the same translation unit. */
4307 if (cxx_dialect
> cxx98
4308 && decl_linkage (decl
) != lk_none
4309 && !DECL_EXTERN_C_P (decl
)
4310 && !DECL_ARTIFICIAL (decl
)
4311 && !decl_defined_p (decl
)
4312 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
4314 if (is_local_extern (decl
))
4315 /* There's no way to define a local extern, and adding it to
4316 the vector interferes with GC, so give an error now. */
4317 no_linkage_error (decl
);
4319 VEC_safe_push (tree
, gc
, no_linkage_decls
, decl
);
4322 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_DECLARED_INLINE_P (decl
)
4323 && !DECL_INITIAL (decl
) && !DECL_ARTIFICIAL (decl
))
4324 /* Remember it, so we can check it was defined. */
4325 note_vague_linkage_fn (decl
);
4327 /* Is it a synthesized method that needs to be synthesized? */
4328 if (TREE_CODE (decl
) == FUNCTION_DECL
4329 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
)
4330 && DECL_DEFAULTED_FN (decl
)
4331 /* A function defaulted outside the class is synthesized either by
4332 cp_finish_decl or instantiate_decl. */
4333 && !DECL_DEFAULTED_OUTSIDE_CLASS_P (decl
)
4334 && ! DECL_INITIAL (decl
))
4336 /* Defer virtual destructors so that thunks get the right
4338 if (DECL_VIRTUAL_P (decl
) && !at_eof
)
4340 note_vague_linkage_fn (decl
);
4344 /* Remember the current location for a function we will end up
4345 synthesizing. Then we can inform the user where it was
4346 required in the case of error. */
4347 DECL_SOURCE_LOCATION (decl
) = input_location
;
4349 /* Synthesizing an implicitly defined member function will result in
4350 garbage collection. We must treat this situation as if we were
4351 within the body of a function so as to avoid collecting live data
4352 on the stack (such as overload resolution candidates).
4354 We could just let cp_write_global_declarations handle synthesizing
4355 this function by adding it to deferred_fns, but doing
4356 it at the use site produces better error messages. */
4358 synthesize_method (decl
);
4360 /* If this is a synthesized method we don't need to
4361 do the instantiation test below. */
4363 else if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
4364 && DECL_TEMPLATE_INFO (decl
)
4365 && (!DECL_EXPLICIT_INSTANTIATION (decl
)
4366 || always_instantiate_p (decl
)))
4367 /* If this is a function or variable that is an instance of some
4368 template, we now know that we will need to actually do the
4369 instantiation. We check that DECL is not an explicit
4370 instantiation because that is not checked in instantiate_decl.
4372 We put off instantiating functions in order to improve compile
4373 times. Maintaining a stack of active functions is expensive,
4374 and the inliner knows to instantiate any functions it might
4375 need. Therefore, we always try to defer instantiation. */
4378 instantiate_decl (decl
, /*defer_ok=*/true,
4379 /*expl_inst_class_mem_p=*/false);
4386 #include "gt-cp-decl2.h"