1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Hacked by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
46 #include "tree-mudflap.h"
48 #include "tree-inline.h"
50 #include "tree-dump.h"
53 #include "pointer-set.h"
54 #include "splay-tree.h"
56 extern cpp_reader *parse_in;
58 /* This structure contains information about the initializations
59 and/or destructions required for a particular priority level. */
60 typedef struct priority_info_s {
61 /* Nonzero if there have been any initializations at this priority
62 throughout the translation unit. */
63 int initializations_p;
64 /* Nonzero if there have been any destructions at this priority
65 throughout the translation unit. */
69 static void mark_vtable_entries (tree);
70 static bool maybe_emit_vtables (tree);
71 static bool acceptable_java_type (tree);
72 static tree start_objects (int, int);
73 static void finish_objects (int, int, tree);
74 static tree start_static_storage_duration_function (unsigned);
75 static void finish_static_storage_duration_function (tree);
76 static priority_info get_priority_info (int);
77 static void do_static_initialization_or_destruction (tree, bool);
78 static void one_static_initialization_or_destruction (tree, tree, bool);
79 static void generate_ctor_or_dtor_function (bool, int, location_t *);
80 static int generate_ctor_and_dtor_functions_for_priority (splay_tree_node,
82 static tree prune_vars_needing_no_initialization (tree *);
83 static void write_out_vars (tree);
84 static void import_export_class (tree);
85 static tree get_guard_bits (tree);
86 static void determine_visibility_from_class (tree, tree);
87 static bool decl_defined_p (tree);
89 /* A list of static class variables. This is needed, because a
90 static class variable can be declared inside the class without
91 an initializer, and then initialized, statically, outside the class. */
92 static GTY(()) VEC(tree,gc) *pending_statics;
94 /* A list of functions which were declared inline, but which we
95 may need to emit outline anyway. */
96 static GTY(()) VEC(tree,gc) *deferred_fns;
98 /* A list of decls that use types with no linkage, which we need to make
100 static GTY(()) VEC(tree,gc) *no_linkage_decls;
102 /* Nonzero if we're done parsing and into end-of-file activities. */
108 /* Return a member function type (a METHOD_TYPE), given FNTYPE (a
109 FUNCTION_TYPE), CTYPE (class type), and QUALS (the cv-qualifiers
110 that apply to the function). */
113 build_memfn_type (tree fntype, tree ctype, cp_cv_quals quals)
119 if (fntype == error_mark_node || ctype == error_mark_node)
120 return error_mark_node;
122 gcc_assert (TREE_CODE (fntype) == FUNCTION_TYPE
123 || TREE_CODE (fntype) == METHOD_TYPE);
125 type_quals = quals & ~TYPE_QUAL_RESTRICT;
126 ctype = cp_build_qualified_type (ctype, type_quals);
127 raises = TYPE_RAISES_EXCEPTIONS (fntype);
128 attrs = TYPE_ATTRIBUTES (fntype);
129 fntype = build_method_type_directly (ctype, TREE_TYPE (fntype),
130 (TREE_CODE (fntype) == METHOD_TYPE
131 ? TREE_CHAIN (TYPE_ARG_TYPES (fntype))
132 : TYPE_ARG_TYPES (fntype)));
134 fntype = build_exception_variant (fntype, raises);
136 fntype = cp_build_type_attribute_variant (fntype, attrs);
141 /* Return a variant of FNTYPE, a FUNCTION_TYPE or METHOD_TYPE, with its
142 return type changed to NEW_RET. */
145 change_return_type (tree new_ret, tree fntype)
148 tree args = TYPE_ARG_TYPES (fntype);
149 tree raises = TYPE_RAISES_EXCEPTIONS (fntype);
150 tree attrs = TYPE_ATTRIBUTES (fntype);
152 if (same_type_p (new_ret, TREE_TYPE (fntype)))
155 if (TREE_CODE (fntype) == FUNCTION_TYPE)
157 newtype = build_function_type (new_ret, args);
158 newtype = apply_memfn_quals (newtype, type_memfn_quals (fntype));
161 newtype = build_method_type_directly
162 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))),
163 new_ret, TREE_CHAIN (args));
165 newtype = build_exception_variant (newtype, raises);
167 newtype = cp_build_type_attribute_variant (newtype, attrs);
172 /* Build a PARM_DECL with NAME and TYPE, and set DECL_ARG_TYPE
176 cp_build_parm_decl (tree name, tree type)
178 tree parm = build_decl (input_location,
179 PARM_DECL, name, type);
180 /* DECL_ARG_TYPE is only used by the back end and the back end never
182 if (!processing_template_decl)
183 DECL_ARG_TYPE (parm) = type_passed_as (type);
185 /* If the type is a pack expansion, then we have a function
187 if (type && TREE_CODE (type) == TYPE_PACK_EXPANSION)
188 FUNCTION_PARAMETER_PACK_P (parm) = 1;
193 /* Returns a PARM_DECL for a parameter of the indicated TYPE, with the
197 build_artificial_parm (tree name, tree type)
199 tree parm = cp_build_parm_decl (name, type);
200 DECL_ARTIFICIAL (parm) = 1;
201 /* All our artificial parms are implicitly `const'; they cannot be
203 TREE_READONLY (parm) = 1;
207 /* Constructors for types with virtual baseclasses need an "in-charge" flag
208 saying whether this constructor is responsible for initialization of
209 virtual baseclasses or not. All destructors also need this "in-charge"
210 flag, which additionally determines whether or not the destructor should
211 free the memory for the object.
213 This function adds the "in-charge" flag to member function FN if
214 appropriate. It is called from grokclassfn and tsubst.
215 FN must be either a constructor or destructor.
217 The in-charge flag follows the 'this' parameter, and is followed by the
218 VTT parm (if any), then the user-written parms. */
221 maybe_retrofit_in_chrg (tree fn)
223 tree basetype, arg_types, parms, parm, fntype;
225 /* If we've already add the in-charge parameter don't do it again. */
226 if (DECL_HAS_IN_CHARGE_PARM_P (fn))
229 /* When processing templates we can't know, in general, whether or
230 not we're going to have virtual baseclasses. */
231 if (processing_template_decl)
234 /* We don't need an in-charge parameter for constructors that don't
235 have virtual bases. */
236 if (DECL_CONSTRUCTOR_P (fn)
237 && !CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
240 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
241 basetype = TREE_TYPE (TREE_VALUE (arg_types));
242 arg_types = TREE_CHAIN (arg_types);
244 parms = TREE_CHAIN (DECL_ARGUMENTS (fn));
246 /* If this is a subobject constructor or destructor, our caller will
247 pass us a pointer to our VTT. */
248 if (CLASSTYPE_VBASECLASSES (DECL_CONTEXT (fn)))
250 parm = build_artificial_parm (vtt_parm_identifier, vtt_parm_type);
252 /* First add it to DECL_ARGUMENTS between 'this' and the real args... */
253 TREE_CHAIN (parm) = parms;
256 /* ...and then to TYPE_ARG_TYPES. */
257 arg_types = hash_tree_chain (vtt_parm_type, arg_types);
259 DECL_HAS_VTT_PARM_P (fn) = 1;
262 /* Then add the in-charge parm (before the VTT parm). */
263 parm = build_artificial_parm (in_charge_identifier, integer_type_node);
264 TREE_CHAIN (parm) = parms;
266 arg_types = hash_tree_chain (integer_type_node, arg_types);
268 /* Insert our new parameter(s) into the list. */
269 TREE_CHAIN (DECL_ARGUMENTS (fn)) = parms;
271 /* And rebuild the function type. */
272 fntype = build_method_type_directly (basetype, TREE_TYPE (TREE_TYPE (fn)),
274 if (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)))
275 fntype = build_exception_variant (fntype,
276 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn)));
277 if (TYPE_ATTRIBUTES (TREE_TYPE (fn)))
278 fntype = (cp_build_type_attribute_variant
279 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (fn))));
280 TREE_TYPE (fn) = fntype;
282 /* Now we've got the in-charge parameter. */
283 DECL_HAS_IN_CHARGE_PARM_P (fn) = 1;
286 /* Classes overload their constituent function names automatically.
287 When a function name is declared in a record structure,
288 its name is changed to it overloaded name. Since names for
289 constructors and destructors can conflict, we place a leading
292 CNAME is the name of the class we are grokking for.
294 FUNCTION is a FUNCTION_DECL. It was created by `grokdeclarator'.
296 FLAGS contains bits saying what's special about today's
297 arguments. DTOR_FLAG == DESTRUCTOR.
299 If FUNCTION is a destructor, then we must add the `auto-delete' field
300 as a second parameter. There is some hair associated with the fact
301 that we must "declare" this variable in the manner consistent with the
302 way the rest of the arguments were declared.
304 QUALS are the qualifiers for the this pointer. */
307 grokclassfn (tree ctype, tree function, enum overload_flags flags)
309 tree fn_name = DECL_NAME (function);
311 /* Even within an `extern "C"' block, members get C++ linkage. See
312 [dcl.link] for details. */
313 SET_DECL_LANGUAGE (function, lang_cplusplus);
315 if (fn_name == NULL_TREE)
317 error ("name missing for member function");
318 fn_name = get_identifier ("<anonymous>");
319 DECL_NAME (function) = fn_name;
322 DECL_CONTEXT (function) = ctype;
324 if (flags == DTOR_FLAG)
325 DECL_DESTRUCTOR_P (function) = 1;
327 if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
328 maybe_retrofit_in_chrg (function);
331 /* Create an ARRAY_REF, checking for the user doing things backwards
335 grok_array_decl (tree array_expr, tree index_exp)
339 tree orig_array_expr = array_expr;
340 tree orig_index_exp = index_exp;
342 if (error_operand_p (array_expr) || error_operand_p (index_exp))
343 return error_mark_node;
345 if (processing_template_decl)
347 if (type_dependent_expression_p (array_expr)
348 || type_dependent_expression_p (index_exp))
349 return build_min_nt (ARRAY_REF, array_expr, index_exp,
350 NULL_TREE, NULL_TREE);
351 array_expr = build_non_dependent_expr (array_expr);
352 index_exp = build_non_dependent_expr (index_exp);
355 type = TREE_TYPE (array_expr);
357 type = non_reference (type);
359 /* If they have an `operator[]', use that. */
360 if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp)))
361 expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL,
362 array_expr, index_exp, NULL_TREE,
363 /*overloaded_p=*/NULL, tf_warning_or_error);
368 /* Otherwise, create an ARRAY_REF for a pointer or array type.
369 It is a little-known fact that, if `a' is an array and `i' is
370 an int, you can write `i[a]', which means the same thing as
372 if (TREE_CODE (type) == ARRAY_TYPE)
375 p1 = build_expr_type_conversion (WANT_POINTER, array_expr, false);
377 if (TREE_CODE (TREE_TYPE (index_exp)) == ARRAY_TYPE)
380 p2 = build_expr_type_conversion (WANT_POINTER, index_exp, false);
382 i1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, array_expr,
384 i2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, index_exp,
387 if ((p1 && i2) && (i1 && p2))
388 error ("ambiguous conversion for array subscript");
391 array_expr = p1, index_exp = i2;
393 array_expr = p2, index_exp = i1;
396 error ("invalid types %<%T[%T]%> for array subscript",
397 type, TREE_TYPE (index_exp));
398 return error_mark_node;
401 if (array_expr == error_mark_node || index_exp == error_mark_node)
402 error ("ambiguous conversion for array subscript");
404 expr = build_array_ref (input_location, array_expr, index_exp);
406 if (processing_template_decl && expr != error_mark_node)
407 return build_min_non_dep (ARRAY_REF, expr, orig_array_expr, orig_index_exp,
408 NULL_TREE, NULL_TREE);
412 /* Given the cast expression EXP, checking out its validity. Either return
413 an error_mark_node if there was an unavoidable error, return a cast to
414 void for trying to delete a pointer w/ the value 0, or return the
415 call to delete. If DOING_VEC is true, we handle things differently
416 for doing an array delete.
417 Implements ARM $5.3.4. This is called from the parser. */
420 delete_sanity (tree exp, tree size, bool doing_vec, int use_global_delete)
424 if (exp == error_mark_node)
427 if (processing_template_decl)
429 t = build_min (DELETE_EXPR, void_type_node, exp, size);
430 DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
431 DELETE_EXPR_USE_VEC (t) = doing_vec;
432 TREE_SIDE_EFFECTS (t) = 1;
436 /* An array can't have been allocated by new, so complain. */
437 if (TREE_CODE (exp) == VAR_DECL
438 && TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
439 warning (0, "deleting array %q#D", exp);
441 t = build_expr_type_conversion (WANT_POINTER, exp, true);
443 if (t == NULL_TREE || t == error_mark_node)
445 error ("type %q#T argument given to %<delete%>, expected pointer",
447 return error_mark_node;
450 type = TREE_TYPE (t);
452 /* As of Valley Forge, you can delete a pointer to const. */
454 /* You can't delete functions. */
455 if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
457 error ("cannot delete a function. Only pointer-to-objects are "
458 "valid arguments to %<delete%>");
459 return error_mark_node;
462 /* Deleting ptr to void is undefined behavior [expr.delete/3]. */
463 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
465 warning (0, "deleting %qT is undefined", type);
469 /* Deleting a pointer with the value zero is valid and has no effect. */
470 if (integer_zerop (t))
471 return build1 (NOP_EXPR, void_type_node, t);
474 return build_vec_delete (t, /*maxindex=*/NULL_TREE,
475 sfk_deleting_destructor,
478 return build_delete (type, t, sfk_deleting_destructor,
479 LOOKUP_NORMAL, use_global_delete);
482 /* Report an error if the indicated template declaration is not the
483 sort of thing that should be a member template. */
486 check_member_template (tree tmpl)
490 gcc_assert (TREE_CODE (tmpl) == TEMPLATE_DECL);
491 decl = DECL_TEMPLATE_RESULT (tmpl);
493 if (TREE_CODE (decl) == FUNCTION_DECL
494 || (TREE_CODE (decl) == TYPE_DECL
495 && MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))))
497 /* The parser rejects template declarations in local classes. */
498 gcc_assert (!current_function_decl);
499 /* The parser rejects any use of virtual in a function template. */
500 gcc_assert (!(TREE_CODE (decl) == FUNCTION_DECL
501 && DECL_VIRTUAL_P (decl)));
503 /* The debug-information generating code doesn't know what to do
504 with member templates. */
505 DECL_IGNORED_P (tmpl) = 1;
508 error ("template declaration of %q#D", decl);
511 /* Return true iff TYPE is a valid Java parameter or return type. */
514 acceptable_java_type (tree type)
516 if (type == error_mark_node)
519 if (TREE_CODE (type) == VOID_TYPE || TYPE_FOR_JAVA (type))
521 if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
523 type = TREE_TYPE (type);
524 if (TREE_CODE (type) == RECORD_TYPE)
527 if (! TYPE_FOR_JAVA (type))
529 if (! CLASSTYPE_TEMPLATE_INFO (type))
531 args = CLASSTYPE_TI_ARGS (type);
532 i = TREE_VEC_LENGTH (args);
535 type = TREE_VEC_ELT (args, i);
536 if (TREE_CODE (type) == POINTER_TYPE)
537 type = TREE_TYPE (type);
538 if (! TYPE_FOR_JAVA (type))
547 /* For a METHOD in a Java class CTYPE, return true if
548 the parameter and return types are valid Java types.
549 Otherwise, print appropriate error messages, and return false. */
552 check_java_method (tree method)
555 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (method));
556 tree ret_type = TREE_TYPE (TREE_TYPE (method));
558 if (!acceptable_java_type (ret_type))
560 error ("Java method %qD has non-Java return type %qT",
565 arg_types = TREE_CHAIN (arg_types);
566 if (DECL_HAS_IN_CHARGE_PARM_P (method))
567 arg_types = TREE_CHAIN (arg_types);
568 if (DECL_HAS_VTT_PARM_P (method))
569 arg_types = TREE_CHAIN (arg_types);
571 for (; arg_types != NULL_TREE; arg_types = TREE_CHAIN (arg_types))
573 tree type = TREE_VALUE (arg_types);
574 if (!acceptable_java_type (type))
576 if (type != error_mark_node)
577 error ("Java method %qD has non-Java parameter type %qT",
585 /* Sanity check: report error if this function FUNCTION is not
586 really a member of the class (CTYPE) it is supposed to belong to.
587 TEMPLATE_PARMS is used to specify the template parameters of a member
588 template passed as FUNCTION_DECL. If the member template is passed as a
589 TEMPLATE_DECL, it can be NULL since the parameters can be extracted
590 from the declaration. If the function is not a function template, it
592 It returns the original declaration for the function, NULL_TREE if
593 no declaration was found, error_mark_node if an error was emitted. */
596 check_classfn (tree ctype, tree function, tree template_parms)
602 if (DECL_USE_TEMPLATE (function)
603 && !(TREE_CODE (function) == TEMPLATE_DECL
604 && DECL_TEMPLATE_SPECIALIZATION (function))
605 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (function)))
606 /* Since this is a specialization of a member template,
607 we're not going to find the declaration in the class.
610 struct S { template <typename T> void f(T); };
611 template <> void S::f(int);
613 we're not going to find `S::f(int)', but there's no
614 reason we should, either. We let our callers know we didn't
615 find the method, but we don't complain. */
618 /* Basic sanity check: for a template function, the template parameters
619 either were not passed, or they are the same of DECL_TEMPLATE_PARMS. */
620 if (TREE_CODE (function) == TEMPLATE_DECL)
623 && !comp_template_parms (template_parms,
624 DECL_TEMPLATE_PARMS (function)))
626 error ("template parameter lists provided don't match the "
627 "template parameters of %qD", function);
628 return error_mark_node;
630 template_parms = DECL_TEMPLATE_PARMS (function);
633 /* OK, is this a definition of a member template? */
634 is_template = (template_parms != NULL_TREE);
636 /* We must enter the scope here, because conversion operators are
637 named by target type, and type equivalence relies on typenames
638 resolving within the scope of CTYPE. */
639 pushed_scope = push_scope (ctype);
640 ix = class_method_index_for_fn (complete_type (ctype), function);
643 VEC(tree,gc) *methods = CLASSTYPE_METHOD_VEC (ctype);
644 tree fndecls, fndecl = 0;
646 const char *format = NULL;
648 for (fndecls = VEC_index (tree, methods, ix);
649 fndecls; fndecls = OVL_NEXT (fndecls))
653 fndecl = OVL_CURRENT (fndecls);
654 p1 = TYPE_ARG_TYPES (TREE_TYPE (function));
655 p2 = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
657 /* We cannot simply call decls_match because this doesn't
658 work for static member functions that are pretending to
659 be methods, and because the name may have been changed by
662 /* Get rid of the this parameter on functions that become
664 if (DECL_STATIC_FUNCTION_P (fndecl)
665 && TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE)
666 p1 = TREE_CHAIN (p1);
668 /* A member template definition only matches a member template
670 if (is_template != (TREE_CODE (fndecl) == TEMPLATE_DECL))
673 if (same_type_p (TREE_TYPE (TREE_TYPE (function)),
674 TREE_TYPE (TREE_TYPE (fndecl)))
675 && compparms (p1, p2)
677 || comp_template_parms (template_parms,
678 DECL_TEMPLATE_PARMS (fndecl)))
679 && (DECL_TEMPLATE_SPECIALIZATION (function)
680 == DECL_TEMPLATE_SPECIALIZATION (fndecl))
681 && (!DECL_TEMPLATE_SPECIALIZATION (function)
682 || (DECL_TI_TEMPLATE (function)
683 == DECL_TI_TEMPLATE (fndecl))))
689 pop_scope (pushed_scope);
690 return OVL_CURRENT (fndecls);
693 error_at (DECL_SOURCE_LOCATION (function),
694 "prototype for %q#D does not match any in class %qT",
696 is_conv_op = DECL_CONV_FN_P (fndecl);
699 ix = CLASSTYPE_FIRST_CONVERSION_SLOT;
700 fndecls = VEC_index (tree, methods, ix);
703 fndecl = OVL_CURRENT (fndecls);
704 fndecls = OVL_NEXT (fndecls);
706 if (!fndecls && is_conv_op)
708 if (VEC_length (tree, methods) > (size_t) ++ix)
710 fndecls = VEC_index (tree, methods, ix);
711 if (!DECL_CONV_FN_P (OVL_CURRENT (fndecls)))
723 format = N_("candidates are: %+#D");
725 format = N_("candidate is: %+#D");
726 error (format, fndecl);
729 else if (!COMPLETE_TYPE_P (ctype))
730 cxx_incomplete_type_error (function, ctype);
732 error ("no %q#D member function declared in class %qT",
736 pop_scope (pushed_scope);
737 return error_mark_node;
740 /* DECL is a function with vague linkage. Remember it so that at the
741 end of the translation unit we can decide whether or not to emit
745 note_vague_linkage_fn (tree decl)
747 DECL_DEFER_OUTPUT (decl) = 1;
748 VEC_safe_push (tree, gc, deferred_fns, decl);
751 /* We have just processed the DECL, which is a static data member.
752 The other parameters are as for cp_finish_decl. */
755 finish_static_data_member_decl (tree decl,
756 tree init, bool init_const_expr_p,
760 DECL_CONTEXT (decl) = current_class_type;
762 /* We cannot call pushdecl here, because that would fill in the
763 TREE_CHAIN of our decl. Instead, we modify cp_finish_decl to do
764 the right thing, namely, to put this decl out straight away. */
766 if (! processing_template_decl)
767 VEC_safe_push (tree, gc, pending_statics, decl);
769 if (LOCAL_CLASS_P (current_class_type))
770 permerror (input_location, "local class %q#T shall not have static data member %q#D",
771 current_class_type, decl);
773 /* Static consts need not be initialized in the class definition. */
774 if (init != NULL_TREE && TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
776 static int explained = 0;
778 error ("initializer invalid for static member with constructor");
781 error ("(an out of class initialization is required)");
787 DECL_INITIAL (decl) = init;
788 DECL_IN_AGGR_P (decl) = 1;
790 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
791 && TYPE_DOMAIN (TREE_TYPE (decl)) == NULL_TREE)
792 SET_VAR_HAD_UNKNOWN_BOUND (decl);
794 cp_finish_decl (decl, init, init_const_expr_p, asmspec_tree, flags);
797 /* DECLARATOR and DECLSPECS correspond to a class member. The other
798 parameters are as for cp_finish_decl. Return the DECL for the
799 class member declared. */
802 grokfield (const cp_declarator *declarator,
803 cp_decl_specifier_seq *declspecs,
804 tree init, bool init_const_expr_p,
809 const char *asmspec = 0;
810 int flags = LOOKUP_ONLYCONVERTING;
814 && TREE_CODE (init) == TREE_LIST
815 && TREE_VALUE (init) == error_mark_node
816 && TREE_CHAIN (init) == NULL_TREE)
819 value = grokdeclarator (declarator, declspecs, FIELD, init != 0, &attrlist);
820 if (! value || error_operand_p (value))
821 /* friend or constructor went bad. */
822 return error_mark_node;
824 if (TREE_CODE (value) == TYPE_DECL && init)
826 error ("typedef %qD is initialized (use decltype instead)", value);
830 /* Pass friendly classes back. */
831 if (value == void_type_node)
834 /* Pass friend decls back. */
835 if ((TREE_CODE (value) == FUNCTION_DECL
836 || TREE_CODE (value) == TEMPLATE_DECL)
837 && DECL_CONTEXT (value) != current_class_type)
840 name = DECL_NAME (value);
842 if (name != NULL_TREE)
844 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
846 error ("explicit template argument list not allowed");
847 return error_mark_node;
850 if (IDENTIFIER_POINTER (name)[0] == '_'
851 && ! strcmp (IDENTIFIER_POINTER (name), "_vptr"))
852 error ("member %qD conflicts with virtual function table field name",
856 /* Stash away type declarations. */
857 if (TREE_CODE (value) == TYPE_DECL)
859 DECL_NONLOCAL (value) = 1;
860 DECL_CONTEXT (value) = current_class_type;
862 if (processing_template_decl)
863 value = push_template_decl (value);
869 /* If this is a typedef that names the class for linkage purposes
870 (7.1.3p8), apply any attributes directly to the type. */
871 if (TAGGED_TYPE_P (TREE_TYPE (value))
872 && value == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))))
873 attrflags = ATTR_FLAG_TYPE_IN_PLACE;
875 cplus_decl_attributes (&value, attrlist, attrflags);
878 if (declspecs->specs[(int)ds_typedef]
879 && TREE_TYPE (value) != error_mark_node
880 && TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (value))) != value)
881 cp_set_underlying_type (value);
886 if (DECL_IN_AGGR_P (value))
888 error ("%qD is already defined in %qT", value, DECL_CONTEXT (value));
889 return void_type_node;
892 if (asmspec_tree && asmspec_tree != error_mark_node)
893 asmspec = TREE_STRING_POINTER (asmspec_tree);
897 if (TREE_CODE (value) == FUNCTION_DECL)
899 /* Initializers for functions are rejected early in the parser.
900 If we get here, it must be a pure specifier for a method. */
901 if (init == ridpointers[(int)RID_DELETE])
903 DECL_DELETED_FN (value) = 1;
904 DECL_DECLARED_INLINE_P (value) = 1;
905 DECL_INITIAL (value) = error_mark_node;
907 else if (init == ridpointers[(int)RID_DEFAULT])
909 if (defaultable_fn_check (value))
911 DECL_DEFAULTED_FN (value) = 1;
912 DECL_INITIALIZED_IN_CLASS_P (value) = 1;
913 DECL_DECLARED_INLINE_P (value) = 1;
916 else if (TREE_CODE (TREE_TYPE (value)) == METHOD_TYPE)
918 if (integer_zerop (init))
919 DECL_PURE_VIRTUAL_P (value) = 1;
920 else if (error_operand_p (init))
921 ; /* An error has already been reported. */
923 error ("invalid initializer for member function %qD",
928 gcc_assert (TREE_CODE (TREE_TYPE (value)) == FUNCTION_TYPE);
929 error ("initializer specified for static member function %qD",
933 else if (pedantic && TREE_CODE (value) != VAR_DECL)
934 /* Already complained in grokdeclarator. */
936 else if (!processing_template_decl)
938 if (TREE_CODE (init) == CONSTRUCTOR)
939 init = digest_init (TREE_TYPE (value), init);
941 init = integral_constant_value (init);
943 if (init != error_mark_node && !TREE_CONSTANT (init))
945 /* We can allow references to things that are effectively
946 static, since references are initialized with the
948 if (TREE_CODE (TREE_TYPE (value)) != REFERENCE_TYPE
949 || (TREE_STATIC (init) == 0
950 && (!DECL_P (init) || DECL_EXTERNAL (init) == 0)))
952 error ("field initializer is not constant");
953 init = error_mark_node;
959 if (processing_template_decl
960 && (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
962 value = push_template_decl (value);
963 if (error_operand_p (value))
964 return error_mark_node;
968 cplus_decl_attributes (&value, attrlist, 0);
970 switch (TREE_CODE (value))
973 finish_static_data_member_decl (value, init, init_const_expr_p,
974 asmspec_tree, flags);
979 error ("%<asm%> specifiers are not permitted on non-static data members");
980 if (DECL_INITIAL (value) == error_mark_node)
981 init = error_mark_node;
982 cp_finish_decl (value, init, /*init_const_expr_p=*/false,
984 DECL_INITIAL (value) = init;
985 DECL_IN_AGGR_P (value) = 1;
990 set_user_assembler_name (value, asmspec);
992 cp_finish_decl (value,
994 /*init_const_expr_p=*/false,
995 asmspec_tree, flags);
997 /* Pass friends back this way. */
998 if (DECL_FRIEND_P (value))
999 return void_type_node;
1001 DECL_IN_AGGR_P (value) = 1;
1010 /* Like `grokfield', but for bitfields.
1011 WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node. */
1014 grokbitfield (const cp_declarator *declarator,
1015 cp_decl_specifier_seq *declspecs, tree width,
1018 tree value = grokdeclarator (declarator, declspecs, BITFIELD, 0, &attrlist);
1020 if (value == error_mark_node)
1021 return NULL_TREE; /* friends went bad. */
1023 /* Pass friendly classes back. */
1024 if (TREE_CODE (value) == VOID_TYPE)
1025 return void_type_node;
1027 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))
1028 && (POINTER_TYPE_P (value)
1029 || !dependent_type_p (TREE_TYPE (value))))
1031 error ("bit-field %qD with non-integral type", value);
1032 return error_mark_node;
1035 if (TREE_CODE (value) == TYPE_DECL)
1037 error ("cannot declare %qD to be a bit-field type", value);
1041 /* Usually, finish_struct_1 catches bitfields with invalid types.
1042 But, in the case of bitfields with function type, we confuse
1043 ourselves into thinking they are member functions, so we must
1045 if (TREE_CODE (value) == FUNCTION_DECL)
1047 error ("cannot declare bit-field %qD with function type",
1052 if (DECL_IN_AGGR_P (value))
1054 error ("%qD is already defined in the class %qT", value,
1055 DECL_CONTEXT (value));
1056 return void_type_node;
1059 if (TREE_STATIC (value))
1061 error ("static member %qD cannot be a bit-field", value);
1064 cp_finish_decl (value, NULL_TREE, false, NULL_TREE, 0);
1066 if (width != error_mark_node)
1068 constant_expression_warning (width);
1069 DECL_INITIAL (value) = width;
1070 SET_DECL_C_BIT_FIELD (value);
1073 DECL_IN_AGGR_P (value) = 1;
1076 cplus_decl_attributes (&value, attrlist, /*flags=*/0);
1082 /* Returns true iff ATTR is an attribute which needs to be applied at
1083 instantiation time rather than template definition time. */
1086 is_late_template_attribute (tree attr, tree decl)
1088 tree name = TREE_PURPOSE (attr);
1089 tree args = TREE_VALUE (attr);
1090 const struct attribute_spec *spec = lookup_attribute_spec (name);
1094 /* Unknown attribute. */
1097 /* Attribute weak handling wants to write out assembly right away. */
1098 if (is_attribute_p ("weak", name))
1101 /* If any of the arguments are dependent expressions, we can't evaluate
1102 the attribute until instantiation time. */
1103 for (arg = args; arg; arg = TREE_CHAIN (arg))
1105 tree t = TREE_VALUE (arg);
1107 /* If the first attribute argument is an identifier, only consider
1108 second and following arguments. Attributes like mode, format,
1109 cleanup and several target specific attributes aren't late
1110 just because they have an IDENTIFIER_NODE as first argument. */
1111 if (arg == args && TREE_CODE (t) == IDENTIFIER_NODE)
1114 if (value_dependent_expression_p (t)
1115 || type_dependent_expression_p (t))
1119 if (TREE_CODE (decl) == TYPE_DECL
1121 || spec->type_required)
1123 tree type = TYPE_P (decl) ? decl : TREE_TYPE (decl);
1125 /* We can't apply any attributes to a completely unknown type until
1126 instantiation time. */
1127 enum tree_code code = TREE_CODE (type);
1128 if (code == TEMPLATE_TYPE_PARM
1129 || code == BOUND_TEMPLATE_TEMPLATE_PARM
1130 || code == TYPENAME_TYPE)
1132 /* Also defer most attributes on dependent types. This is not
1133 necessary in all cases, but is the better default. */
1134 else if (dependent_type_p (type)
1135 /* But attribute visibility specifically works on
1137 && !is_attribute_p ("visibility", name))
1146 /* ATTR_P is a list of attributes. Remove any attributes which need to be
1147 applied at instantiation time and return them. If IS_DEPENDENT is true,
1148 the declaration itself is dependent, so all attributes should be applied
1149 at instantiation time. */
1152 splice_template_attributes (tree *attr_p, tree decl)
1155 tree late_attrs = NULL_TREE;
1156 tree *q = &late_attrs;
1163 if (is_late_template_attribute (*p, decl))
1165 ATTR_IS_DEPENDENT (*p) = 1;
1167 *p = TREE_CHAIN (*p);
1168 q = &TREE_CHAIN (*q);
1172 p = &TREE_CHAIN (*p);
1178 /* Remove any late attributes from the list in ATTR_P and attach them to
1182 save_template_attributes (tree *attr_p, tree *decl_p)
1184 tree late_attrs = splice_template_attributes (attr_p, *decl_p);
1186 tree old_attrs = NULL_TREE;
1191 if (DECL_P (*decl_p))
1192 q = &DECL_ATTRIBUTES (*decl_p);
1194 q = &TYPE_ATTRIBUTES (*decl_p);
1198 /* Place the late attributes at the beginning of the attribute
1200 TREE_CHAIN (tree_last (late_attrs)) = *q;
1203 if (!DECL_P (*decl_p) && *decl_p == TYPE_MAIN_VARIANT (*decl_p))
1205 /* We've added new attributes directly to the main variant, so
1206 now we need to update all of the other variants to include
1207 these new attributes. */
1209 for (variant = TYPE_NEXT_VARIANT (*decl_p); variant;
1210 variant = TYPE_NEXT_VARIANT (variant))
1212 gcc_assert (TYPE_ATTRIBUTES (variant) == old_attrs);
1213 TYPE_ATTRIBUTES (variant) = TYPE_ATTRIBUTES (*decl_p);
1218 /* Like reconstruct_complex_type, but handle also template trees. */
1221 cp_reconstruct_complex_type (tree type, tree bottom)
1225 if (TREE_CODE (type) == POINTER_TYPE)
1227 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1228 outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
1229 TYPE_REF_CAN_ALIAS_ALL (type));
1231 else if (TREE_CODE (type) == REFERENCE_TYPE)
1233 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1234 outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
1235 TYPE_REF_CAN_ALIAS_ALL (type));
1237 else if (TREE_CODE (type) == ARRAY_TYPE)
1239 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1240 outer = build_cplus_array_type (inner, TYPE_DOMAIN (type));
1241 /* Don't call cp_build_qualified_type on ARRAY_TYPEs, the
1242 element type qualification will be handled by the recursive
1243 cp_reconstruct_complex_type call and cp_build_qualified_type
1244 for ARRAY_TYPEs changes the element type. */
1247 else if (TREE_CODE (type) == FUNCTION_TYPE)
1249 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1250 outer = build_function_type (inner, TYPE_ARG_TYPES (type));
1251 outer = apply_memfn_quals (outer, type_memfn_quals (type));
1253 else if (TREE_CODE (type) == METHOD_TYPE)
1255 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1256 /* The build_method_type_directly() routine prepends 'this' to argument list,
1257 so we must compensate by getting rid of it. */
1259 = build_method_type_directly
1260 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
1262 TREE_CHAIN (TYPE_ARG_TYPES (type)));
1264 else if (TREE_CODE (type) == OFFSET_TYPE)
1266 inner = cp_reconstruct_complex_type (TREE_TYPE (type), bottom);
1267 outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
1272 if (TYPE_ATTRIBUTES (type))
1273 outer = cp_build_type_attribute_variant (outer, TYPE_ATTRIBUTES (type));
1274 return cp_build_qualified_type (outer, cp_type_quals (type));
1277 /* Like decl_attributes, but handle C++ complexity. */
1280 cplus_decl_attributes (tree *decl, tree attributes, int flags)
1282 if (*decl == NULL_TREE || *decl == void_type_node
1283 || *decl == error_mark_node
1284 || attributes == NULL_TREE)
1287 if (processing_template_decl)
1289 if (check_for_bare_parameter_packs (attributes))
1292 save_template_attributes (&attributes, decl);
1293 if (attributes == NULL_TREE)
1297 if (TREE_CODE (*decl) == TEMPLATE_DECL)
1298 decl = &DECL_TEMPLATE_RESULT (*decl);
1300 decl_attributes (decl, attributes, flags);
1302 if (TREE_CODE (*decl) == TYPE_DECL)
1303 SET_IDENTIFIER_TYPE_VALUE (DECL_NAME (*decl), TREE_TYPE (*decl));
1306 /* Walks through the namespace- or function-scope anonymous union
1307 OBJECT, with the indicated TYPE, building appropriate VAR_DECLs.
1308 Returns one of the fields for use in the mangled name. */
1311 build_anon_union_vars (tree type, tree object)
1313 tree main_decl = NULL_TREE;
1316 /* Rather than write the code to handle the non-union case,
1317 just give an error. */
1318 if (TREE_CODE (type) != UNION_TYPE)
1319 error ("anonymous struct not inside named type");
1321 for (field = TYPE_FIELDS (type);
1323 field = TREE_CHAIN (field))
1328 if (DECL_ARTIFICIAL (field))
1330 if (TREE_CODE (field) != FIELD_DECL)
1332 permerror (input_location, "%q+#D invalid; an anonymous union can only "
1333 "have non-static data members", field);
1337 if (TREE_PRIVATE (field))
1338 permerror (input_location, "private member %q+#D in anonymous union", field);
1339 else if (TREE_PROTECTED (field))
1340 permerror (input_location, "protected member %q+#D in anonymous union", field);
1342 if (processing_template_decl)
1343 ref = build_min_nt (COMPONENT_REF, object,
1344 DECL_NAME (field), NULL_TREE);
1346 ref = build_class_member_access_expr (object, field, NULL_TREE,
1347 false, tf_warning_or_error);
1349 if (DECL_NAME (field))
1353 decl = build_decl (input_location,
1354 VAR_DECL, DECL_NAME (field), TREE_TYPE (field));
1355 DECL_ANON_UNION_VAR_P (decl) = 1;
1356 DECL_ARTIFICIAL (decl) = 1;
1358 base = get_base_address (object);
1359 TREE_PUBLIC (decl) = TREE_PUBLIC (base);
1360 TREE_STATIC (decl) = TREE_STATIC (base);
1361 DECL_EXTERNAL (decl) = DECL_EXTERNAL (base);
1363 SET_DECL_VALUE_EXPR (decl, ref);
1364 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1366 decl = pushdecl (decl);
1368 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
1369 decl = build_anon_union_vars (TREE_TYPE (field), ref);
1373 if (main_decl == NULL_TREE)
1380 /* Finish off the processing of a UNION_TYPE structure. If the union is an
1381 anonymous union, then all members must be laid out together. PUBLIC_P
1382 is nonzero if this union is not declared static. */
1385 finish_anon_union (tree anon_union_decl)
1391 if (anon_union_decl == error_mark_node)
1394 type = TREE_TYPE (anon_union_decl);
1395 public_p = TREE_PUBLIC (anon_union_decl);
1397 /* The VAR_DECL's context is the same as the TYPE's context. */
1398 DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
1400 if (TYPE_FIELDS (type) == NULL_TREE)
1405 error ("namespace-scope anonymous aggregates must be static");
1409 main_decl = build_anon_union_vars (type, anon_union_decl);
1410 if (main_decl == error_mark_node)
1412 if (main_decl == NULL_TREE)
1414 warning (0, "anonymous union with no members");
1418 if (!processing_template_decl)
1420 /* Use main_decl to set the mangled name. */
1421 DECL_NAME (anon_union_decl) = DECL_NAME (main_decl);
1422 maybe_commonize_var (anon_union_decl);
1423 mangle_decl (anon_union_decl);
1424 DECL_NAME (anon_union_decl) = NULL_TREE;
1427 pushdecl (anon_union_decl);
1428 if (building_stmt_tree ()
1429 && at_function_scope_p ())
1430 add_decl_expr (anon_union_decl);
1431 else if (!processing_template_decl)
1432 rest_of_decl_compilation (anon_union_decl,
1433 toplevel_bindings_p (), at_eof);
1436 /* Auxiliary functions to make type signatures for
1437 `operator new' and `operator delete' correspond to
1438 what compiler will be expecting. */
1441 coerce_new_type (tree type)
1444 tree args = TYPE_ARG_TYPES (type);
1446 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1448 if (!same_type_p (TREE_TYPE (type), ptr_type_node))
1451 error ("%<operator new%> must return type %qT", ptr_type_node);
1454 if (args && args != void_list_node)
1456 if (TREE_PURPOSE (args))
1458 /* [basic.stc.dynamic.allocation]
1460 The first parameter shall not have an associated default
1462 error ("the first parameter of %<operator new%> cannot "
1463 "have a default argument");
1464 /* Throw away the default argument. */
1465 TREE_PURPOSE (args) = NULL_TREE;
1468 if (!same_type_p (TREE_VALUE (args), size_type_node))
1471 args = TREE_CHAIN (args);
1478 permerror (input_location, "%<operator new%> takes type %<size_t%> (%qT) "
1479 "as first parameter", size_type_node);
1484 args = tree_cons (NULL_TREE, size_type_node, args);
1487 type = build_exception_variant
1488 (build_function_type (ptr_type_node, args),
1489 TYPE_RAISES_EXCEPTIONS (type));
1497 coerce_delete_type (tree type)
1500 tree args = TYPE_ARG_TYPES (type);
1502 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
1504 if (!same_type_p (TREE_TYPE (type), void_type_node))
1507 error ("%<operator delete%> must return type %qT", void_type_node);
1510 if (!args || args == void_list_node
1511 || !same_type_p (TREE_VALUE (args), ptr_type_node))
1514 if (args && args != void_list_node)
1515 args = TREE_CHAIN (args);
1516 error ("%<operator delete%> takes type %qT as first parameter",
1522 args = tree_cons (NULL_TREE, ptr_type_node, args);
1525 type = build_exception_variant
1526 (build_function_type (void_type_node, args),
1527 TYPE_RAISES_EXCEPTIONS (type));
1535 /* DECL is a VAR_DECL for a vtable: walk through the entries in the vtable
1536 and mark them as needed. */
1539 mark_vtable_entries (tree decl)
1542 unsigned HOST_WIDE_INT idx;
1544 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (DECL_INITIAL (decl)),
1549 STRIP_NOPS (fnaddr);
1551 if (TREE_CODE (fnaddr) != ADDR_EXPR
1552 && TREE_CODE (fnaddr) != FDESC_EXPR)
1553 /* This entry is an offset: a virtual base class offset, a
1554 virtual call offset, an RTTI offset, etc. */
1557 fn = TREE_OPERAND (fnaddr, 0);
1558 TREE_ADDRESSABLE (fn) = 1;
1559 /* When we don't have vcall offsets, we output thunks whenever
1560 we output the vtables that contain them. With vcall offsets,
1561 we know all the thunks we'll need when we emit a virtual
1562 function, so we emit the thunks there instead. */
1563 if (DECL_THUNK_P (fn))
1564 use_thunk (fn, /*emit_p=*/0);
1569 /* Set DECL up to have the closest approximation of "initialized common"
1570 linkage available. */
1573 comdat_linkage (tree decl)
1576 make_decl_one_only (decl, cxx_comdat_group (decl));
1577 else if (TREE_CODE (decl) == FUNCTION_DECL
1578 || (TREE_CODE (decl) == VAR_DECL && DECL_ARTIFICIAL (decl)))
1579 /* We can just emit function and compiler-generated variables
1580 statically; having multiple copies is (for the most part) only
1583 There are two correctness issues, however: the address of a
1584 template instantiation with external linkage should be the
1585 same, independent of what translation unit asks for the
1586 address, and this will not hold when we emit multiple copies of
1587 the function. However, there's little else we can do.
1589 Also, by default, the typeinfo implementation assumes that
1590 there will be only one copy of the string used as the name for
1591 each type. Therefore, if weak symbols are unavailable, the
1592 run-time library should perform a more conservative check; it
1593 should perform a string comparison, rather than an address
1595 TREE_PUBLIC (decl) = 0;
1598 /* Static data member template instantiations, however, cannot
1599 have multiple copies. */
1600 if (DECL_INITIAL (decl) == 0
1601 || DECL_INITIAL (decl) == error_mark_node)
1602 DECL_COMMON (decl) = 1;
1603 else if (EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl)))
1605 DECL_COMMON (decl) = 1;
1606 DECL_INITIAL (decl) = error_mark_node;
1608 else if (!DECL_EXPLICIT_INSTANTIATION (decl))
1610 /* We can't do anything useful; leave vars for explicit
1612 DECL_EXTERNAL (decl) = 1;
1613 DECL_NOT_REALLY_EXTERN (decl) = 0;
1617 DECL_COMDAT (decl) = 1;
1620 /* For win32 we also want to put explicit instantiations in
1621 linkonce sections, so that they will be merged with implicit
1622 instantiations; otherwise we get duplicate symbol errors.
1623 For Darwin we do not want explicit instantiations to be
1627 maybe_make_one_only (tree decl)
1629 /* We used to say that this was not necessary on targets that support weak
1630 symbols, because the implicit instantiations will defer to the explicit
1631 one. However, that's not actually the case in SVR4; a strong definition
1632 after a weak one is an error. Also, not making explicit
1633 instantiations one_only means that we can end up with two copies of
1634 some template instantiations. */
1638 /* We can't set DECL_COMDAT on functions, or cp_finish_file will think
1639 we can get away with not emitting them if they aren't used. We need
1640 to for variables so that cp_finish_decl will update their linkage,
1641 because their DECL_INITIAL may not have been set properly yet. */
1643 if (!TARGET_WEAK_NOT_IN_ARCHIVE_TOC
1644 || (! DECL_EXPLICIT_INSTANTIATION (decl)
1645 && ! DECL_TEMPLATE_SPECIALIZATION (decl)))
1647 make_decl_one_only (decl, cxx_comdat_group (decl));
1649 if (TREE_CODE (decl) == VAR_DECL)
1651 DECL_COMDAT (decl) = 1;
1652 /* Mark it needed so we don't forget to emit it. */
1653 mark_decl_referenced (decl);
1658 /* Returns true iff DECL, a FUNCTION_DECL or VAR_DECL, has vague linkage.
1659 This predicate will give the right answer during parsing of the
1660 function, which other tests may not. */
1663 vague_linkage_p (tree decl)
1665 /* Unfortunately, import_export_decl has not always been called
1666 before the function is processed, so we cannot simply check
1668 return (DECL_COMDAT (decl)
1669 || (((TREE_CODE (decl) == FUNCTION_DECL
1670 && DECL_DECLARED_INLINE_P (decl))
1671 || (DECL_LANG_SPECIFIC (decl)
1672 && DECL_TEMPLATE_INSTANTIATION (decl)))
1673 && TREE_PUBLIC (decl)));
1676 /* Determine whether or not we want to specifically import or export CTYPE,
1677 using various heuristics. */
1680 import_export_class (tree ctype)
1682 /* -1 for imported, 1 for exported. */
1683 int import_export = 0;
1685 /* It only makes sense to call this function at EOF. The reason is
1686 that this function looks at whether or not the first non-inline
1687 non-abstract virtual member function has been defined in this
1688 translation unit. But, we can't possibly know that until we've
1689 seen the entire translation unit. */
1690 gcc_assert (at_eof);
1692 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
1695 /* If MULTIPLE_SYMBOL_SPACES is set and we saw a #pragma interface,
1696 we will have CLASSTYPE_INTERFACE_ONLY set but not
1697 CLASSTYPE_INTERFACE_KNOWN. In that case, we don't want to use this
1698 heuristic because someone will supply a #pragma implementation
1699 elsewhere, and deducing it here would produce a conflict. */
1700 if (CLASSTYPE_INTERFACE_ONLY (ctype))
1703 if (lookup_attribute ("dllimport", TYPE_ATTRIBUTES (ctype)))
1705 else if (lookup_attribute ("dllexport", TYPE_ATTRIBUTES (ctype)))
1707 else if (CLASSTYPE_IMPLICIT_INSTANTIATION (ctype)
1708 && !flag_implicit_templates)
1709 /* For a template class, without -fimplicit-templates, check the
1710 repository. If the virtual table is assigned to this
1711 translation unit, then export the class; otherwise, import
1713 import_export = repo_export_class_p (ctype) ? 1 : -1;
1714 else if (TYPE_POLYMORPHIC_P (ctype))
1716 /* The ABI specifies that the virtual table and associated
1717 information are emitted with the key method, if any. */
1718 tree method = CLASSTYPE_KEY_METHOD (ctype);
1719 /* If weak symbol support is not available, then we must be
1720 careful not to emit the vtable when the key function is
1721 inline. An inline function can be defined in multiple
1722 translation units. If we were to emit the vtable in each
1723 translation unit containing a definition, we would get
1724 multiple definition errors at link-time. */
1725 if (method && (flag_weak || ! DECL_DECLARED_INLINE_P (method)))
1726 import_export = (DECL_REALLY_EXTERN (method) ? -1 : 1);
1729 /* When MULTIPLE_SYMBOL_SPACES is set, we cannot count on seeing
1730 a definition anywhere else. */
1731 if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
1734 /* Allow back ends the chance to overrule the decision. */
1735 if (targetm.cxx.import_export_class)
1736 import_export = targetm.cxx.import_export_class (ctype, import_export);
1740 SET_CLASSTYPE_INTERFACE_KNOWN (ctype);
1741 CLASSTYPE_INTERFACE_ONLY (ctype) = (import_export < 0);
1745 /* Return true if VAR has already been provided to the back end; in that
1746 case VAR should not be modified further by the front end. */
1748 var_finalized_p (tree var)
1750 return varpool_node (var)->finalized;
1753 /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
1754 must be emitted in this translation unit. Mark it as such. */
1757 mark_needed (tree decl)
1759 /* It's possible that we no longer need to set
1760 TREE_SYMBOL_REFERENCED here directly, but doing so is
1762 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) = 1;
1763 mark_decl_referenced (decl);
1766 /* DECL is either a FUNCTION_DECL or a VAR_DECL. This function
1767 returns true if a definition of this entity should be provided in
1768 this object file. Callers use this function to determine whether
1769 or not to let the back end know that a definition of DECL is
1770 available in this translation unit. */
1773 decl_needed_p (tree decl)
1775 gcc_assert (TREE_CODE (decl) == VAR_DECL
1776 || TREE_CODE (decl) == FUNCTION_DECL);
1777 /* This function should only be called at the end of the translation
1778 unit. We cannot be sure of whether or not something will be
1779 COMDAT until that point. */
1780 gcc_assert (at_eof);
1782 /* All entities with external linkage that are not COMDAT should be
1783 emitted; they may be referred to from other object files. */
1784 if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
1786 /* If this entity was used, let the back end see it; it will decide
1787 whether or not to emit it into the object file. */
1788 if (TREE_USED (decl)
1789 || (DECL_ASSEMBLER_NAME_SET_P (decl)
1790 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
1792 /* Functions marked "dllexport" must be emitted so that they are
1793 visible to other DLLs. */
1794 if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
1796 /* Otherwise, DECL does not need to be emitted -- yet. A subsequent
1797 reference to DECL might cause it to be emitted later. */
1801 /* If necessary, write out the vtables for the dynamic class CTYPE.
1802 Returns true if any vtables were emitted. */
1805 maybe_emit_vtables (tree ctype)
1810 struct varpool_node *current = NULL, *last = NULL, *first = NULL;
1812 /* If the vtables for this class have already been emitted there is
1813 nothing more to do. */
1814 primary_vtbl = CLASSTYPE_VTABLES (ctype);
1815 if (var_finalized_p (primary_vtbl))
1817 /* Ignore dummy vtables made by get_vtable_decl. */
1818 if (TREE_TYPE (primary_vtbl) == void_type_node)
1821 /* On some targets, we cannot determine the key method until the end
1822 of the translation unit -- which is when this function is
1824 if (!targetm.cxx.key_method_may_be_inline ())
1825 determine_key_method (ctype);
1827 /* See if any of the vtables are needed. */
1828 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1830 import_export_decl (vtbl);
1831 if (DECL_NOT_REALLY_EXTERN (vtbl) && decl_needed_p (vtbl))
1836 /* If the references to this class' vtables are optimized away,
1837 still emit the appropriate debugging information. See
1839 if (DECL_COMDAT (primary_vtbl)
1840 && CLASSTYPE_DEBUG_REQUESTED (ctype))
1841 note_debug_info_needed (ctype);
1845 /* The ABI requires that we emit all of the vtables if we emit any
1847 for (vtbl = CLASSTYPE_VTABLES (ctype); vtbl; vtbl = TREE_CHAIN (vtbl))
1849 /* Mark entities references from the virtual table as used. */
1850 mark_vtable_entries (vtbl);
1852 if (TREE_TYPE (DECL_INITIAL (vtbl)) == 0)
1854 tree expr = store_init_value (vtbl, DECL_INITIAL (vtbl), LOOKUP_NORMAL);
1856 /* It had better be all done at compile-time. */
1861 DECL_EXTERNAL (vtbl) = 0;
1862 rest_of_decl_compilation (vtbl, 1, 1);
1864 /* Because we're only doing syntax-checking, we'll never end up
1865 actually marking the variable as written. */
1866 if (flag_syntax_only)
1867 TREE_ASM_WRITTEN (vtbl) = 1;
1868 else if (DECL_COMDAT (vtbl))
1870 current = varpool_node (vtbl);
1872 last->same_comdat_group = current;
1880 last->same_comdat_group = first;
1882 /* Since we're writing out the vtable here, also write the debug
1884 note_debug_info_needed (ctype);
1889 /* A special return value from type_visibility meaning internal
1892 enum { VISIBILITY_ANON = VISIBILITY_INTERNAL+1 };
1894 /* walk_tree helper function for type_visibility. */
1897 min_vis_r (tree *tp, int *walk_subtrees, void *data)
1899 int *vis_p = (int *)data;
1904 else if (CLASS_TYPE_P (*tp))
1906 if (!TREE_PUBLIC (TYPE_MAIN_DECL (*tp)))
1908 *vis_p = VISIBILITY_ANON;
1911 else if (CLASSTYPE_VISIBILITY (*tp) > *vis_p)
1912 *vis_p = CLASSTYPE_VISIBILITY (*tp);
1917 /* Returns the visibility of TYPE, which is the minimum visibility of its
1921 type_visibility (tree type)
1923 int vis = VISIBILITY_DEFAULT;
1924 cp_walk_tree_without_duplicates (&type, min_vis_r, &vis);
1928 /* Limit the visibility of DECL to VISIBILITY, if not explicitly
1929 specified (or if VISIBILITY is static). */
1932 constrain_visibility (tree decl, int visibility)
1934 if (visibility == VISIBILITY_ANON)
1936 /* extern "C" declarations aren't affected by the anonymous
1938 if (!DECL_EXTERN_C_P (decl))
1940 TREE_PUBLIC (decl) = 0;
1941 DECL_WEAK (decl) = 0;
1942 DECL_COMMON (decl) = 0;
1943 DECL_COMDAT_GROUP (decl) = NULL_TREE;
1944 DECL_INTERFACE_KNOWN (decl) = 1;
1945 if (DECL_LANG_SPECIFIC (decl))
1946 DECL_NOT_REALLY_EXTERN (decl) = 1;
1949 else if (visibility > DECL_VISIBILITY (decl)
1950 && !DECL_VISIBILITY_SPECIFIED (decl))
1952 DECL_VISIBILITY (decl) = (enum symbol_visibility) visibility;
1958 /* Constrain the visibility of DECL based on the visibility of its template
1962 constrain_visibility_for_template (tree decl, tree targs)
1964 /* If this is a template instantiation, check the innermost
1965 template args for visibility constraints. The outer template
1966 args are covered by the class check. */
1967 tree args = INNERMOST_TEMPLATE_ARGS (targs);
1969 for (i = TREE_VEC_LENGTH (args); i > 0; --i)
1973 tree arg = TREE_VEC_ELT (args, i-1);
1975 vis = type_visibility (arg);
1976 else if (TREE_TYPE (arg) && POINTER_TYPE_P (TREE_TYPE (arg)))
1979 if (TREE_CODE (arg) == ADDR_EXPR)
1980 arg = TREE_OPERAND (arg, 0);
1981 if (TREE_CODE (arg) == VAR_DECL
1982 || TREE_CODE (arg) == FUNCTION_DECL)
1984 if (! TREE_PUBLIC (arg))
1985 vis = VISIBILITY_ANON;
1987 vis = DECL_VISIBILITY (arg);
1991 constrain_visibility (decl, vis);
1995 /* Like c_determine_visibility, but with additional C++-specific
1998 Function-scope entities can rely on the function's visibility because
1999 it is set in start_preparsed_function.
2001 Class-scope entities cannot rely on the class's visibility until the end
2002 of the enclosing class definition.
2004 Note that because namespaces have multiple independent definitions,
2005 namespace visibility is handled elsewhere using the #pragma visibility
2006 machinery rather than by decorating the namespace declaration.
2008 The goal is for constraints from the type to give a diagnostic, and
2009 other constraints to be applied silently. */
2012 determine_visibility (tree decl)
2014 tree class_type = NULL_TREE;
2016 bool orig_visibility_specified;
2017 enum symbol_visibility orig_visibility;
2019 /* Remember that all decls get VISIBILITY_DEFAULT when built. */
2021 /* Only relevant for names with external linkage. */
2022 if (!TREE_PUBLIC (decl))
2025 /* Cloned constructors and destructors get the same visibility as
2026 the underlying function. That should be set up in
2027 maybe_clone_body. */
2028 gcc_assert (!DECL_CLONED_FUNCTION_P (decl));
2030 orig_visibility_specified = DECL_VISIBILITY_SPECIFIED (decl);
2031 orig_visibility = DECL_VISIBILITY (decl);
2033 if (TREE_CODE (decl) == TYPE_DECL)
2035 if (CLASS_TYPE_P (TREE_TYPE (decl)))
2036 use_template = CLASSTYPE_USE_TEMPLATE (TREE_TYPE (decl));
2037 else if (TYPE_TEMPLATE_INFO (TREE_TYPE (decl)))
2042 else if (DECL_LANG_SPECIFIC (decl))
2043 use_template = DECL_USE_TEMPLATE (decl);
2047 /* If DECL is a member of a class, visibility specifiers on the
2048 class can influence the visibility of the DECL. */
2049 if (DECL_CLASS_SCOPE_P (decl))
2050 class_type = DECL_CONTEXT (decl);
2053 /* Not a class member. */
2055 /* Virtual tables have DECL_CONTEXT set to their associated class,
2056 so they are automatically handled above. */
2057 gcc_assert (TREE_CODE (decl) != VAR_DECL
2058 || !DECL_VTABLE_OR_VTT_P (decl));
2060 if (DECL_FUNCTION_SCOPE_P (decl) && ! DECL_VISIBILITY_SPECIFIED (decl))
2062 /* Local statics and classes get the visibility of their
2063 containing function by default, except that
2064 -fvisibility-inlines-hidden doesn't affect them. */
2065 tree fn = DECL_CONTEXT (decl);
2066 if (DECL_VISIBILITY_SPECIFIED (fn) || ! DECL_CLASS_SCOPE_P (fn))
2068 DECL_VISIBILITY (decl) = DECL_VISIBILITY (fn);
2069 DECL_VISIBILITY_SPECIFIED (decl) =
2070 DECL_VISIBILITY_SPECIFIED (fn);
2073 determine_visibility_from_class (decl, DECL_CONTEXT (fn));
2075 /* Local classes in templates have CLASSTYPE_USE_TEMPLATE set,
2076 but have no TEMPLATE_INFO, so don't try to check it. */
2079 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl)
2080 && flag_visibility_ms_compat)
2082 /* Under -fvisibility-ms-compat, types are visible by default,
2083 even though their contents aren't. */
2084 tree underlying_type = TREE_TYPE (DECL_NAME (decl));
2085 int underlying_vis = type_visibility (underlying_type);
2086 if (underlying_vis == VISIBILITY_ANON
2087 || CLASSTYPE_VISIBILITY_SPECIFIED (underlying_type))
2088 constrain_visibility (decl, underlying_vis);
2090 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
2092 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2094 /* tinfo visibility is based on the type it's for. */
2095 constrain_visibility
2096 (decl, type_visibility (TREE_TYPE (DECL_NAME (decl))));
2098 /* Give the target a chance to override the visibility associated
2100 if (TREE_PUBLIC (decl)
2101 && !DECL_REALLY_EXTERN (decl)
2102 && CLASS_TYPE_P (TREE_TYPE (DECL_NAME (decl)))
2103 && !CLASSTYPE_VISIBILITY_SPECIFIED (TREE_TYPE (DECL_NAME (decl))))
2104 targetm.cxx.determine_class_data_visibility (decl);
2106 else if (use_template)
2107 /* Template instantiations and specializations get visibility based
2108 on their template unless they override it with an attribute. */;
2109 else if (! DECL_VISIBILITY_SPECIFIED (decl))
2111 /* Set default visibility to whatever the user supplied with
2112 #pragma GCC visibility or a namespace visibility attribute. */
2113 DECL_VISIBILITY (decl) = default_visibility;
2114 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
2120 /* If the specialization doesn't specify visibility, use the
2121 visibility from the template. */
2122 tree tinfo = (TREE_CODE (decl) == TYPE_DECL
2123 ? TYPE_TEMPLATE_INFO (TREE_TYPE (decl))
2124 : DECL_TEMPLATE_INFO (decl));
2125 tree args = TI_ARGS (tinfo);
2127 if (args != error_mark_node)
2129 int depth = TMPL_ARGS_DEPTH (args);
2130 tree pattern = DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo));
2132 if (!DECL_VISIBILITY_SPECIFIED (decl))
2134 DECL_VISIBILITY (decl) = DECL_VISIBILITY (pattern);
2135 DECL_VISIBILITY_SPECIFIED (decl)
2136 = DECL_VISIBILITY_SPECIFIED (pattern);
2139 /* FIXME should TMPL_ARGS_DEPTH really return 1 for null input? */
2140 if (args && depth > template_class_depth (class_type))
2141 /* Limit visibility based on its template arguments. */
2142 constrain_visibility_for_template (decl, args);
2147 determine_visibility_from_class (decl, class_type);
2149 if (decl_anon_ns_mem_p (decl))
2150 /* Names in an anonymous namespace get internal linkage.
2151 This might change once we implement export. */
2152 constrain_visibility (decl, VISIBILITY_ANON);
2153 else if (TREE_CODE (decl) != TYPE_DECL)
2155 /* Propagate anonymity from type to decl. */
2156 int tvis = type_visibility (TREE_TYPE (decl));
2157 if (tvis == VISIBILITY_ANON
2158 || ! DECL_VISIBILITY_SPECIFIED (decl))
2159 constrain_visibility (decl, tvis);
2161 else if (no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/true))
2162 /* DR 757: A type without linkage shall not be used as the type of a
2163 variable or function with linkage, unless
2164 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
2165 o the variable or function is not used (3.2 [basic.def.odr]) or is
2166 defined in the same translation unit.
2168 Since non-extern "C" decls need to be defined in the same
2169 translation unit, we can make the type internal. */
2170 constrain_visibility (decl, VISIBILITY_ANON);
2172 /* If visibility changed and DECL already has DECL_RTL, ensure
2173 symbol flags are updated. */
2174 if ((DECL_VISIBILITY (decl) != orig_visibility
2175 || DECL_VISIBILITY_SPECIFIED (decl) != orig_visibility_specified)
2176 && ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
2177 || TREE_CODE (decl) == FUNCTION_DECL)
2178 && DECL_RTL_SET_P (decl))
2179 make_decl_rtl (decl);
2182 /* By default, static data members and function members receive
2183 the visibility of their containing class. */
2186 determine_visibility_from_class (tree decl, tree class_type)
2188 if (DECL_VISIBILITY_SPECIFIED (decl))
2191 if (visibility_options.inlines_hidden
2192 /* Don't do this for inline templates; specializations might not be
2193 inline, and we don't want them to inherit the hidden
2194 visibility. We'll set it here for all inline instantiations. */
2195 && !processing_template_decl
2196 && TREE_CODE (decl) == FUNCTION_DECL
2197 && DECL_DECLARED_INLINE_P (decl)
2198 && (! DECL_LANG_SPECIFIC (decl)
2199 || ! DECL_EXPLICIT_INSTANTIATION (decl)))
2200 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
2203 /* Default to the class visibility. */
2204 DECL_VISIBILITY (decl) = CLASSTYPE_VISIBILITY (class_type);
2205 DECL_VISIBILITY_SPECIFIED (decl)
2206 = CLASSTYPE_VISIBILITY_SPECIFIED (class_type);
2209 /* Give the target a chance to override the visibility associated
2211 if (TREE_CODE (decl) == VAR_DECL
2212 && (DECL_TINFO_P (decl)
2213 || (DECL_VTABLE_OR_VTT_P (decl)
2214 /* Construction virtual tables are not exported because
2215 they cannot be referred to from other object files;
2216 their name is not standardized by the ABI. */
2217 && !DECL_CONSTRUCTION_VTABLE_P (decl)))
2218 && TREE_PUBLIC (decl)
2219 && !DECL_REALLY_EXTERN (decl)
2220 && !CLASSTYPE_VISIBILITY_SPECIFIED (class_type))
2221 targetm.cxx.determine_class_data_visibility (decl);
2224 /* Constrain the visibility of a class TYPE based on the visibility of its
2225 field types. Warn if any fields require lesser visibility. */
2228 constrain_class_visibility (tree type)
2234 int vis = type_visibility (type);
2236 if (vis == VISIBILITY_ANON
2237 || DECL_IN_SYSTEM_HEADER (TYPE_MAIN_DECL (type)))
2240 /* Don't warn about visibility if the class has explicit visibility. */
2241 if (CLASSTYPE_VISIBILITY_SPECIFIED (type))
2242 vis = VISIBILITY_INTERNAL;
2244 for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
2245 if (TREE_CODE (t) == FIELD_DECL && TREE_TYPE (t) != error_mark_node)
2247 tree ftype = strip_pointer_or_array_types (TREE_TYPE (t));
2248 int subvis = type_visibility (ftype);
2250 if (subvis == VISIBILITY_ANON)
2252 if (!in_main_input_context ())
2254 %qT has a field %qD whose type uses the anonymous namespace",
2257 else if (MAYBE_CLASS_TYPE_P (ftype)
2258 && vis < VISIBILITY_HIDDEN
2259 && subvis >= VISIBILITY_HIDDEN)
2260 warning (OPT_Wattributes, "\
2261 %qT declared with greater visibility than the type of its field %qD",
2265 binfo = TYPE_BINFO (type);
2266 for (i = 0; BINFO_BASE_ITERATE (binfo, i, t); ++i)
2268 int subvis = type_visibility (TREE_TYPE (t));
2270 if (subvis == VISIBILITY_ANON)
2272 if (!in_main_input_context())
2274 %qT has a base %qT whose type uses the anonymous namespace",
2275 type, TREE_TYPE (t));
2277 else if (vis < VISIBILITY_HIDDEN
2278 && subvis >= VISIBILITY_HIDDEN)
2279 warning (OPT_Wattributes, "\
2280 %qT declared with greater visibility than its base %qT",
2281 type, TREE_TYPE (t));
2285 /* DECL is a FUNCTION_DECL or VAR_DECL. If the object file linkage
2286 for DECL has not already been determined, do so now by setting
2287 DECL_EXTERNAL, DECL_COMDAT and other related flags. Until this
2288 function is called entities with vague linkage whose definitions
2289 are available must have TREE_PUBLIC set.
2291 If this function decides to place DECL in COMDAT, it will set
2292 appropriate flags -- but will not clear DECL_EXTERNAL. It is up to
2293 the caller to decide whether or not to clear DECL_EXTERNAL. Some
2294 callers defer that decision until it is clear that DECL is actually
2298 import_export_decl (tree decl)
2303 tree class_type = NULL_TREE;
2305 if (DECL_INTERFACE_KNOWN (decl))
2308 /* We cannot determine what linkage to give to an entity with vague
2309 linkage until the end of the file. For example, a virtual table
2310 for a class will be defined if and only if the key method is
2311 defined in this translation unit. As a further example, consider
2312 that when compiling a translation unit that uses PCH file with
2313 "-frepo" it would be incorrect to make decisions about what
2314 entities to emit when building the PCH; those decisions must be
2315 delayed until the repository information has been processed. */
2316 gcc_assert (at_eof);
2317 /* Object file linkage for explicit instantiations is handled in
2318 mark_decl_instantiated. For static variables in functions with
2319 vague linkage, maybe_commonize_var is used.
2321 Therefore, the only declarations that should be provided to this
2322 function are those with external linkage that are:
2324 * implicit instantiations of function templates
2328 * implicit instantiations of static data members of class
2335 Furthermore, all entities that reach this point must have a
2336 definition available in this translation unit.
2338 The following assertions check these conditions. */
2339 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
2340 || TREE_CODE (decl) == VAR_DECL);
2341 /* Any code that creates entities with TREE_PUBLIC cleared should
2342 also set DECL_INTERFACE_KNOWN. */
2343 gcc_assert (TREE_PUBLIC (decl));
2344 if (TREE_CODE (decl) == FUNCTION_DECL)
2345 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2346 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
2347 || DECL_DECLARED_INLINE_P (decl));
2349 gcc_assert (DECL_IMPLICIT_INSTANTIATION (decl)
2350 || DECL_VTABLE_OR_VTT_P (decl)
2351 || DECL_TINFO_P (decl));
2352 /* Check that a definition of DECL is available in this translation
2354 gcc_assert (!DECL_REALLY_EXTERN (decl));
2356 /* Assume that DECL will not have COMDAT linkage. */
2358 /* Assume that DECL will not be imported into this translation
2362 /* See if the repository tells us whether or not to emit DECL in
2363 this translation unit. */
2364 emit_p = repo_emit_p (decl);
2367 else if (emit_p == 1)
2369 /* The repository indicates that this entity should be defined
2370 here. Make sure the back end honors that request. */
2371 if (TREE_CODE (decl) == VAR_DECL)
2373 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
2374 || DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl))
2377 FOR_EACH_CLONE (clone, decl)
2378 mark_needed (clone);
2382 /* Output the definition as an ordinary strong definition. */
2383 DECL_EXTERNAL (decl) = 0;
2384 DECL_INTERFACE_KNOWN (decl) = 1;
2389 /* We have already decided what to do with this DECL; there is no
2390 need to check anything further. */
2392 else if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
2394 class_type = DECL_CONTEXT (decl);
2395 import_export_class (class_type);
2396 if (TYPE_FOR_JAVA (class_type))
2398 else if (CLASSTYPE_INTERFACE_KNOWN (class_type)
2399 && CLASSTYPE_INTERFACE_ONLY (class_type))
2401 else if ((!flag_weak || TARGET_WEAK_NOT_IN_ARCHIVE_TOC)
2402 && !CLASSTYPE_USE_TEMPLATE (class_type)
2403 && CLASSTYPE_KEY_METHOD (class_type)
2404 && !DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type)))
2405 /* The ABI requires that all virtual tables be emitted with
2406 COMDAT linkage. However, on systems where COMDAT symbols
2407 don't show up in the table of contents for a static
2408 archive, or on systems without weak symbols (where we
2409 approximate COMDAT linkage by using internal linkage), the
2410 linker will report errors about undefined symbols because
2411 it will not see the virtual table definition. Therefore,
2412 in the case that we know that the virtual table will be
2413 emitted in only one translation unit, we make the virtual
2414 table an ordinary definition with external linkage. */
2415 DECL_EXTERNAL (decl) = 0;
2416 else if (CLASSTYPE_INTERFACE_KNOWN (class_type))
2418 /* CLASS_TYPE is being exported from this translation unit,
2419 so DECL should be defined here. */
2420 if (!flag_weak && CLASSTYPE_EXPLICIT_INSTANTIATION (class_type))
2421 /* If a class is declared in a header with the "extern
2422 template" extension, then it will not be instantiated,
2423 even in translation units that would normally require
2424 it. Often such classes are explicitly instantiated in
2425 one translation unit. Therefore, the explicit
2426 instantiation must be made visible to other translation
2428 DECL_EXTERNAL (decl) = 0;
2431 /* The generic C++ ABI says that class data is always
2432 COMDAT, even if there is a key function. Some
2433 variants (e.g., the ARM EABI) says that class data
2434 only has COMDAT linkage if the class data might be
2435 emitted in more than one translation unit. When the
2436 key method can be inline and is inline, we still have
2437 to arrange for comdat even though
2438 class_data_always_comdat is false. */
2439 if (!CLASSTYPE_KEY_METHOD (class_type)
2440 || DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (class_type))
2441 || targetm.cxx.class_data_always_comdat ())
2443 /* The ABI requires COMDAT linkage. Normally, we
2444 only emit COMDAT things when they are needed;
2445 make sure that we realize that this entity is
2452 else if (!flag_implicit_templates
2453 && CLASSTYPE_IMPLICIT_INSTANTIATION (class_type))
2458 else if (TREE_CODE (decl) == VAR_DECL && DECL_TINFO_P (decl))
2460 tree type = TREE_TYPE (DECL_NAME (decl));
2461 if (CLASS_TYPE_P (type))
2464 import_export_class (type);
2465 if (CLASSTYPE_INTERFACE_KNOWN (type)
2466 && TYPE_POLYMORPHIC_P (type)
2467 && CLASSTYPE_INTERFACE_ONLY (type)
2468 /* If -fno-rtti was specified, then we cannot be sure
2469 that RTTI information will be emitted with the
2470 virtual table of the class, so we must emit it
2471 wherever it is used. */
2476 if (CLASSTYPE_INTERFACE_KNOWN (type)
2477 && !CLASSTYPE_INTERFACE_ONLY (type))
2479 comdat_p = (targetm.cxx.class_data_always_comdat ()
2480 || (CLASSTYPE_KEY_METHOD (type)
2481 && DECL_DECLARED_INLINE_P (CLASSTYPE_KEY_METHOD (type))));
2486 DECL_EXTERNAL (decl) = 0;
2496 else if (DECL_TEMPLATE_INSTANTIATION (decl)
2497 || DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl))
2499 /* DECL is an implicit instantiation of a function or static
2501 if ((flag_implicit_templates
2502 && !flag_use_repository)
2503 || (flag_implicit_inline_templates
2504 && TREE_CODE (decl) == FUNCTION_DECL
2505 && DECL_DECLARED_INLINE_P (decl)))
2508 /* If we are not implicitly generating templates, then mark
2509 this entity as undefined in this translation unit. */
2512 else if (DECL_FUNCTION_MEMBER_P (decl))
2514 if (!DECL_DECLARED_INLINE_P (decl))
2516 tree ctype = DECL_CONTEXT (decl);
2517 import_export_class (ctype);
2518 if (CLASSTYPE_INTERFACE_KNOWN (ctype))
2520 DECL_NOT_REALLY_EXTERN (decl)
2521 = ! (CLASSTYPE_INTERFACE_ONLY (ctype)
2522 || (DECL_DECLARED_INLINE_P (decl)
2523 && ! flag_implement_inlines
2524 && !DECL_VINDEX (decl)));
2526 if (!DECL_NOT_REALLY_EXTERN (decl))
2527 DECL_EXTERNAL (decl) = 1;
2529 /* Always make artificials weak. */
2530 if (DECL_ARTIFICIAL (decl) && flag_weak)
2533 maybe_make_one_only (decl);
2544 /* If we are importing DECL into this translation unit, mark is
2545 an undefined here. */
2546 DECL_EXTERNAL (decl) = 1;
2547 DECL_NOT_REALLY_EXTERN (decl) = 0;
2551 /* If we decided to put DECL in COMDAT, mark it accordingly at
2553 comdat_linkage (decl);
2556 DECL_INTERFACE_KNOWN (decl) = 1;
2559 /* Return an expression that performs the destruction of DECL, which
2560 must be a VAR_DECL whose type has a non-trivial destructor, or is
2561 an array whose (innermost) elements have a non-trivial destructor. */
2564 build_cleanup (tree decl)
2567 tree type = TREE_TYPE (decl);
2569 /* This function should only be called for declarations that really
2570 require cleanups. */
2571 gcc_assert (!TYPE_HAS_TRIVIAL_DESTRUCTOR (type));
2573 /* Treat all objects with destructors as used; the destructor may do
2574 something substantive. */
2577 if (TREE_CODE (type) == ARRAY_TYPE)
2580 temp = build_address (decl);
2581 temp = build_delete (TREE_TYPE (temp), temp,
2582 sfk_complete_destructor,
2583 LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
2587 /* Returns the initialization guard variable for the variable DECL,
2588 which has static storage duration. */
2591 get_guard (tree decl)
2596 sname = mangle_guard_variable (decl);
2597 guard = IDENTIFIER_GLOBAL_VALUE (sname);
2602 /* We use a type that is big enough to contain a mutex as well
2603 as an integer counter. */
2604 guard_type = targetm.cxx.guard_type ();
2605 guard = build_decl (DECL_SOURCE_LOCATION (decl),
2606 VAR_DECL, sname, guard_type);
2608 /* The guard should have the same linkage as what it guards. */
2609 TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
2610 TREE_STATIC (guard) = TREE_STATIC (decl);
2611 DECL_COMMON (guard) = DECL_COMMON (decl);
2612 DECL_COMDAT (guard) = DECL_COMDAT (decl);
2613 if (DECL_ONE_ONLY (decl))
2614 make_decl_one_only (guard, cxx_comdat_group (guard));
2615 if (TREE_PUBLIC (decl))
2616 DECL_WEAK (guard) = DECL_WEAK (decl);
2617 DECL_VISIBILITY (guard) = DECL_VISIBILITY (decl);
2618 DECL_VISIBILITY_SPECIFIED (guard) = DECL_VISIBILITY_SPECIFIED (decl);
2620 DECL_ARTIFICIAL (guard) = 1;
2621 DECL_IGNORED_P (guard) = 1;
2622 TREE_USED (guard) = 1;
2623 pushdecl_top_level_and_finish (guard, NULL_TREE);
2628 /* Return those bits of the GUARD variable that should be set when the
2629 guarded entity is actually initialized. */
2632 get_guard_bits (tree guard)
2634 if (!targetm.cxx.guard_mask_bit ())
2636 /* We only set the first byte of the guard, in order to leave room
2637 for a mutex in the high-order bits. */
2638 guard = build1 (ADDR_EXPR,
2639 build_pointer_type (TREE_TYPE (guard)),
2641 guard = build1 (NOP_EXPR,
2642 build_pointer_type (char_type_node),
2644 guard = build1 (INDIRECT_REF, char_type_node, guard);
2650 /* Return an expression which determines whether or not the GUARD
2651 variable has already been initialized. */
2654 get_guard_cond (tree guard)
2658 /* Check to see if the GUARD is zero. */
2659 guard = get_guard_bits (guard);
2661 /* Mask off all but the low bit. */
2662 if (targetm.cxx.guard_mask_bit ())
2664 guard_value = integer_one_node;
2665 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2666 guard_value = convert (TREE_TYPE (guard), guard_value);
2667 guard = cp_build_binary_op (input_location,
2668 BIT_AND_EXPR, guard, guard_value,
2669 tf_warning_or_error);
2672 guard_value = integer_zero_node;
2673 if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
2674 guard_value = convert (TREE_TYPE (guard), guard_value);
2675 return cp_build_binary_op (input_location,
2676 EQ_EXPR, guard, guard_value,
2677 tf_warning_or_error);
2680 /* Return an expression which sets the GUARD variable, indicating that
2681 the variable being guarded has been initialized. */
2684 set_guard (tree guard)
2688 /* Set the GUARD to one. */
2689 guard = get_guard_bits (guard);
2690 guard_init = integer_one_node;
2691 if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
2692 guard_init = convert (TREE_TYPE (guard), guard_init);
2693 return cp_build_modify_expr (guard, NOP_EXPR, guard_init,
2694 tf_warning_or_error);
2697 /* Start the process of running a particular set of global constructors
2698 or destructors. Subroutine of do_[cd]tors. */
2701 start_objects (int method_type, int initp)
2707 /* Make ctor or dtor function. METHOD_TYPE may be 'I' or 'D'. */
2709 if (initp != DEFAULT_INIT_PRIORITY)
2719 sprintf (type, "%c%c%.5u", method_type, joiner, initp);
2722 sprintf (type, "%c", method_type);
2724 fndecl = build_lang_decl (FUNCTION_DECL,
2725 get_file_function_name (type),
2726 build_function_type (void_type_node,
2728 start_preparsed_function (fndecl, /*attrs=*/NULL_TREE, SF_PRE_PARSED);
2730 TREE_PUBLIC (current_function_decl) = 0;
2732 /* Mark as artificial because it's not explicitly in the user's
2734 DECL_ARTIFICIAL (current_function_decl) = 1;
2736 /* Mark this declaration as used to avoid spurious warnings. */
2737 TREE_USED (current_function_decl) = 1;
2739 /* Mark this function as a global constructor or destructor. */
2740 if (method_type == 'I')
2741 DECL_GLOBAL_CTOR_P (current_function_decl) = 1;
2743 DECL_GLOBAL_DTOR_P (current_function_decl) = 1;
2745 body = begin_compound_stmt (BCS_FN_BODY);
2750 /* Finish the process of running a particular set of global constructors
2751 or destructors. Subroutine of do_[cd]tors. */
2754 finish_objects (int method_type, int initp, tree body)
2759 finish_compound_stmt (body);
2760 fn = finish_function (0);
2762 if (method_type == 'I')
2764 DECL_STATIC_CONSTRUCTOR (fn) = 1;
2765 decl_init_priority_insert (fn, initp);
2769 DECL_STATIC_DESTRUCTOR (fn) = 1;
2770 decl_fini_priority_insert (fn, initp);
2773 expand_or_defer_fn (fn);
2776 /* The names of the parameters to the function created to handle
2777 initializations and destructions for objects with static storage
2779 #define INITIALIZE_P_IDENTIFIER "__initialize_p"
2780 #define PRIORITY_IDENTIFIER "__priority"
2782 /* The name of the function we create to handle initializations and
2783 destructions for objects with static storage duration. */
2784 #define SSDF_IDENTIFIER "__static_initialization_and_destruction"
2786 /* The declaration for the __INITIALIZE_P argument. */
2787 static GTY(()) tree initialize_p_decl;
2789 /* The declaration for the __PRIORITY argument. */
2790 static GTY(()) tree priority_decl;
2792 /* The declaration for the static storage duration function. */
2793 static GTY(()) tree ssdf_decl;
2795 /* All the static storage duration functions created in this
2796 translation unit. */
2797 static GTY(()) VEC(tree,gc) *ssdf_decls;
2799 /* A map from priority levels to information about that priority
2800 level. There may be many such levels, so efficient lookup is
2802 static splay_tree priority_info_map;
2804 /* Begins the generation of the function that will handle all
2805 initialization and destruction of objects with static storage
2806 duration. The function generated takes two parameters of type
2807 `int': __INITIALIZE_P and __PRIORITY. If __INITIALIZE_P is
2808 nonzero, it performs initializations. Otherwise, it performs
2809 destructions. It only performs those initializations or
2810 destructions with the indicated __PRIORITY. The generated function
2813 It is assumed that this function will only be called once per
2814 translation unit. */
2817 start_static_storage_duration_function (unsigned count)
2822 char id[sizeof (SSDF_IDENTIFIER) + 1 /* '\0' */ + 32];
2824 /* Create the identifier for this function. It will be of the form
2825 SSDF_IDENTIFIER_<number>. */
2826 sprintf (id, "%s_%u", SSDF_IDENTIFIER, count);
2828 /* Create the parameters. */
2829 parm_types = void_list_node;
2830 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2831 parm_types = tree_cons (NULL_TREE, integer_type_node, parm_types);
2832 type = build_function_type (void_type_node, parm_types);
2834 /* Create the FUNCTION_DECL itself. */
2835 ssdf_decl = build_lang_decl (FUNCTION_DECL,
2836 get_identifier (id),
2838 TREE_PUBLIC (ssdf_decl) = 0;
2839 DECL_ARTIFICIAL (ssdf_decl) = 1;
2841 /* Put this function in the list of functions to be called from the
2842 static constructors and destructors. */
2845 ssdf_decls = VEC_alloc (tree, gc, 32);
2847 /* Take this opportunity to initialize the map from priority
2848 numbers to information about that priority level. */
2849 priority_info_map = splay_tree_new (splay_tree_compare_ints,
2850 /*delete_key_fn=*/0,
2851 /*delete_value_fn=*/
2852 (splay_tree_delete_value_fn) &free);
2854 /* We always need to generate functions for the
2855 DEFAULT_INIT_PRIORITY so enter it now. That way when we walk
2856 priorities later, we'll be sure to find the
2857 DEFAULT_INIT_PRIORITY. */
2858 get_priority_info (DEFAULT_INIT_PRIORITY);
2861 VEC_safe_push (tree, gc, ssdf_decls, ssdf_decl);
2863 /* Create the argument list. */
2864 initialize_p_decl = cp_build_parm_decl
2865 (get_identifier (INITIALIZE_P_IDENTIFIER), integer_type_node);
2866 DECL_CONTEXT (initialize_p_decl) = ssdf_decl;
2867 TREE_USED (initialize_p_decl) = 1;
2868 priority_decl = cp_build_parm_decl
2869 (get_identifier (PRIORITY_IDENTIFIER), integer_type_node);
2870 DECL_CONTEXT (priority_decl) = ssdf_decl;
2871 TREE_USED (priority_decl) = 1;
2873 TREE_CHAIN (initialize_p_decl) = priority_decl;
2874 DECL_ARGUMENTS (ssdf_decl) = initialize_p_decl;
2876 /* Put the function in the global scope. */
2877 pushdecl (ssdf_decl);
2879 /* Start the function itself. This is equivalent to declaring the
2882 static void __ssdf (int __initialize_p, init __priority_p);
2884 It is static because we only need to call this function from the
2885 various constructor and destructor functions for this module. */
2886 start_preparsed_function (ssdf_decl,
2887 /*attrs=*/NULL_TREE,
2890 /* Set up the scope of the outermost block in the function. */
2891 body = begin_compound_stmt (BCS_FN_BODY);
2896 /* Finish the generation of the function which performs initialization
2897 and destruction of objects with static storage duration. After
2898 this point, no more such objects can be created. */
2901 finish_static_storage_duration_function (tree body)
2903 /* Close out the function. */
2904 finish_compound_stmt (body);
2905 expand_or_defer_fn (finish_function (0));
2908 /* Return the information about the indicated PRIORITY level. If no
2909 code to handle this level has yet been generated, generate the
2910 appropriate prologue. */
2912 static priority_info
2913 get_priority_info (int priority)
2918 n = splay_tree_lookup (priority_info_map,
2919 (splay_tree_key) priority);
2922 /* Create a new priority information structure, and insert it
2924 pi = XNEW (struct priority_info_s);
2925 pi->initializations_p = 0;
2926 pi->destructions_p = 0;
2927 splay_tree_insert (priority_info_map,
2928 (splay_tree_key) priority,
2929 (splay_tree_value) pi);
2932 pi = (priority_info) n->value;
2937 /* The effective initialization priority of a DECL. */
2939 #define DECL_EFFECTIVE_INIT_PRIORITY(decl) \
2940 ((!DECL_HAS_INIT_PRIORITY_P (decl) || DECL_INIT_PRIORITY (decl) == 0) \
2941 ? DEFAULT_INIT_PRIORITY : DECL_INIT_PRIORITY (decl))
2943 /* Whether a DECL needs a guard to protect it against multiple
2946 #define NEEDS_GUARD_P(decl) (TREE_PUBLIC (decl) && (DECL_COMMON (decl) \
2947 || DECL_ONE_ONLY (decl) \
2948 || DECL_WEAK (decl)))
2950 /* Called from one_static_initialization_or_destruction(),
2952 Walks the initializer list of a global variable and looks for
2953 temporary variables (DECL_NAME() == NULL and DECL_ARTIFICIAL != 0)
2954 and that have their DECL_CONTEXT() == NULL.
2955 For each such temporary variable, set their DECL_CONTEXT() to
2956 the current function. This is necessary because otherwise
2957 some optimizers (enabled by -O2 -fprofile-arcs) might crash
2958 when trying to refer to a temporary variable that does not have
2959 it's DECL_CONTECT() properly set. */
2961 fix_temporary_vars_context_r (tree *node,
2962 int *unused ATTRIBUTE_UNUSED,
2963 void *unused1 ATTRIBUTE_UNUSED)
2965 gcc_assert (current_function_decl);
2967 if (TREE_CODE (*node) == BIND_EXPR)
2971 for (var = BIND_EXPR_VARS (*node); var; var = TREE_CHAIN (var))
2972 if (TREE_CODE (var) == VAR_DECL
2974 && DECL_ARTIFICIAL (var)
2975 && !DECL_CONTEXT (var))
2976 DECL_CONTEXT (var) = current_function_decl;
2982 /* Set up to handle the initialization or destruction of DECL. If
2983 INITP is nonzero, we are initializing the variable. Otherwise, we
2984 are destroying it. */
2987 one_static_initialization_or_destruction (tree decl, tree init, bool initp)
2989 tree guard_if_stmt = NULL_TREE;
2992 /* If we are supposed to destruct and there's a trivial destructor,
2993 nothing has to be done. */
2995 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2998 /* Trick the compiler into thinking we are at the file and line
2999 where DECL was declared so that error-messages make sense, and so
3000 that the debugger will show somewhat sensible file and line
3002 input_location = DECL_SOURCE_LOCATION (decl);
3004 /* Make sure temporary variables in the initialiser all have
3005 their DECL_CONTEXT() set to a value different from NULL_TREE.
3006 This can happen when global variables initialisers are built.
3007 In that case, the DECL_CONTEXT() of the global variables _AND_ of all
3008 the temporary variables that might have been generated in the
3009 accompagning initialisers is NULL_TREE, meaning the variables have been
3010 declared in the global namespace.
3011 What we want to do here is to fix that and make sure the DECL_CONTEXT()
3012 of the temporaries are set to the current function decl. */
3013 cp_walk_tree_without_duplicates (&init,
3014 fix_temporary_vars_context_r,
3021 Access control for implicit calls to the constructors,
3022 the conversion functions, or the destructor called to
3023 create and destroy a static data member is performed as
3024 if these calls appeared in the scope of the member's
3027 we pretend we are in a static member function of the class of
3028 which the DECL is a member. */
3029 if (member_p (decl))
3031 DECL_CONTEXT (current_function_decl) = DECL_CONTEXT (decl);
3032 DECL_STATIC_FUNCTION_P (current_function_decl) = 1;
3035 /* Assume we don't need a guard. */
3037 /* We need a guard if this is an object with external linkage that
3038 might be initialized in more than one place. (For example, a
3039 static data member of a template, when the data member requires
3041 if (NEEDS_GUARD_P (decl))
3045 guard = get_guard (decl);
3047 /* When using __cxa_atexit, we just check the GUARD as we would
3048 for a local static. */
3049 if (flag_use_cxa_atexit)
3051 /* When using __cxa_atexit, we never try to destroy
3052 anything from a static destructor. */
3054 guard_cond = get_guard_cond (guard);
3056 /* If we don't have __cxa_atexit, then we will be running
3057 destructors from .fini sections, or their equivalents. So,
3058 we need to know how many times we've tried to initialize this
3059 object. We do initializations only if the GUARD is zero,
3060 i.e., if we are the first to initialize the variable. We do
3061 destructions only if the GUARD is one, i.e., if we are the
3062 last to destroy the variable. */
3065 = cp_build_binary_op (input_location,
3067 cp_build_unary_op (PREINCREMENT_EXPR,
3070 tf_warning_or_error),
3072 tf_warning_or_error);
3075 = cp_build_binary_op (input_location,
3077 cp_build_unary_op (PREDECREMENT_EXPR,
3080 tf_warning_or_error),
3082 tf_warning_or_error);
3084 guard_if_stmt = begin_if_stmt ();
3085 finish_if_stmt_cond (guard_cond, guard_if_stmt);
3089 /* If we're using __cxa_atexit, we have not already set the GUARD,
3090 so we must do so now. */
3091 if (guard && initp && flag_use_cxa_atexit)
3092 finish_expr_stmt (set_guard (guard));
3094 /* Perform the initialization or destruction. */
3098 finish_expr_stmt (init);
3100 /* If we're using __cxa_atexit, register a function that calls the
3101 destructor for the object. */
3102 if (flag_use_cxa_atexit)
3103 finish_expr_stmt (register_dtor_fn (decl));
3106 finish_expr_stmt (build_cleanup (decl));
3108 /* Finish the guard if-stmt, if necessary. */
3111 finish_then_clause (guard_if_stmt);
3112 finish_if_stmt (guard_if_stmt);
3115 /* Now that we're done with DECL we don't need to pretend to be a
3116 member of its class any longer. */
3117 DECL_CONTEXT (current_function_decl) = NULL_TREE;
3118 DECL_STATIC_FUNCTION_P (current_function_decl) = 0;
3121 /* Generate code to do the initialization or destruction of the decls in VARS,
3122 a TREE_LIST of VAR_DECL with static storage duration.
3123 Whether initialization or destruction is performed is specified by INITP. */
3126 do_static_initialization_or_destruction (tree vars, bool initp)
3128 tree node, init_if_stmt, cond;
3130 /* Build the outer if-stmt to check for initialization or destruction. */
3131 init_if_stmt = begin_if_stmt ();
3132 cond = initp ? integer_one_node : integer_zero_node;
3133 cond = cp_build_binary_op (input_location,
3137 tf_warning_or_error);
3138 finish_if_stmt_cond (cond, init_if_stmt);
3142 tree decl = TREE_VALUE (node);
3143 tree priority_if_stmt;
3147 /* If we don't need a destructor, there's nothing to do. Avoid
3148 creating a possibly empty if-stmt. */
3149 if (!initp && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
3151 node = TREE_CHAIN (node);
3155 /* Remember that we had an initialization or finalization at this
3157 priority = DECL_EFFECTIVE_INIT_PRIORITY (decl);
3158 pi = get_priority_info (priority);
3160 pi->initializations_p = 1;
3162 pi->destructions_p = 1;
3164 /* Conditionalize this initialization on being in the right priority
3165 and being initializing/finalizing appropriately. */
3166 priority_if_stmt = begin_if_stmt ();
3167 cond = cp_build_binary_op (input_location,
3170 build_int_cst (NULL_TREE, priority),
3171 tf_warning_or_error);
3172 finish_if_stmt_cond (cond, priority_if_stmt);
3174 /* Process initializers with same priority. */
3176 && DECL_EFFECTIVE_INIT_PRIORITY (TREE_VALUE (node)) == priority;
3177 node = TREE_CHAIN (node))
3178 /* Do one initialization or destruction. */
3179 one_static_initialization_or_destruction (TREE_VALUE (node),
3180 TREE_PURPOSE (node), initp);
3182 /* Finish up the priority if-stmt body. */
3183 finish_then_clause (priority_if_stmt);
3184 finish_if_stmt (priority_if_stmt);
3188 /* Finish up the init/destruct if-stmt body. */
3189 finish_then_clause (init_if_stmt);
3190 finish_if_stmt (init_if_stmt);
3193 /* VARS is a list of variables with static storage duration which may
3194 need initialization and/or finalization. Remove those variables
3195 that don't really need to be initialized or finalized, and return
3196 the resulting list. The order in which the variables appear in
3197 VARS is in reverse order of the order in which they should actually
3198 be initialized. The list we return is in the unreversed order;
3199 i.e., the first variable should be initialized first. */
3202 prune_vars_needing_no_initialization (tree *vars)
3205 tree result = NULL_TREE;
3210 tree decl = TREE_VALUE (t);
3211 tree init = TREE_PURPOSE (t);
3213 /* Deal gracefully with error. */
3214 if (decl == error_mark_node)
3216 var = &TREE_CHAIN (t);
3220 /* The only things that can be initialized are variables. */
3221 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3223 /* If this object is not defined, we don't need to do anything
3225 if (DECL_EXTERNAL (decl))
3227 var = &TREE_CHAIN (t);
3231 /* Also, if the initializer already contains errors, we can bail
3233 if (init && TREE_CODE (init) == TREE_LIST
3234 && value_member (error_mark_node, init))
3236 var = &TREE_CHAIN (t);
3240 /* This variable is going to need initialization and/or
3241 finalization, so we add it to the list. */
3242 *var = TREE_CHAIN (t);
3243 TREE_CHAIN (t) = result;
3250 /* Make sure we have told the back end about all the variables in
3254 write_out_vars (tree vars)
3258 for (v = vars; v; v = TREE_CHAIN (v))
3260 tree var = TREE_VALUE (v);
3261 if (!var_finalized_p (var))
3263 import_export_decl (var);
3264 rest_of_decl_compilation (var, 1, 1);
3269 /* Generate a static constructor (if CONSTRUCTOR_P) or destructor
3270 (otherwise) that will initialize all global objects with static
3271 storage duration having the indicated PRIORITY. */
3274 generate_ctor_or_dtor_function (bool constructor_p, int priority,
3283 input_location = *locus;
3285 /* Was: locus->line++; */
3287 /* We use `I' to indicate initialization and `D' to indicate
3289 function_key = constructor_p ? 'I' : 'D';
3291 /* We emit the function lazily, to avoid generating empty
3292 global constructors and destructors. */
3295 /* For Objective-C++, we may need to initialize metadata found in this module.
3296 This must be done _before_ any other static initializations. */
3297 if (c_dialect_objc () && (priority == DEFAULT_INIT_PRIORITY)
3298 && constructor_p && objc_static_init_needed_p ())
3300 body = start_objects (function_key, priority);
3301 objc_generate_static_init_call (NULL_TREE);
3304 /* Call the static storage duration function with appropriate
3306 for (i = 0; VEC_iterate (tree, ssdf_decls, i, fndecl); ++i)
3308 /* Calls to pure or const functions will expand to nothing. */
3309 if (! (flags_from_decl_or_type (fndecl) & (ECF_CONST | ECF_PURE)))
3312 body = start_objects (function_key, priority);
3314 arguments = tree_cons (NULL_TREE,
3315 build_int_cst (NULL_TREE, priority),
3317 arguments = tree_cons (NULL_TREE,
3318 build_int_cst (NULL_TREE, constructor_p),
3320 finish_expr_stmt (cp_build_function_call (fndecl, arguments,
3321 tf_warning_or_error));
3325 /* Close out the function. */
3327 finish_objects (function_key, priority, body);
3330 /* Generate constructor and destructor functions for the priority
3334 generate_ctor_and_dtor_functions_for_priority (splay_tree_node n, void * data)
3336 location_t *locus = (location_t *) data;
3337 int priority = (int) n->key;
3338 priority_info pi = (priority_info) n->value;
3340 /* Generate the functions themselves, but only if they are really
3342 if (pi->initializations_p)
3343 generate_ctor_or_dtor_function (/*constructor_p=*/true, priority, locus);
3344 if (pi->destructions_p)
3345 generate_ctor_or_dtor_function (/*constructor_p=*/false, priority, locus);
3347 /* Keep iterating. */
3351 /* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
3352 decls referenced from front-end specific constructs; it will be called
3353 only for language-specific tree nodes.
3355 Here we must deal with member pointers. */
3358 cxx_callgraph_analyze_expr (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED)
3362 switch (TREE_CODE (t))
3365 if (TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
3366 cgraph_mark_address_taken_node (cgraph_node (PTRMEM_CST_MEMBER (t)));
3369 if (TREE_CODE (BASELINK_FUNCTIONS (t)) == FUNCTION_DECL)
3370 cgraph_mark_address_taken_node (cgraph_node (BASELINK_FUNCTIONS (t)));
3373 if (DECL_CONTEXT (t)
3374 && flag_use_repository
3375 && TREE_CODE (DECL_CONTEXT (t)) == FUNCTION_DECL)
3376 /* If we need a static variable in a function, then we
3377 need the containing function. */
3378 mark_decl_referenced (DECL_CONTEXT (t));
3387 /* Java requires that we be able to reference a local address for a
3388 method, and not be confused by PLT entries. If hidden aliases are
3389 supported, collect and return all the functions for which we should
3390 emit a hidden alias. */
3392 static struct pointer_set_t *
3393 collect_candidates_for_java_method_aliases (void)
3395 struct cgraph_node *node;
3396 struct pointer_set_t *candidates = NULL;
3398 #ifndef HAVE_GAS_HIDDEN
3402 for (node = cgraph_nodes; node ; node = node->next)
3404 tree fndecl = node->decl;
3406 if (DECL_CONTEXT (fndecl)
3407 && TYPE_P (DECL_CONTEXT (fndecl))
3408 && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
3409 && TARGET_USE_LOCAL_THUNK_ALIAS_P (fndecl))
3411 if (candidates == NULL)
3412 candidates = pointer_set_create ();
3413 pointer_set_insert (candidates, fndecl);
3421 /* Java requires that we be able to reference a local address for a
3422 method, and not be confused by PLT entries. If hidden aliases are
3423 supported, emit one for each java function that we've emitted.
3424 CANDIDATES is the set of FUNCTION_DECLs that were gathered
3425 by collect_candidates_for_java_method_aliases. */
3428 build_java_method_aliases (struct pointer_set_t *candidates)
3430 struct cgraph_node *node;
3432 #ifndef HAVE_GAS_HIDDEN
3436 for (node = cgraph_nodes; node ; node = node->next)
3438 tree fndecl = node->decl;
3440 if (TREE_ASM_WRITTEN (fndecl)
3441 && pointer_set_contains (candidates, fndecl))
3443 /* Mangle the name in a predictable way; we need to reference
3444 this from a java compiled object file. */
3445 tree oid, nid, alias;
3449 oid = DECL_ASSEMBLER_NAME (fndecl);
3450 oname = IDENTIFIER_POINTER (oid);
3451 gcc_assert (oname[0] == '_' && oname[1] == 'Z');
3452 nname = ACONCAT (("_ZGA", oname+2, NULL));
3453 nid = get_identifier (nname);
3455 alias = make_alias_for (fndecl, nid);
3456 TREE_PUBLIC (alias) = 1;
3457 DECL_VISIBILITY (alias) = VISIBILITY_HIDDEN;
3459 assemble_alias (alias, oid);
3464 /* Returns true iff there is a definition available for variable or
3468 decl_defined_p (tree decl)
3470 if (TREE_CODE (decl) == FUNCTION_DECL)
3471 return (DECL_INITIAL (decl) != NULL_TREE);
3474 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3475 return !DECL_EXTERNAL (decl);
3479 /* Complain that DECL uses a type with no linkage but is never defined. */
3482 no_linkage_error (tree decl)
3484 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
3485 if (TYPE_ANONYMOUS_P (t))
3487 permerror (0, "%q+#D, declared using anonymous type, "
3488 "is used but never defined", decl);
3489 if (is_typedef_decl (TYPE_NAME (t)))
3490 permerror (0, "%q+#D does not refer to the unqualified type, "
3491 "so it is not used for linkage", TYPE_NAME (t));
3494 permerror (0, "%q+#D, declared using local type %qT, "
3495 "is used but never defined", decl, t);
3498 /* This routine is called at the end of compilation.
3499 Its job is to create all the code needed to initialize and
3500 destroy the global aggregates. We do the destruction
3501 first, since that way we only need to reverse the decls once. */
3504 cp_write_global_declarations (void)
3510 unsigned ssdf_count = 0;
3513 struct pointer_set_t *candidates;
3515 locus = input_location;
3518 /* Bad parse errors. Just forget about it. */
3519 if (! global_bindings_p () || current_class_type || decl_namespace_list)
3523 c_common_write_pch ();
3525 /* FIXME - huh? was input_line -= 1;*/
3527 /* We now have to write out all the stuff we put off writing out.
3530 o Template specializations that we have not yet instantiated,
3531 but which are needed.
3532 o Initialization and destruction for non-local objects with
3533 static storage duration. (Local objects with static storage
3534 duration are initialized when their scope is first entered,
3535 and are cleaned up via atexit.)
3536 o Virtual function tables.
3538 All of these may cause others to be needed. For example,
3539 instantiating one function may cause another to be needed, and
3540 generating the initializer for an object may cause templates to be
3541 instantiated, etc., etc. */
3543 timevar_push (TV_VARCONST);
3545 emit_support_tinfos ();
3554 /* If there are templates that we've put off instantiating, do
3556 instantiate_pending_templates (retries);
3559 /* Write out virtual tables as required. Note that writing out
3560 the virtual table for a template class may cause the
3561 instantiation of members of that class. If we write out
3562 vtables then we remove the class from our list so we don't
3563 have to look at it again. */
3565 while (keyed_classes != NULL_TREE
3566 && maybe_emit_vtables (TREE_VALUE (keyed_classes)))
3569 keyed_classes = TREE_CHAIN (keyed_classes);
3575 tree next = TREE_CHAIN (t);
3579 if (maybe_emit_vtables (TREE_VALUE (next)))
3582 TREE_CHAIN (t) = TREE_CHAIN (next);
3587 next = TREE_CHAIN (t);
3591 /* Write out needed type info variables. We have to be careful
3592 looping through unemitted decls, because emit_tinfo_decl may
3593 cause other variables to be needed. New elements will be
3594 appended, and we remove from the vector those that actually
3596 for (i = VEC_length (tree, unemitted_tinfo_decls);
3597 VEC_iterate (tree, unemitted_tinfo_decls, --i, t);)
3598 if (emit_tinfo_decl (t))
3601 VEC_unordered_remove (tree, unemitted_tinfo_decls, i);
3604 /* The list of objects with static storage duration is built up
3605 in reverse order. We clear STATIC_AGGREGATES so that any new
3606 aggregates added during the initialization of these will be
3607 initialized in the correct order when we next come around the
3609 vars = prune_vars_needing_no_initialization (&static_aggregates);
3613 /* We need to start a new initialization function each time
3614 through the loop. That's because we need to know which
3615 vtables have been referenced, and TREE_SYMBOL_REFERENCED
3616 isn't computed until a function is finished, and written
3617 out. That's a deficiency in the back end. When this is
3618 fixed, these initialization functions could all become
3619 inline, with resulting performance improvements. */
3622 /* Set the line and file, so that it is obviously not from
3624 input_location = locus;
3625 ssdf_body = start_static_storage_duration_function (ssdf_count);
3627 /* Make sure the back end knows about all the variables. */
3628 write_out_vars (vars);
3630 /* First generate code to do all the initializations. */
3632 do_static_initialization_or_destruction (vars, /*initp=*/true);
3634 /* Then, generate code to do all the destructions. Do these
3635 in reverse order so that the most recently constructed
3636 variable is the first destroyed. If we're using
3637 __cxa_atexit, then we don't need to do this; functions
3638 were registered at initialization time to destroy the
3640 if (!flag_use_cxa_atexit && vars)
3642 vars = nreverse (vars);
3643 do_static_initialization_or_destruction (vars, /*initp=*/false);
3648 /* Finish up the static storage duration function for this
3650 input_location = locus;
3651 finish_static_storage_duration_function (ssdf_body);
3653 /* All those initializations and finalizations might cause
3654 us to need more inline functions, more template
3655 instantiations, etc. */
3658 /* ??? was: locus.line++; */
3661 /* Go through the set of inline functions whose bodies have not
3662 been emitted yet. If out-of-line copies of these functions
3663 are required, emit them. */
3664 for (i = 0; VEC_iterate (tree, deferred_fns, i, decl); ++i)
3666 /* Does it need synthesizing? */
3667 if (DECL_DEFAULTED_FN (decl) && ! DECL_INITIAL (decl)
3668 && (! DECL_REALLY_EXTERN (decl) || possibly_inlined_p (decl)))
3670 /* Even though we're already at the top-level, we push
3671 there again. That way, when we pop back a few lines
3672 hence, all of our state is restored. Otherwise,
3673 finish_function doesn't clean things up, and we end
3674 up with CURRENT_FUNCTION_DECL set. */
3675 push_to_top_level ();
3676 /* The decl's location will mark where it was first
3677 needed. Save that so synthesize method can indicate
3678 where it was needed from, in case of error */
3679 input_location = DECL_SOURCE_LOCATION (decl);
3680 synthesize_method (decl);
3681 pop_from_top_level ();
3685 if (!DECL_SAVED_TREE (decl))
3688 /* We lie to the back end, pretending that some functions
3689 are not defined when they really are. This keeps these
3690 functions from being put out unnecessarily. But, we must
3691 stop lying when the functions are referenced, or if they
3692 are not comdat since they need to be put out now. If
3693 DECL_INTERFACE_KNOWN, then we have already set
3694 DECL_EXTERNAL appropriately, so there's no need to check
3695 again, and we do not want to clear DECL_EXTERNAL if a
3696 previous call to import_export_decl set it.
3698 This is done in a separate for cycle, because if some
3699 deferred function is contained in another deferred
3700 function later in deferred_fns varray,
3701 rest_of_compilation would skip this function and we
3702 really cannot expand the same function twice. */
3703 import_export_decl (decl);
3704 if (DECL_NOT_REALLY_EXTERN (decl)
3705 && DECL_INITIAL (decl)
3706 && decl_needed_p (decl))
3708 struct cgraph_node *node = cgraph_get_node (decl), *alias, *next;
3710 DECL_EXTERNAL (decl) = 0;
3711 /* If we mark !DECL_EXTERNAL one of the same body aliases,
3712 we need to mark all of them that way. */
3713 if (node && node->same_body)
3715 DECL_EXTERNAL (node->decl) = 0;
3716 for (alias = node->same_body; alias; alias = alias->next)
3717 DECL_EXTERNAL (alias->decl) = 0;
3719 /* If we mark !DECL_EXTERNAL one of the symbols in some comdat
3720 group, we need to mark all symbols in the same comdat group
3722 if (node->same_comdat_group)
3723 for (next = node->same_comdat_group;
3725 next = next->same_comdat_group)
3727 DECL_EXTERNAL (next->decl) = 0;
3728 if (next->same_body)
3730 for (alias = next->same_body;
3732 alias = alias->next)
3733 DECL_EXTERNAL (alias->decl) = 0;
3738 /* If we're going to need to write this function out, and
3739 there's already a body for it, create RTL for it now.
3740 (There might be no body if this is a method we haven't
3741 gotten around to synthesizing yet.) */
3742 if (!DECL_EXTERNAL (decl)
3743 && decl_needed_p (decl)
3744 && !TREE_ASM_WRITTEN (decl)
3745 && !cgraph_node (decl)->local.finalized)
3747 /* We will output the function; no longer consider it in this
3749 DECL_DEFER_OUTPUT (decl) = 0;
3750 /* Generate RTL for this function now that we know we
3752 expand_or_defer_fn (decl);
3753 /* If we're compiling -fsyntax-only pretend that this
3754 function has been written out so that we don't try to
3756 if (flag_syntax_only)
3757 TREE_ASM_WRITTEN (decl) = 1;
3762 if (walk_namespaces (wrapup_globals_for_namespace, /*data=*/0))
3765 /* Static data members are just like namespace-scope globals. */
3766 for (i = 0; VEC_iterate (tree, pending_statics, i, decl); ++i)
3768 if (var_finalized_p (decl) || DECL_REALLY_EXTERN (decl)
3769 /* Don't write it out if we haven't seen a definition. */
3770 || DECL_IN_AGGR_P (decl))
3772 import_export_decl (decl);
3773 /* If this static data member is needed, provide it to the
3775 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
3776 DECL_EXTERNAL (decl) = 0;
3778 if (VEC_length (tree, pending_statics) != 0
3779 && wrapup_global_declarations (VEC_address (tree, pending_statics),
3780 VEC_length (tree, pending_statics)))
3787 /* All used inline functions must have a definition at this point. */
3788 for (i = 0; VEC_iterate (tree, deferred_fns, i, decl); ++i)
3790 if (/* Check online inline functions that were actually used. */
3791 DECL_ODR_USED (decl) && DECL_DECLARED_INLINE_P (decl)
3792 /* If the definition actually was available here, then the
3793 fact that the function was not defined merely represents
3794 that for some reason (use of a template repository,
3795 #pragma interface, etc.) we decided not to emit the
3797 && !DECL_INITIAL (decl)
3798 /* An explicit instantiation can be used to specify
3799 that the body is in another unit. It will have
3800 already verified there was a definition. */
3801 && !DECL_EXPLICIT_INSTANTIATION (decl))
3803 warning (0, "inline function %q+D used but never defined", decl);
3804 /* Avoid a duplicate warning from check_global_declaration_1. */
3805 TREE_NO_WARNING (decl) = 1;
3809 /* So must decls that use a type with no linkage. */
3810 for (i = 0; VEC_iterate (tree, no_linkage_decls, i, decl); ++i)
3811 if (!decl_defined_p (decl))
3812 no_linkage_error (decl);
3814 /* We give C linkage to static constructors and destructors. */
3815 push_lang_context (lang_name_c);
3817 /* Generate initialization and destruction functions for all
3818 priorities for which they are required. */
3819 if (priority_info_map)
3820 splay_tree_foreach (priority_info_map,
3821 generate_ctor_and_dtor_functions_for_priority,
3823 else if (c_dialect_objc () && objc_static_init_needed_p ())
3824 /* If this is obj-c++ and we need a static init, call
3825 generate_ctor_or_dtor_function. */
3826 generate_ctor_or_dtor_function (/*constructor_p=*/true,
3827 DEFAULT_INIT_PRIORITY, &locus);
3829 /* We're done with the splay-tree now. */
3830 if (priority_info_map)
3831 splay_tree_delete (priority_info_map);
3833 /* Generate any missing aliases. */
3834 maybe_apply_pending_pragma_weaks ();
3836 /* We're done with static constructors, so we can go back to "C++"
3838 pop_lang_context ();
3840 /* Collect candidates for Java hidden aliases. */
3841 candidates = collect_candidates_for_java_method_aliases ();
3843 cgraph_finalize_compilation_unit ();
3845 /* Now, issue warnings about static, but not defined, functions,
3846 etc., and emit debugging information. */
3847 walk_namespaces (wrapup_globals_for_namespace, /*data=*/&reconsider);
3848 if (VEC_length (tree, pending_statics) != 0)
3850 check_global_declarations (VEC_address (tree, pending_statics),
3851 VEC_length (tree, pending_statics));
3852 emit_debug_global_declarations (VEC_address (tree, pending_statics),
3853 VEC_length (tree, pending_statics));
3856 /* Generate hidden aliases for Java. */
3859 build_java_method_aliases (candidates);
3860 pointer_set_destroy (candidates);
3865 /* The entire file is now complete. If requested, dump everything
3869 FILE *stream = dump_begin (TDI_tu, &flags);
3873 dump_node (global_namespace, flags & ~TDF_SLIM, stream);
3874 dump_end (TDI_tu, stream);
3878 timevar_pop (TV_VARCONST);
3880 if (flag_detailed_statistics)
3882 dump_tree_statistics ();
3883 dump_time_statistics ();
3885 input_location = locus;
3887 #ifdef ENABLE_CHECKING
3888 validate_conversion_obstack ();
3889 #endif /* ENABLE_CHECKING */
3892 /* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
3893 function to call in parse-tree form; it has not yet been
3894 semantically analyzed. ARGS are the arguments to the function.
3895 They have already been semantically analyzed. This may change
3899 build_offset_ref_call_from_tree (tree fn, VEC(tree,gc) **args)
3902 VEC(tree,gc) *orig_args = NULL;
3907 object = TREE_OPERAND (fn, 0);
3909 if (processing_template_decl)
3911 gcc_assert (TREE_CODE (fn) == DOTSTAR_EXPR
3912 || TREE_CODE (fn) == MEMBER_REF);
3913 if (type_dependent_expression_p (fn)
3914 || any_type_dependent_arguments_p (*args))
3915 return build_nt_call_vec (fn, *args);
3917 orig_args = make_tree_vector_copy (*args);
3919 /* Transform the arguments and add the implicit "this"
3920 parameter. That must be done before the FN is transformed
3921 because we depend on the form of FN. */
3922 make_args_non_dependent (*args);
3923 object = build_non_dependent_expr (object);
3924 if (TREE_CODE (fn) == DOTSTAR_EXPR)
3925 object = cp_build_unary_op (ADDR_EXPR, object, 0, tf_warning_or_error);
3926 VEC_safe_insert (tree, gc, *args, 0, object);
3927 /* Now that the arguments are done, transform FN. */
3928 fn = build_non_dependent_expr (fn);
3931 /* A qualified name corresponding to a bound pointer-to-member is
3932 represented as an OFFSET_REF:
3934 struct B { void g(); };
3936 void B::g() { (this->*p)(); } */
3937 if (TREE_CODE (fn) == OFFSET_REF)
3939 tree object_addr = cp_build_unary_op (ADDR_EXPR, object, 0,
3940 tf_warning_or_error);
3941 fn = TREE_OPERAND (fn, 1);
3942 fn = get_member_function_from_ptrfunc (&object_addr, fn);
3943 VEC_safe_insert (tree, gc, *args, 0, object_addr);
3946 expr = cp_build_function_call_vec (fn, args, tf_warning_or_error);
3947 if (processing_template_decl && expr != error_mark_node)
3948 expr = build_min_non_dep_call_vec (expr, orig_fn, orig_args);
3950 if (orig_args != NULL)
3951 release_tree_vector (orig_args);
3958 check_default_args (tree x)
3960 tree arg = TYPE_ARG_TYPES (TREE_TYPE (x));
3961 bool saw_def = false;
3962 int i = 0 - (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE);
3963 for (; arg && arg != void_list_node; arg = TREE_CHAIN (arg), ++i)
3965 if (TREE_PURPOSE (arg))
3969 error ("default argument missing for parameter %P of %q+#D", i, x);
3970 TREE_PURPOSE (arg) = error_mark_node;
3975 /* Return true if function DECL can be inlined. This is used to force
3976 instantiation of methods that might be interesting for inlining. */
3978 possibly_inlined_p (tree decl)
3980 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
3981 if (DECL_UNINLINABLE (decl))
3983 if (!optimize || pragma_java_exceptions)
3984 return DECL_DECLARED_INLINE_P (decl);
3985 /* When optimizing, we might inline everything when flatten
3986 attribute or heuristics inlining for size or autoinlining
3991 /* Mark DECL (either a _DECL or a BASELINK) as "used" in the program.
3992 If DECL is a specialization or implicitly declared class member,
3993 generate the actual definition. */
3996 mark_used (tree decl)
3998 HOST_WIDE_INT saved_processing_template_decl = 0;
4000 /* If DECL is a BASELINK for a single function, then treat it just
4001 like the DECL for the function. Otherwise, if the BASELINK is
4002 for an overloaded function, we don't know which function was
4003 actually used until after overload resolution. */
4004 if (TREE_CODE (decl) == BASELINK)
4006 decl = BASELINK_FUNCTIONS (decl);
4007 if (really_overloaded_fn (decl))
4009 decl = OVL_CURRENT (decl);
4012 /* Set TREE_USED for the benefit of -Wunused. */
4013 TREE_USED (decl) = 1;
4014 if (DECL_CLONED_FUNCTION_P (decl))
4015 TREE_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4017 if (TREE_CODE (decl) == FUNCTION_DECL
4018 && DECL_DELETED_FN (decl))
4020 if (DECL_ARTIFICIAL (decl))
4022 if (DECL_OVERLOADED_OPERATOR_P (decl) == TYPE_EXPR
4023 && LAMBDA_TYPE_P (DECL_CONTEXT (decl)))
4025 /* We mark a lambda conversion op as deleted if we can't
4026 generate it properly; see maybe_add_lambda_conv_op. */
4027 sorry ("converting lambda which uses %<...%> to "
4028 "function pointer");
4032 error ("deleted function %q+D", decl);
4033 error ("used here");
4036 /* If we don't need a value, then we don't need to synthesize DECL. */
4037 if (cp_unevaluated_operand != 0)
4040 /* We can only check DECL_ODR_USED on variables or functions with
4041 DECL_LANG_SPECIFIC set, and these are also the only decls that we
4042 might need special handling for. */
4043 if ((TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4044 || DECL_LANG_SPECIFIC (decl) == NULL
4045 || DECL_THUNK_P (decl))
4048 /* We only want to do this processing once. We don't need to keep trying
4049 to instantiate inline templates, because unit-at-a-time will make sure
4050 we get them compiled before functions that want to inline them. */
4051 if (DECL_ODR_USED (decl))
4054 /* If within finish_function, defer the rest until that function
4055 finishes, otherwise it might recurse. */
4056 if (defer_mark_used_calls)
4058 VEC_safe_push (tree, gc, deferred_mark_used_calls, decl);
4062 /* Normally, we can wait until instantiation-time to synthesize
4063 DECL. However, if DECL is a static data member initialized with
4064 a constant, we need the value right now because a reference to
4065 such a data member is not value-dependent. */
4066 if (TREE_CODE (decl) == VAR_DECL
4067 && DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl)
4068 && DECL_CLASS_SCOPE_P (decl))
4070 /* Don't try to instantiate members of dependent types. We
4071 cannot just use dependent_type_p here because this function
4072 may be called from fold_non_dependent_expr, and then we may
4073 see dependent types, even though processing_template_decl
4075 if (CLASSTYPE_TEMPLATE_INFO ((DECL_CONTEXT (decl)))
4076 && uses_template_parms (CLASSTYPE_TI_ARGS (DECL_CONTEXT (decl))))
4078 /* Pretend that we are not in a template, even if we are, so
4079 that the static data member initializer will be processed. */
4080 saved_processing_template_decl = processing_template_decl;
4081 processing_template_decl = 0;
4084 if (processing_template_decl)
4087 DECL_ODR_USED (decl) = 1;
4088 if (DECL_CLONED_FUNCTION_P (decl))
4089 DECL_ODR_USED (DECL_CLONED_FUNCTION (decl)) = 1;
4091 /* DR 757: A type without linkage shall not be used as the type of a
4092 variable or function with linkage, unless
4093 o the variable or function has extern "C" linkage (7.5 [dcl.link]), or
4094 o the variable or function is not used (3.2 [basic.def.odr]) or is
4095 defined in the same translation unit. */
4096 if (cxx_dialect > cxx98
4097 && decl_linkage (decl) != lk_none
4098 && !DECL_EXTERN_C_P (decl)
4099 && !DECL_ARTIFICIAL (decl)
4100 && !decl_defined_p (decl)
4101 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
4103 if (is_local_extern (decl))
4104 /* There's no way to define a local extern, and adding it to
4105 the vector interferes with GC, so give an error now. */
4106 no_linkage_error (decl);
4108 VEC_safe_push (tree, gc, no_linkage_decls, decl);
4111 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)
4112 && !DECL_INITIAL (decl) && !DECL_ARTIFICIAL (decl))
4113 /* Remember it, so we can check it was defined. */
4114 note_vague_linkage_fn (decl);
4116 /* Is it a synthesized method that needs to be synthesized? */
4117 if (TREE_CODE (decl) == FUNCTION_DECL
4118 && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
4119 && DECL_DEFAULTED_FN (decl)
4120 && ! DECL_INITIAL (decl))
4122 /* Remember the current location for a function we will end up
4123 synthesizing. Then we can inform the user where it was
4124 required in the case of error. */
4125 DECL_SOURCE_LOCATION (decl) = input_location;
4127 /* Synthesizing an implicitly defined member function will result in
4128 garbage collection. We must treat this situation as if we were
4129 within the body of a function so as to avoid collecting live data
4130 on the stack (such as overload resolution candidates).
4132 We could just let cp_write_global_declarations handle synthesizing
4133 this function, since we just added it to deferred_fns, but doing
4134 it at the use site produces better error messages. */
4136 synthesize_method (decl);
4138 /* If this is a synthesized method we don't need to
4139 do the instantiation test below. */
4141 else if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
4142 && DECL_TEMPLATE_INFO (decl)
4143 && (!DECL_EXPLICIT_INSTANTIATION (decl)
4144 || always_instantiate_p (decl)))
4145 /* If this is a function or variable that is an instance of some
4146 template, we now know that we will need to actually do the
4147 instantiation. We check that DECL is not an explicit
4148 instantiation because that is not checked in instantiate_decl.
4150 We put off instantiating functions in order to improve compile
4151 times. Maintaining a stack of active functions is expensive,
4152 and the inliner knows to instantiate any functions it might
4153 need. Therefore, we always try to defer instantiation. */
4154 instantiate_decl (decl, /*defer_ok=*/true,
4155 /*expl_inst_class_mem_p=*/false);
4157 processing_template_decl = saved_processing_template_decl;
4160 #include "gt-cp-decl2.h"