1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Contributed 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"
38 #include "tree-iterator.h"
39 #include "tree-inline.h"
46 #include "c-family/c-common.h"
47 #include "c-family/c-objc.h"
48 #include "c-family/c-pragma.h"
49 #include "diagnostic.h"
53 #include "pointer-set.h"
54 #include "splay-tree.h"
57 /* Possible cases of bad specifiers type used by bad_specifiers. */
59 BSP_VAR, /* variable */
60 BSP_PARM, /* parameter */
65 static tree grokparms (tree parmlist, tree *);
66 static const char *redeclaration_error_message (tree, tree);
68 static int decl_jump_unsafe (tree);
69 static void require_complete_types_for_parms (tree);
70 static int ambi_op_p (enum tree_code);
71 static int unary_op_p (enum tree_code);
72 static void push_local_name (tree);
73 static tree grok_reference_init (tree, tree, tree, int);
74 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
76 static int check_static_variable_definition (tree, tree);
77 static void record_unknown_type (tree, const char *);
78 static tree builtin_function_1 (tree, tree, bool);
79 static tree build_library_fn_1 (tree, enum tree_code, tree);
80 static int member_function_or_else (tree, tree, enum overload_flags);
81 static void bad_specifiers (tree, enum bad_spec_place, int, int, int, int,
83 static void check_for_uninitialized_const_var (tree);
84 static hashval_t typename_hash (const void *);
85 static int typename_compare (const void *, const void *);
86 static tree local_variable_p_walkfn (tree *, int *, void *);
87 static tree record_builtin_java_type (const char *, int);
88 static const char *tag_name (enum tag_types);
89 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
90 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
91 static void maybe_deduce_size_from_array_init (tree, tree);
92 static void layout_var_decl (tree);
93 static tree check_initializer (tree, tree, int, VEC(tree,gc) **);
94 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
95 static void save_function_data (tree);
96 static void copy_type_enum (tree , tree);
97 static void check_function_type (tree, tree);
98 static void finish_constructor_body (void);
99 static void begin_destructor_body (void);
100 static void finish_destructor_body (void);
101 static void record_key_method_defined (tree);
102 static tree create_array_type_for_decl (tree, tree, tree);
103 static tree get_atexit_node (void);
104 static tree get_dso_handle_node (void);
105 static tree start_cleanup_fn (void);
106 static void end_cleanup_fn (void);
107 static tree cp_make_fname_decl (location_t, tree, int);
108 static void initialize_predefined_identifiers (void);
109 static tree check_special_function_return_type
110 (special_function_kind, tree, tree);
111 static tree push_cp_library_fn (enum tree_code, tree);
112 static tree build_cp_library_fn (tree, enum tree_code, tree);
113 static void store_parm_decls (tree);
114 static void initialize_local_var (tree, tree);
115 static void expand_static_init (tree, tree);
117 /* The following symbols are subsumed in the cp_global_trees array, and
118 listed here individually for documentation purposes.
121 tree wchar_decl_node;
123 tree vtable_entry_type;
124 tree delta_type_node;
125 tree __t_desc_type_node;
127 tree class_type_node;
128 tree unknown_type_node;
130 Array type `vtable_entry_type[]'
133 tree vtbl_ptr_type_node;
140 A FUNCTION_DECL which can call `abort'. Not necessarily the
141 one that the user will declare, but sufficient to be called
142 by routines that want to abort the program.
146 The FUNCTION_DECL for the default `::operator delete'.
148 tree global_delete_fndecl;
151 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
152 tree tinfo_var_id; */
154 tree cp_global_trees[CPTI_MAX];
156 /* Indicates that there is a type value in some namespace, although
157 that is not necessarily in scope at the moment. */
159 tree global_type_node;
161 /* The node that holds the "name" of the global scope. */
162 tree global_scope_name;
164 #define local_names cp_function_chain->x_local_names
166 /* A list of objects which have constructors or destructors
167 which reside in the global scope. The decl is stored in
168 the TREE_VALUE slot and the initializer is stored
169 in the TREE_PURPOSE slot. */
170 tree static_aggregates;
174 /* A node for the integer constant 2. */
176 tree integer_two_node;
178 /* Used only for jumps to as-yet undefined labels, since jumps to
179 defined labels can have their validity checked immediately. */
181 struct GTY((chain_next ("%h.next"))) named_label_use_entry {
182 struct named_label_use_entry *next;
183 /* The binding level to which this entry is *currently* attached.
184 This is initially the binding level in which the goto appeared,
185 but is modified as scopes are closed. */
186 cp_binding_level *binding_level;
187 /* The head of the names list that was current when the goto appeared,
188 or the inner scope popped. These are the decls that will *not* be
189 skipped when jumping to the label. */
191 /* The location of the goto, for error reporting. */
192 location_t o_goto_locus;
193 /* True if an OpenMP structured block scope has been closed since
194 the goto appeared. This means that the branch from the label will
195 illegally exit an OpenMP scope. */
199 /* A list of all LABEL_DECLs in the function that have names. Here so
200 we can clear out their names' definitions at the end of the
201 function, and so we can check the validity of jumps to these labels. */
203 struct GTY(()) named_label_entry {
204 /* The decl itself. */
207 /* The binding level to which the label is *currently* attached.
208 This is initially set to the binding level in which the label
209 is defined, but is modified as scopes are closed. */
210 cp_binding_level *binding_level;
211 /* The head of the names list that was current when the label was
212 defined, or the inner scope popped. These are the decls that will
213 be skipped when jumping to the label. */
215 /* A vector of all decls from all binding levels that would be
216 crossed by a backward branch to the label. */
217 VEC(tree,gc) *bad_decls;
219 /* A list of uses of the label, before the label is defined. */
220 struct named_label_use_entry *uses;
222 /* The following bits are set after the label is defined, and are
223 updated as scopes are popped. They indicate that a backward jump
224 to the label will illegally enter a scope of the given flavor. */
230 #define named_labels cp_function_chain->x_named_labels
232 /* The number of function bodies which we are currently processing.
233 (Zero if we are at namespace scope, one inside the body of a
234 function, two inside the body of a function in a local class, etc.) */
237 /* To avoid unwanted recursion, finish_function defers all mark_used calls
238 encountered during its execution until it finishes. */
239 bool defer_mark_used_calls;
240 VEC(tree, gc) *deferred_mark_used_calls;
242 /* States indicating how grokdeclarator() should handle declspecs marked
243 with __attribute__((deprecated)). An object declared as
244 __attribute__((deprecated)) suppresses warnings of uses of other
246 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
249 /* A list of VAR_DECLs whose type was incomplete at the time the
250 variable was declared. */
252 typedef struct GTY(()) incomplete_var_d {
254 tree incomplete_type;
257 DEF_VEC_O(incomplete_var);
258 DEF_VEC_ALLOC_O(incomplete_var,gc);
260 static GTY(()) VEC(incomplete_var,gc) *incomplete_vars;
262 /* Returns the kind of template specialization we are currently
263 processing, given that it's declaration contained N_CLASS_SCOPES
264 explicit scope qualifications. */
267 current_tmpl_spec_kind (int n_class_scopes)
269 int n_template_parm_scopes = 0;
270 int seen_specialization_p = 0;
271 int innermost_specialization_p = 0;
274 /* Scan through the template parameter scopes. */
275 for (b = current_binding_level;
276 b->kind == sk_template_parms;
279 /* If we see a specialization scope inside a parameter scope,
280 then something is wrong. That corresponds to a declaration
283 template <class T> template <> ...
285 which is always invalid since [temp.expl.spec] forbids the
286 specialization of a class member template if the enclosing
287 class templates are not explicitly specialized as well. */
288 if (b->explicit_spec_p)
290 if (n_template_parm_scopes == 0)
291 innermost_specialization_p = 1;
293 seen_specialization_p = 1;
295 else if (seen_specialization_p == 1)
296 return tsk_invalid_member_spec;
298 ++n_template_parm_scopes;
301 /* Handle explicit instantiations. */
302 if (processing_explicit_instantiation)
304 if (n_template_parm_scopes != 0)
305 /* We've seen a template parameter list during an explicit
306 instantiation. For example:
308 template <class T> template void f(int);
310 This is erroneous. */
311 return tsk_invalid_expl_inst;
313 return tsk_expl_inst;
316 if (n_template_parm_scopes < n_class_scopes)
317 /* We've not seen enough template headers to match all the
318 specialized classes present. For example:
320 template <class T> void R<T>::S<T>::f(int);
322 This is invalid; there needs to be one set of template
323 parameters for each class. */
324 return tsk_insufficient_parms;
325 else if (n_template_parm_scopes == n_class_scopes)
326 /* We're processing a non-template declaration (even though it may
327 be a member of a template class.) For example:
329 template <class T> void S<T>::f(int);
331 The `class T' matches the `S<T>', leaving no template headers
332 corresponding to the `f'. */
334 else if (n_template_parm_scopes > n_class_scopes + 1)
335 /* We've got too many template headers. For example:
337 template <> template <class T> void f (T);
339 There need to be more enclosing classes. */
340 return tsk_excessive_parms;
342 /* This must be a template. It's of the form:
344 template <class T> template <class U> void S<T>::f(U);
346 This is a specialization if the innermost level was a
347 specialization; otherwise it's just a definition of the
349 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
352 /* Exit the current scope. */
360 /* When a label goes out of scope, check to see if that label was used
361 in a valid manner, and issue any appropriate warnings or errors. */
364 pop_label (tree label, tree old_value)
366 if (!processing_template_decl)
368 if (DECL_INITIAL (label) == NULL_TREE)
372 error ("label %q+D used but not defined", label);
373 location = input_location; /* FIXME want (input_filename, (line)0) */
374 /* Avoid crashing later. */
375 define_label (location, DECL_NAME (label));
378 warn_for_unused_label (label);
381 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
384 /* At the end of a function, all labels declared within the function
385 go out of scope. BLOCK is the top-level block for the
389 pop_labels_1 (void **slot, void *data)
391 struct named_label_entry *ent = (struct named_label_entry *) *slot;
392 tree block = (tree) data;
394 pop_label (ent->label_decl, NULL_TREE);
396 /* Put the labels into the "variables" of the top-level block,
397 so debugger can see them. */
398 DECL_CHAIN (ent->label_decl) = BLOCK_VARS (block);
399 BLOCK_VARS (block) = ent->label_decl;
401 htab_clear_slot (named_labels, slot);
407 pop_labels (tree block)
411 htab_traverse (named_labels, pop_labels_1, block);
416 /* At the end of a block with local labels, restore the outer definition. */
419 pop_local_label (tree label, tree old_value)
421 struct named_label_entry dummy;
424 pop_label (label, old_value);
426 dummy.label_decl = label;
427 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
428 htab_clear_slot (named_labels, slot);
431 /* The following two routines are used to interface to Objective-C++.
432 The binding level is purposely treated as an opaque type. */
435 objc_get_current_scope (void)
437 return current_binding_level;
440 /* The following routine is used by the NeXT-style SJLJ exceptions;
441 variables get marked 'volatile' so as to not be clobbered by
442 _setjmp()/_longjmp() calls. All variables in the current scope,
443 as well as parent scopes up to (but not including) ENCLOSING_BLK
444 shall be thusly marked. */
447 objc_mark_locals_volatile (void *enclosing_blk)
449 cp_binding_level *scope;
451 for (scope = current_binding_level;
452 scope && scope != enclosing_blk;
453 scope = scope->level_chain)
457 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
458 objc_volatilize_decl (decl);
460 /* Do not climb up past the current function. */
461 if (scope->kind == sk_function_parms)
466 /* Update data for defined and undefined labels when leaving a scope. */
469 poplevel_named_label_1 (void **slot, void *data)
471 struct named_label_entry *ent = (struct named_label_entry *) *slot;
472 cp_binding_level *bl = (cp_binding_level *) data;
473 cp_binding_level *obl = bl->level_chain;
475 if (ent->binding_level == bl)
479 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
480 TREE_LISTs representing OVERLOADs, so be careful. */
481 for (decl = ent->names_in_scope; decl; decl = (DECL_P (decl)
483 : TREE_CHAIN (decl)))
484 if (decl_jump_unsafe (decl))
485 VEC_safe_push (tree, gc, ent->bad_decls, decl);
487 ent->binding_level = obl;
488 ent->names_in_scope = obl->names;
492 ent->in_try_scope = true;
495 ent->in_catch_scope = true;
498 ent->in_omp_scope = true;
506 struct named_label_use_entry *use;
508 for (use = ent->uses; use ; use = use->next)
509 if (use->binding_level == bl)
511 use->binding_level = obl;
512 use->names_in_scope = obl->names;
513 if (bl->kind == sk_omp)
514 use->in_omp_scope = true;
521 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
522 when errors were reported, except for -Werror-unused-but-set-*. */
523 static int unused_but_set_errorcount;
525 /* Exit a binding level.
526 Pop the level off, and restore the state of the identifier-decl mappings
527 that were in effect when this level was entered.
529 If KEEP == 1, this level had explicit declarations, so
530 and create a "block" (a BLOCK node) for the level
531 to record its declarations and subblocks for symbol table output.
533 If FUNCTIONBODY is nonzero, this level is the body of a function,
534 so create a block as if KEEP were set and also clear out all
537 If REVERSE is nonzero, reverse the order of decls before putting
538 them into the BLOCK. */
541 poplevel (int keep, int reverse, int functionbody)
544 /* The chain of decls was accumulated in reverse order.
545 Put it into forward order, just for cleanliness. */
550 int leaving_for_scope;
553 cp_label_binding *label_bind;
555 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
560 gcc_assert (current_binding_level->kind != sk_class);
562 if (current_binding_level->kind == sk_cleanup)
564 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
566 gcc_assert (!VEC_length(cp_class_binding,
567 current_binding_level->class_shadowed));
569 /* We used to use KEEP == 2 to indicate that the new block should go
570 at the beginning of the list of blocks at this binding level,
571 rather than the end. This hack is no longer used. */
572 gcc_assert (keep == 0 || keep == 1);
574 if (current_binding_level->keep)
577 /* Any uses of undefined labels, and any defined labels, now operate
578 under constraints of next binding contour. */
579 if (cfun && !functionbody && named_labels)
580 htab_traverse (named_labels, poplevel_named_label_1,
581 current_binding_level);
583 /* Get the decls in the order they were written.
584 Usually current_binding_level->names is in reverse order.
585 But parameter decls were previously put in forward order. */
588 current_binding_level->names
589 = decls = nreverse (current_binding_level->names);
591 decls = current_binding_level->names;
593 /* If there were any declarations or structure tags in that level,
594 or if this level is a function body,
595 create a BLOCK to record them for the life of this function. */
597 if (keep == 1 || functionbody)
598 block = make_node (BLOCK);
599 if (block != NULL_TREE)
601 BLOCK_VARS (block) = decls;
602 BLOCK_SUBBLOCKS (block) = subblocks;
605 /* In each subblock, record that this is its superior. */
607 for (link = subblocks; link; link = BLOCK_CHAIN (link))
608 BLOCK_SUPERCONTEXT (link) = block;
610 /* We still support the old for-scope rules, whereby the variables
611 in a for-init statement were in scope after the for-statement
612 ended. We only use the new rules if flag_new_for_scope is
615 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
617 /* Before we remove the declarations first check for unused variables. */
618 if ((warn_unused_variable || warn_unused_but_set_variable)
619 && !processing_template_decl)
620 for (tree d = getdecls (); d; d = TREE_CHAIN (d))
622 /* There are cases where D itself is a TREE_LIST. See in
623 push_local_binding where the list of decls returned by
624 getdecls is built. */
625 decl = TREE_CODE (d) == TREE_LIST ? TREE_VALUE (d) : d;
626 if (TREE_CODE (decl) == VAR_DECL
627 && (! TREE_USED (decl) || !DECL_READ_P (decl))
628 && ! DECL_IN_SYSTEM_HEADER (decl)
629 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)
630 && TREE_TYPE (decl) != error_mark_node
631 && (!CLASS_TYPE_P (TREE_TYPE (decl))
632 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
634 if (! TREE_USED (decl))
635 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
636 else if (DECL_CONTEXT (decl) == current_function_decl
637 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
638 && errorcount == unused_but_set_errorcount)
640 warning (OPT_Wunused_but_set_variable,
641 "variable %q+D set but not used", decl);
642 unused_but_set_errorcount = errorcount;
647 /* Remove declarations for all the DECLs in this level. */
648 for (link = decls; link; link = TREE_CHAIN (link))
650 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
651 /* It's hard to make this ARM compatibility hack play nicely with
652 lambdas, and it really isn't necessary in C++11 mode. */
653 && cxx_dialect < cxx0x
656 tree name = DECL_NAME (link);
660 ob = outer_binding (name,
661 IDENTIFIER_BINDING (name),
664 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
666 ns_binding = NULL_TREE;
668 if (ob && ob->scope == current_binding_level->level_chain)
669 /* We have something like:
674 and we are leaving the `for' scope. There's no reason to
675 keep the binding of the inner `i' in this case. */
676 pop_binding (name, link);
677 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
678 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
679 /* Here, we have something like:
687 We must pop the for-scope binding so we know what's a
688 type and what isn't. */
689 pop_binding (name, link);
692 /* Mark this VAR_DECL as dead so that we can tell we left it
693 there only for backward compatibility. */
694 DECL_DEAD_FOR_LOCAL (link) = 1;
696 /* Keep track of what should have happened when we
697 popped the binding. */
700 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
701 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
704 /* Add it to the list of dead variables in the next
705 outermost binding to that we can remove these when we
706 leave that binding. */
707 VEC_safe_push (tree, gc,
708 current_binding_level->level_chain->dead_vars_from_for,
711 /* Although we don't pop the cxx_binding, we do clear
712 its SCOPE since the scope is going away now. */
713 IDENTIFIER_BINDING (name)->scope
714 = current_binding_level->level_chain;
721 /* Remove the binding. */
724 if (TREE_CODE (decl) == TREE_LIST)
725 decl = TREE_VALUE (decl);
728 if (TREE_CODE (name) == OVERLOAD)
729 name = OVL_FUNCTION (name);
731 gcc_assert (DECL_P (name));
732 pop_binding (DECL_NAME (name), decl);
736 /* Remove declarations for any `for' variables from inner scopes
737 that we kept around. */
738 FOR_EACH_VEC_ELT_REVERSE (tree, current_binding_level->dead_vars_from_for,
740 pop_binding (DECL_NAME (decl), decl);
742 /* Restore the IDENTIFIER_TYPE_VALUEs. */
743 for (link = current_binding_level->type_shadowed;
744 link; link = TREE_CHAIN (link))
745 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
747 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
748 FOR_EACH_VEC_ELT_REVERSE (cp_label_binding,
749 current_binding_level->shadowed_labels,
751 pop_local_label (label_bind->label, label_bind->prev_value);
753 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
754 list if a `using' declaration put them there. The debugging
755 back ends won't understand OVERLOAD, so we remove them here.
756 Because the BLOCK_VARS are (temporarily) shared with
757 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
758 popped all the bindings. */
763 for (d = &BLOCK_VARS (block); *d; )
765 if (TREE_CODE (*d) == TREE_LIST)
766 *d = TREE_CHAIN (*d);
768 d = &DECL_CHAIN (*d);
772 /* If the level being exited is the top level of a function,
773 check over all the labels. */
776 /* Since this is the top level block of a function, the vars are
777 the function's parameters. Don't leave them in the BLOCK
778 because they are found in the FUNCTION_DECL instead. */
779 BLOCK_VARS (block) = 0;
783 kind = current_binding_level->kind;
784 if (kind == sk_cleanup)
788 /* If this is a temporary binding created for a cleanup, then we'll
789 have pushed a statement list level. Pop that, create a new
790 BIND_EXPR for the block, and insert it into the stream. */
791 stmt = pop_stmt_list (current_binding_level->statement_list);
792 stmt = c_build_bind_expr (input_location, block, stmt);
799 /* The current function is being defined, so its DECL_INITIAL
800 should be error_mark_node. */
801 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
802 DECL_INITIAL (current_function_decl) = block;
805 current_binding_level->blocks
806 = block_chainon (current_binding_level->blocks, block);
808 /* If we did not make a block for the level just exited,
809 any blocks made for inner levels
810 (since they cannot be recorded as subblocks in that level)
811 must be carried forward so they will later become subblocks
812 of something else. */
814 current_binding_level->blocks
815 = block_chainon (current_binding_level->blocks, subblocks);
817 /* Each and every BLOCK node created here in `poplevel' is important
818 (e.g. for proper debugging information) so if we created one
819 earlier, mark it as "used". */
821 TREE_USED (block) = 1;
823 /* All temporary bindings created for cleanups are popped silently. */
824 if (kind == sk_cleanup)
827 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
831 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
832 itself, calling F for each. The DATA is passed to F as well. */
835 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
838 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
840 result |= (*f) (name_space, data);
842 for (; current; current = DECL_CHAIN (current))
843 result |= walk_namespaces_r (current, f, data);
848 /* Walk all the namespaces, calling F for each. The DATA is passed to
852 walk_namespaces (walk_namespaces_fn f, void* data)
854 return walk_namespaces_r (global_namespace, f, data);
857 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
858 DATA is non-NULL, this is the last time we will call
859 wrapup_global_declarations for this NAMESPACE. */
862 wrapup_globals_for_namespace (tree name_space, void* data)
864 cp_binding_level *level = NAMESPACE_LEVEL (name_space);
865 VEC(tree,gc) *statics = level->static_decls;
866 tree *vec = VEC_address (tree, statics);
867 int len = VEC_length (tree, statics);
868 int last_time = (data != 0);
872 check_global_declarations (vec, len);
873 emit_debug_global_declarations (vec, len);
877 /* Write out any globals that need to be output. */
878 return wrapup_global_declarations (vec, len);
882 /* In C++, you don't have to write `struct S' to refer to `S'; you
883 can just use `S'. We accomplish this by creating a TYPE_DECL as
884 if the user had written `typedef struct S S'. Create and return
885 the TYPE_DECL for TYPE. */
888 create_implicit_typedef (tree name, tree type)
892 decl = build_decl (input_location, TYPE_DECL, name, type);
893 DECL_ARTIFICIAL (decl) = 1;
894 /* There are other implicit type declarations, like the one *within*
895 a class that allows you to write `S::S'. We must distinguish
897 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
898 TYPE_NAME (type) = decl;
899 TYPE_STUB_DECL (type) = decl;
904 /* Remember a local name for name-mangling purposes. */
907 push_local_name (tree decl)
912 timevar_start (TV_NAME_LOOKUP);
914 name = DECL_NAME (decl);
916 nelts = VEC_length (tree, local_names);
917 for (i = 0; i < nelts; i++)
919 t = VEC_index (tree, local_names, i);
920 if (DECL_NAME (t) == name)
922 if (!DECL_LANG_SPECIFIC (decl))
923 retrofit_lang_decl (decl);
924 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
925 if (DECL_LANG_SPECIFIC (t))
926 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
928 DECL_DISCRIMINATOR (decl) = 1;
930 VEC_replace (tree, local_names, i, decl);
931 timevar_stop (TV_NAME_LOOKUP);
936 VEC_safe_push (tree, gc, local_names, decl);
937 timevar_stop (TV_NAME_LOOKUP);
940 /* Subroutine of duplicate_decls: return truthvalue of whether
941 or not types of these decls match.
943 For C++, we must compare the parameter list so that `int' can match
944 `int&' in a parameter position, but `int&' is not confused with
948 decls_match (tree newdecl, tree olddecl)
952 if (newdecl == olddecl)
955 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
956 /* If the two DECLs are not even the same kind of thing, we're not
957 interested in their types. */
960 gcc_assert (DECL_P (newdecl));
962 if (TREE_CODE (newdecl) == FUNCTION_DECL)
964 tree f1 = TREE_TYPE (newdecl);
965 tree f2 = TREE_TYPE (olddecl);
966 tree p1 = TYPE_ARG_TYPES (f1);
967 tree p2 = TYPE_ARG_TYPES (f2);
970 /* Specializations of different templates are different functions
971 even if they have the same type. */
972 tree t1 = (DECL_USE_TEMPLATE (newdecl)
973 ? DECL_TI_TEMPLATE (newdecl)
975 tree t2 = (DECL_USE_TEMPLATE (olddecl)
976 ? DECL_TI_TEMPLATE (olddecl)
981 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
982 && ! (DECL_EXTERN_C_P (newdecl)
983 && DECL_EXTERN_C_P (olddecl)))
986 #ifdef NO_IMPLICIT_EXTERN_C
987 /* A new declaration doesn't match a built-in one unless it
988 is also extern "C". */
989 if (DECL_IS_BUILTIN (olddecl)
990 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
994 if (TREE_CODE (f1) != TREE_CODE (f2))
997 /* A declaration with deduced return type should use its pre-deduction
998 type for declaration matching. */
999 if (FNDECL_USED_AUTO (olddecl))
1000 r2 = DECL_STRUCT_FUNCTION (olddecl)->language->x_auto_return_pattern;
1002 r2 = TREE_TYPE (f2);
1004 if (same_type_p (TREE_TYPE (f1), r2))
1006 if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
1007 && (DECL_BUILT_IN (olddecl)
1008 #ifndef NO_IMPLICIT_EXTERN_C
1009 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
1010 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
1014 types_match = self_promoting_args_p (p1);
1015 if (p1 == void_list_node)
1016 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1018 #ifndef NO_IMPLICIT_EXTERN_C
1019 else if (!prototype_p (f1)
1020 && (DECL_EXTERN_C_P (olddecl)
1021 && DECL_IN_SYSTEM_HEADER (olddecl)
1022 && !DECL_CLASS_SCOPE_P (olddecl))
1023 && (DECL_EXTERN_C_P (newdecl)
1024 && DECL_IN_SYSTEM_HEADER (newdecl)
1025 && !DECL_CLASS_SCOPE_P (newdecl)))
1027 types_match = self_promoting_args_p (p2);
1028 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1034 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
1035 || comp_type_attributes (TREE_TYPE (newdecl),
1036 TREE_TYPE (olddecl)) != 0);
1041 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1043 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1044 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1047 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1048 DECL_TEMPLATE_PARMS (olddecl)))
1051 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1052 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1053 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1055 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1056 DECL_TEMPLATE_RESULT (newdecl));
1060 /* Need to check scope for variable declaration (VAR_DECL).
1061 For typedef (TYPE_DECL), scope is ignored. */
1062 if (TREE_CODE (newdecl) == VAR_DECL
1063 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1065 Two declarations for an object with C language linkage
1066 with the same name (ignoring the namespace that qualify
1067 it) that appear in different namespace scopes refer to
1069 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1072 if (TREE_TYPE (newdecl) == error_mark_node)
1073 types_match = TREE_TYPE (olddecl) == error_mark_node;
1074 else if (TREE_TYPE (olddecl) == NULL_TREE)
1075 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1076 else if (TREE_TYPE (newdecl) == NULL_TREE)
1079 types_match = comptypes (TREE_TYPE (newdecl),
1080 TREE_TYPE (olddecl),
1081 COMPARE_REDECLARATION);
1087 /* If NEWDECL is `static' and an `extern' was seen previously,
1088 warn about it. OLDDECL is the previous declaration.
1090 Note that this does not apply to the C++ case of declaring
1091 a variable `extern const' and then later `const'.
1093 Don't complain about built-in functions, since they are beyond
1094 the user's control. */
1097 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1099 if (TREE_CODE (newdecl) == TYPE_DECL
1100 || TREE_CODE (newdecl) == TEMPLATE_DECL
1101 || TREE_CODE (newdecl) == CONST_DECL
1102 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1105 /* Don't get confused by static member functions; that's a different
1107 if (TREE_CODE (newdecl) == FUNCTION_DECL
1108 && DECL_STATIC_FUNCTION_P (newdecl))
1111 /* If the old declaration was `static', or the new one isn't, then
1112 everything is OK. */
1113 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1116 /* It's OK to declare a builtin function as `static'. */
1117 if (TREE_CODE (olddecl) == FUNCTION_DECL
1118 && DECL_ARTIFICIAL (olddecl))
1121 permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1122 permerror (input_location, "previous declaration of %q+D", olddecl);
1125 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1126 function templates. If their exception specifications do not
1127 match, issue a diagnostic. */
1130 check_redeclaration_exception_specification (tree new_decl,
1135 tree new_exceptions;
1136 tree old_exceptions;
1138 new_type = TREE_TYPE (new_decl);
1139 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1140 old_type = TREE_TYPE (old_decl);
1141 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1145 If any declaration of a function has an exception-specification,
1146 all declarations, including the definition and an explicit
1147 specialization, of that function shall have an
1148 exception-specification with the same set of type-ids. */
1149 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1150 && ! DECL_IS_BUILTIN (old_decl)
1152 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal))
1154 error ("declaration of %qF has a different exception specifier",
1156 error ("from previous declaration %q+F", old_decl);
1160 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1161 Otherwise issue diagnostics. */
1164 validate_constexpr_redeclaration (tree old_decl, tree new_decl)
1166 old_decl = STRIP_TEMPLATE (old_decl);
1167 new_decl = STRIP_TEMPLATE (new_decl);
1168 if (!VAR_OR_FUNCTION_DECL_P (old_decl)
1169 || !VAR_OR_FUNCTION_DECL_P (new_decl))
1171 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
1172 == DECL_DECLARED_CONSTEXPR_P (new_decl))
1174 if (TREE_CODE (old_decl) == FUNCTION_DECL && DECL_BUILT_IN (old_decl))
1176 /* Hide a built-in declaration. */
1177 DECL_DECLARED_CONSTEXPR_P (old_decl)
1178 = DECL_DECLARED_CONSTEXPR_P (new_decl);
1181 error ("redeclaration %qD differs in %<constexpr%>", new_decl);
1182 error ("from previous declaration %q+D", old_decl);
1186 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1187 && lookup_attribute ("gnu_inline", \
1188 DECL_ATTRIBUTES (fn)))
1190 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1191 If the redeclaration is invalid, a diagnostic is issued, and the
1192 error_mark_node is returned. Otherwise, OLDDECL is returned.
1194 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1197 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1200 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1202 unsigned olddecl_uid = DECL_UID (olddecl);
1203 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1204 int new_defines_function = 0;
1205 tree new_template_info;
1207 if (newdecl == olddecl)
1210 types_match = decls_match (newdecl, olddecl);
1212 /* If either the type of the new decl or the type of the old decl is an
1213 error_mark_node, then that implies that we have already issued an
1214 error (earlier) for some bogus type specification, and in that case,
1215 it is rather pointless to harass the user with yet more error message
1216 about the same declaration, so just pretend the types match here. */
1217 if (TREE_TYPE (newdecl) == error_mark_node
1218 || TREE_TYPE (olddecl) == error_mark_node)
1219 return error_mark_node;
1221 if (UDLIT_OPER_P (DECL_NAME (newdecl))
1222 && UDLIT_OPER_P (DECL_NAME (olddecl)))
1224 if (TREE_CODE (newdecl) == TEMPLATE_DECL
1225 && TREE_CODE (olddecl) != TEMPLATE_DECL
1226 && check_raw_literal_operator (olddecl))
1227 error ("literal operator template %q+D conflicts with"
1228 " raw literal operator %qD", newdecl, olddecl);
1229 else if (TREE_CODE (newdecl) != TEMPLATE_DECL
1230 && TREE_CODE (olddecl) == TEMPLATE_DECL
1231 && check_raw_literal_operator (newdecl))
1232 error ("raw literal operator %q+D conflicts with"
1233 " literal operator template %qD", newdecl, olddecl);
1236 if (DECL_P (olddecl)
1237 && TREE_CODE (newdecl) == FUNCTION_DECL
1238 && TREE_CODE (olddecl) == FUNCTION_DECL
1239 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1241 if (DECL_DECLARED_INLINE_P (newdecl)
1242 && DECL_UNINLINABLE (newdecl)
1243 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1244 /* Already warned elsewhere. */;
1245 else if (DECL_DECLARED_INLINE_P (olddecl)
1246 && DECL_UNINLINABLE (olddecl)
1247 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1248 /* Already warned. */;
1249 else if (DECL_DECLARED_INLINE_P (newdecl)
1250 && DECL_UNINLINABLE (olddecl)
1251 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1253 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1255 warning (OPT_Wattributes, "previous declaration of %q+D "
1256 "with attribute noinline", olddecl);
1258 else if (DECL_DECLARED_INLINE_P (olddecl)
1259 && DECL_UNINLINABLE (newdecl)
1260 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1262 warning (OPT_Wattributes, "function %q+D redeclared with "
1263 "attribute noinline", newdecl);
1264 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1269 /* Check for redeclaration and other discrepancies. */
1270 if (TREE_CODE (olddecl) == FUNCTION_DECL
1271 && DECL_ARTIFICIAL (olddecl))
1273 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1274 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1276 /* Avoid warnings redeclaring built-ins which have not been
1277 explicitly declared. */
1278 if (DECL_ANTICIPATED (olddecl))
1281 /* If you declare a built-in or predefined function name as static,
1282 the old definition is overridden, but optionally warn this was a
1283 bad choice of name. */
1284 if (! TREE_PUBLIC (newdecl))
1286 warning (OPT_Wshadow,
1287 DECL_BUILT_IN (olddecl)
1288 ? G_("shadowing built-in function %q#D")
1289 : G_("shadowing library function %q#D"), olddecl);
1290 /* Discard the old built-in function. */
1293 /* If the built-in is not ansi, then programs can override
1294 it even globally without an error. */
1295 else if (! DECL_BUILT_IN (olddecl))
1296 warning (0, "library function %q#D redeclared as non-function %q#D",
1300 error ("declaration of %q#D", newdecl);
1301 error ("conflicts with built-in declaration %q#D",
1306 else if (!types_match)
1308 /* Avoid warnings redeclaring built-ins which have not been
1309 explicitly declared. */
1310 if (DECL_ANTICIPATED (olddecl))
1312 /* Deal with fileptr_type_node. FILE type is not known
1313 at the time we create the builtins. */
1316 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1317 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1319 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1322 else if (TREE_VALUE (t2) == fileptr_type_node)
1324 tree t = TREE_VALUE (t1);
1326 if (TREE_CODE (t) == POINTER_TYPE
1327 && TYPE_NAME (TREE_TYPE (t))
1328 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1329 == get_identifier ("FILE")
1330 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1332 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1334 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1335 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1336 types_match = decls_match (newdecl, olddecl);
1338 return duplicate_decls (newdecl, olddecl,
1340 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1343 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1346 else if ((DECL_EXTERN_C_P (newdecl)
1347 && DECL_EXTERN_C_P (olddecl))
1348 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1349 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1351 /* A near match; override the builtin. */
1353 if (TREE_PUBLIC (newdecl))
1355 warning (0, "new declaration %q#D", newdecl);
1356 warning (0, "ambiguates built-in declaration %q#D",
1360 warning (OPT_Wshadow,
1361 DECL_BUILT_IN (olddecl)
1362 ? G_("shadowing built-in function %q#D")
1363 : G_("shadowing library function %q#D"), olddecl);
1366 /* Discard the old built-in function. */
1369 /* Replace the old RTL to avoid problems with inlining. */
1370 COPY_DECL_RTL (newdecl, olddecl);
1372 /* Even if the types match, prefer the new declarations type for
1373 built-ins which have not been explicitly declared, for
1374 exception lists, etc... */
1375 else if (DECL_IS_BUILTIN (olddecl))
1377 tree type = TREE_TYPE (newdecl);
1378 tree attribs = (*targetm.merge_type_attributes)
1379 (TREE_TYPE (olddecl), type);
1381 type = cp_build_type_attribute_variant (type, attribs);
1382 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1385 /* If a function is explicitly declared "throw ()", propagate that to
1386 the corresponding builtin. */
1387 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1388 && DECL_ANTICIPATED (olddecl)
1389 && TREE_NOTHROW (newdecl)
1390 && !TREE_NOTHROW (olddecl))
1392 enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl);
1393 tree tmpdecl = builtin_decl_explicit (fncode);
1394 if (tmpdecl && tmpdecl != olddecl && types_match)
1395 TREE_NOTHROW (tmpdecl) = 1;
1398 /* Whether or not the builtin can throw exceptions has no
1399 bearing on this declarator. */
1400 TREE_NOTHROW (olddecl) = 0;
1402 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1404 /* If a builtin function is redeclared as `static', merge
1405 the declarations, but make the original one static. */
1406 DECL_THIS_STATIC (olddecl) = 1;
1407 TREE_PUBLIC (olddecl) = 0;
1409 /* Make the old declaration consistent with the new one so
1410 that all remnants of the builtin-ness of this function
1411 will be banished. */
1412 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1413 COPY_DECL_RTL (newdecl, olddecl);
1416 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1418 /* C++ Standard, 3.3, clause 4:
1419 "[Note: a namespace name or a class template name must be unique
1420 in its declarative region (7.3.2, clause 14). ]" */
1421 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1422 && TREE_CODE (newdecl) != NAMESPACE_DECL
1423 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1424 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1425 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1426 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1428 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1429 && TREE_CODE (newdecl) != TYPE_DECL)
1430 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1431 && TREE_CODE (olddecl) != TYPE_DECL))
1433 /* We do nothing special here, because C++ does such nasty
1434 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1435 get shadowed, and know that if we need to find a TYPE_DECL
1436 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1437 slot of the identifier. */
1441 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1442 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1443 || (TREE_CODE (olddecl) == FUNCTION_DECL
1444 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1448 error ("%q#D redeclared as different kind of symbol", newdecl);
1449 if (TREE_CODE (olddecl) == TREE_LIST)
1450 olddecl = TREE_VALUE (olddecl);
1451 error ("previous declaration of %q+#D", olddecl);
1453 return error_mark_node;
1455 else if (!types_match)
1457 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1458 /* These are certainly not duplicate declarations; they're
1459 from different scopes. */
1462 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1464 /* The name of a class template may not be declared to refer to
1465 any other template, class, function, object, namespace, value,
1466 or type in the same scope. */
1467 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1468 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1470 error ("declaration of template %q#D", newdecl);
1471 error ("conflicts with previous declaration %q+#D", olddecl);
1472 return error_mark_node;
1474 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1475 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1476 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1477 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1478 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1479 DECL_TEMPLATE_PARMS (olddecl))
1480 /* Template functions can be disambiguated by
1482 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1483 TREE_TYPE (TREE_TYPE (olddecl))))
1485 error ("new declaration %q#D", newdecl);
1486 error ("ambiguates old declaration %q+#D", olddecl);
1490 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1492 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1494 error ("declaration of C function %q#D conflicts with",
1496 error ("previous declaration %q+#D here", olddecl);
1499 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1500 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1502 error ("new declaration %q#D", newdecl);
1503 if (FNDECL_USED_AUTO (olddecl))
1504 error_at (DECL_SOURCE_LOCATION (olddecl), "ambiguates old "
1505 "declaration with deduced return type");
1507 error ("ambiguates old declaration %q+#D", olddecl);
1508 return error_mark_node;
1515 error ("conflicting declaration %q#D", newdecl);
1516 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1517 return error_mark_node;
1520 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1521 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1522 && (!DECL_TEMPLATE_INFO (newdecl)
1523 || (DECL_TI_TEMPLATE (newdecl)
1524 != DECL_TI_TEMPLATE (olddecl))))
1525 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1526 && (!DECL_TEMPLATE_INFO (olddecl)
1527 || (DECL_TI_TEMPLATE (olddecl)
1528 != DECL_TI_TEMPLATE (newdecl))))))
1529 /* It's OK to have a template specialization and a non-template
1530 with the same type, or to have specializations of two
1531 different templates with the same type. Note that if one is a
1532 specialization, and the other is an instantiation of the same
1533 template, that we do not exit at this point. That situation
1534 can occur if we instantiate a template class, and then
1535 specialize one of its methods. This situation is valid, but
1536 the declarations must be merged in the usual way. */
1538 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1539 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1540 && !DECL_USE_TEMPLATE (newdecl))
1541 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1542 && !DECL_USE_TEMPLATE (olddecl))))
1543 /* One of the declarations is a template instantiation, and the
1544 other is not a template at all. That's OK. */
1546 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1548 /* In [namespace.alias] we have:
1550 In a declarative region, a namespace-alias-definition can be
1551 used to redefine a namespace-alias declared in that declarative
1552 region to refer only to the namespace to which it already
1555 Therefore, if we encounter a second alias directive for the same
1556 alias, we can just ignore the second directive. */
1557 if (DECL_NAMESPACE_ALIAS (newdecl)
1558 && (DECL_NAMESPACE_ALIAS (newdecl)
1559 == DECL_NAMESPACE_ALIAS (olddecl)))
1561 /* [namespace.alias]
1563 A namespace-name or namespace-alias shall not be declared as
1564 the name of any other entity in the same declarative region.
1565 A namespace-name defined at global scope shall not be
1566 declared as the name of any other entity in any global scope
1568 error ("declaration of namespace %qD conflicts with", newdecl);
1569 error ("previous declaration of namespace %q+D here", olddecl);
1570 return error_mark_node;
1574 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1577 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1578 if (DECL_NAME (olddecl) != NULL_TREE)
1579 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1580 ? G_("%q+#D previously defined here")
1581 : G_("%q+#D previously declared here"), olddecl);
1582 return error_mark_node;
1584 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1585 && DECL_INITIAL (olddecl) != NULL_TREE
1586 && !prototype_p (TREE_TYPE (olddecl))
1587 && prototype_p (TREE_TYPE (newdecl)))
1589 /* Prototype decl follows defn w/o prototype. */
1590 warning_at (input_location, 0, "prototype for %q+#D", newdecl);
1591 warning_at (DECL_SOURCE_LOCATION (olddecl), 0,
1592 "follows non-prototype definition here");
1594 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1595 || TREE_CODE (olddecl) == VAR_DECL)
1596 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1599 If two declarations of the same function or object
1600 specify different linkage-specifications ..., the program
1601 is ill-formed.... Except for functions with C++ linkage,
1602 a function declaration without a linkage specification
1603 shall not precede the first linkage specification for
1604 that function. A function can be declared without a
1605 linkage specification after an explicit linkage
1606 specification has been seen; the linkage explicitly
1607 specified in the earlier declaration is not affected by
1608 such a function declaration.
1610 DR 563 raises the question why the restrictions on
1611 functions should not also apply to objects. Older
1612 versions of G++ silently ignore the linkage-specification
1620 which is clearly wrong. Therefore, we now treat objects
1622 if (current_lang_depth () == 0)
1624 /* There is no explicit linkage-specification, so we use
1625 the linkage from the previous declaration. */
1626 if (!DECL_LANG_SPECIFIC (newdecl))
1627 retrofit_lang_decl (newdecl);
1628 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1632 error ("previous declaration of %q+#D with %qL linkage",
1633 olddecl, DECL_LANGUAGE (olddecl));
1634 error ("conflicts with new declaration with %qL linkage",
1635 DECL_LANGUAGE (newdecl));
1639 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1641 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1643 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1644 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1647 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1648 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1650 for (; t1 && t1 != void_list_node;
1651 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1652 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1654 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1657 permerror (input_location, "default argument given for parameter %d of %q#D",
1659 permerror (input_location, "after previous specification in %q+#D", olddecl);
1663 error ("default argument given for parameter %d of %q#D",
1665 error ("after previous specification in %q+#D",
1672 /* Do not merge an implicit typedef with an explicit one. In:
1676 typedef class A A __attribute__ ((foo));
1678 the attribute should apply only to the typedef. */
1679 if (TREE_CODE (olddecl) == TYPE_DECL
1680 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1681 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1684 /* If new decl is `static' and an `extern' was seen previously,
1686 warn_extern_redeclared_static (newdecl, olddecl);
1688 if (!validate_constexpr_redeclaration (olddecl, newdecl))
1689 return error_mark_node;
1691 /* We have committed to returning 1 at this point. */
1692 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1694 /* Now that functions must hold information normally held
1695 by field decls, there is extra work to do so that
1696 declaration information does not get destroyed during
1698 if (DECL_VINDEX (olddecl))
1699 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1700 if (DECL_CONTEXT (olddecl))
1701 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1702 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1703 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1704 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1705 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1706 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1707 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1708 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1709 SET_OVERLOADED_OPERATOR_CODE
1710 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1711 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1713 /* Optionally warn about more than one declaration for the same
1714 name, but don't warn about a function declaration followed by a
1716 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1717 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1718 /* Don't warn about extern decl followed by definition. */
1719 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1720 /* Don't warn about friends, let add_friend take care of it. */
1721 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
1722 /* Don't warn about declaration followed by specialization. */
1723 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
1724 || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
1726 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1727 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1730 if (DECL_DELETED_FN (newdecl))
1732 error ("deleted definition of %qD", newdecl);
1733 error ("after previous declaration %q+D", olddecl);
1735 DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl);
1738 /* Deal with C++: must preserve virtual function table size. */
1739 if (TREE_CODE (olddecl) == TYPE_DECL)
1741 tree newtype = TREE_TYPE (newdecl);
1742 tree oldtype = TREE_TYPE (olddecl);
1744 if (newtype != error_mark_node && oldtype != error_mark_node
1745 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1746 CLASSTYPE_FRIEND_CLASSES (newtype)
1747 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1749 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1752 /* Copy all the DECL_... slots specified in the new decl
1753 except for any that we copy here from the old type. */
1754 DECL_ATTRIBUTES (newdecl)
1755 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1757 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1761 old_result = DECL_TEMPLATE_RESULT (olddecl);
1762 new_result = DECL_TEMPLATE_RESULT (newdecl);
1763 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1764 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1765 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1766 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1768 DECL_ATTRIBUTES (old_result)
1769 = (*targetm.merge_decl_attributes) (old_result, new_result);
1771 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1773 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1774 && DECL_INITIAL (new_result))
1776 if (DECL_INITIAL (old_result))
1777 DECL_UNINLINABLE (old_result) = 1;
1779 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1780 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1781 DECL_NOT_REALLY_EXTERN (old_result)
1782 = DECL_NOT_REALLY_EXTERN (new_result);
1783 DECL_INTERFACE_KNOWN (old_result)
1784 = DECL_INTERFACE_KNOWN (new_result);
1785 DECL_DECLARED_INLINE_P (old_result)
1786 = DECL_DECLARED_INLINE_P (new_result);
1787 DECL_DISREGARD_INLINE_LIMITS (old_result)
1788 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1793 DECL_DECLARED_INLINE_P (old_result)
1794 |= DECL_DECLARED_INLINE_P (new_result);
1795 DECL_DISREGARD_INLINE_LIMITS (old_result)
1796 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1797 check_redeclaration_exception_specification (newdecl, olddecl);
1801 /* If the new declaration is a definition, update the file and
1802 line information on the declaration, and also make
1803 the old declaration the same definition. */
1804 if (DECL_INITIAL (new_result) != NULL_TREE)
1806 DECL_SOURCE_LOCATION (olddecl)
1807 = DECL_SOURCE_LOCATION (old_result)
1808 = DECL_SOURCE_LOCATION (newdecl);
1809 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1810 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1813 DECL_ARGUMENTS (old_result)
1814 = DECL_ARGUMENTS (new_result);
1815 for (parm = DECL_ARGUMENTS (old_result); parm;
1816 parm = DECL_CHAIN (parm))
1817 DECL_CONTEXT (parm) = old_result;
1826 /* Automatically handles default parameters. */
1827 tree oldtype = TREE_TYPE (olddecl);
1830 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1831 maybe_instantiate_noexcept (olddecl);
1833 /* Merge the data types specified in the two decls. */
1834 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1836 /* If merge_types produces a non-typedef type, just use the old type. */
1837 if (TREE_CODE (newdecl) == TYPE_DECL
1838 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1841 if (TREE_CODE (newdecl) == VAR_DECL)
1843 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1844 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1845 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1846 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1847 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1848 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1850 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1851 if (DECL_LANG_SPECIFIC (olddecl)
1852 && CP_DECL_THREADPRIVATE_P (olddecl))
1854 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1855 if (!DECL_LANG_SPECIFIC (newdecl))
1856 retrofit_lang_decl (newdecl);
1858 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1859 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1863 /* Do this after calling `merge_types' so that default
1864 parameters don't confuse us. */
1865 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1866 check_redeclaration_exception_specification (newdecl, olddecl);
1867 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1869 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1870 check_default_args (newdecl);
1872 /* Lay the type out, unless already done. */
1873 if (! same_type_p (newtype, oldtype)
1874 && TREE_TYPE (newdecl) != error_mark_node
1875 && !(processing_template_decl && uses_template_parms (newdecl)))
1876 layout_type (TREE_TYPE (newdecl));
1878 if ((TREE_CODE (newdecl) == VAR_DECL
1879 || TREE_CODE (newdecl) == PARM_DECL
1880 || TREE_CODE (newdecl) == RESULT_DECL
1881 || TREE_CODE (newdecl) == FIELD_DECL
1882 || TREE_CODE (newdecl) == TYPE_DECL)
1883 && !(processing_template_decl && uses_template_parms (newdecl)))
1884 layout_decl (newdecl, 0);
1886 /* Merge the type qualifiers. */
1887 if (TREE_READONLY (newdecl))
1888 TREE_READONLY (olddecl) = 1;
1889 if (TREE_THIS_VOLATILE (newdecl))
1890 TREE_THIS_VOLATILE (olddecl) = 1;
1891 if (TREE_NOTHROW (newdecl))
1892 TREE_NOTHROW (olddecl) = 1;
1894 /* Merge deprecatedness. */
1895 if (TREE_DEPRECATED (newdecl))
1896 TREE_DEPRECATED (olddecl) = 1;
1898 /* Preserve function specific target and optimization options */
1899 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1901 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1902 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1903 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1904 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1906 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1907 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1908 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1909 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1912 /* Merge the initialization information. */
1913 if (DECL_INITIAL (newdecl) == NULL_TREE
1914 && DECL_INITIAL (olddecl) != NULL_TREE)
1916 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1917 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1918 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1920 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1921 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1925 /* Merge the section attribute.
1926 We want to issue an error if the sections conflict but that must be
1927 done later in decl_attributes since we are called before attributes
1929 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1930 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1932 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1934 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1935 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1936 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1937 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1938 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1939 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1940 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1941 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1942 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1943 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1944 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1945 /* Keep the old RTL. */
1946 COPY_DECL_RTL (olddecl, newdecl);
1948 else if (TREE_CODE (newdecl) == VAR_DECL
1949 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1951 /* Keep the old RTL. We cannot keep the old RTL if the old
1952 declaration was for an incomplete object and the new
1953 declaration is not since many attributes of the RTL will
1955 COPY_DECL_RTL (olddecl, newdecl);
1958 /* If cannot merge, then use the new type and qualifiers,
1959 and don't preserve the old rtl. */
1962 /* Clean out any memory we had of the old declaration. */
1963 tree oldstatic = value_member (olddecl, static_aggregates);
1965 TREE_VALUE (oldstatic) = error_mark_node;
1967 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1968 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1969 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1970 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1973 /* Merge the storage class information. */
1974 merge_weak (newdecl, olddecl);
1976 if (DECL_ONE_ONLY (olddecl))
1977 DECL_COMDAT_GROUP (newdecl) = DECL_COMDAT_GROUP (olddecl);
1979 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1980 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1981 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1982 if (! DECL_EXTERNAL (olddecl))
1983 DECL_EXTERNAL (newdecl) = 0;
1985 new_template_info = NULL_TREE;
1986 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1988 bool new_redefines_gnu_inline = false;
1990 if (new_defines_function
1991 && ((DECL_INTERFACE_KNOWN (olddecl)
1992 && TREE_CODE (olddecl) == FUNCTION_DECL)
1993 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1994 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1995 == FUNCTION_DECL))))
1999 if (TREE_CODE (fn) == TEMPLATE_DECL)
2000 fn = DECL_TEMPLATE_RESULT (olddecl);
2002 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
2005 if (!new_redefines_gnu_inline)
2007 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
2008 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
2009 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
2011 DECL_TEMPLATE_INSTANTIATED (newdecl)
2012 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
2013 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
2015 /* If the OLDDECL is an instantiation and/or specialization,
2016 then the NEWDECL must be too. But, it may not yet be marked
2017 as such if the caller has created NEWDECL, but has not yet
2018 figured out that it is a redeclaration. */
2019 if (!DECL_USE_TEMPLATE (newdecl))
2020 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
2022 /* Don't really know how much of the language-specific
2023 values we should copy from old to new. */
2024 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2025 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
2026 DECL_INITIALIZED_IN_CLASS_P (newdecl)
2027 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
2029 if (LANG_DECL_HAS_MIN (newdecl))
2031 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
2032 DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
2033 if (DECL_TEMPLATE_INFO (newdecl))
2034 new_template_info = DECL_TEMPLATE_INFO (newdecl);
2035 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2037 /* Only functions have these fields. */
2038 if (TREE_CODE (newdecl) == FUNCTION_DECL
2039 || DECL_FUNCTION_TEMPLATE_P (newdecl))
2041 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
2042 olddecl_friend = DECL_FRIEND_P (olddecl);
2043 hidden_friend = (DECL_ANTICIPATED (olddecl)
2044 && DECL_HIDDEN_FRIEND_P (olddecl)
2045 && newdecl_is_friend);
2046 DECL_BEFRIENDING_CLASSES (newdecl)
2047 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
2048 DECL_BEFRIENDING_CLASSES (olddecl));
2049 /* DECL_THUNKS is only valid for virtual functions,
2050 otherwise it is a DECL_FRIEND_CONTEXT. */
2051 if (DECL_VIRTUAL_P (newdecl))
2052 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
2054 /* Only variables have this field. */
2055 else if (TREE_CODE (newdecl) == VAR_DECL
2056 && VAR_HAD_UNKNOWN_BOUND (olddecl))
2057 SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
2060 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2064 /* Merge parameter attributes. */
2065 tree oldarg, newarg;
2066 for (oldarg = DECL_ARGUMENTS(olddecl),
2067 newarg = DECL_ARGUMENTS(newdecl);
2069 oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) {
2070 DECL_ATTRIBUTES (newarg)
2071 = (*targetm.merge_decl_attributes) (oldarg, newarg);
2072 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
2075 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2076 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
2078 /* If newdecl is not a specialization, then it is not a
2079 template-related function at all. And that means that we
2080 should have exited above, returning 0. */
2081 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
2083 if (DECL_ODR_USED (olddecl))
2084 /* From [temp.expl.spec]:
2086 If a template, a member template or the member of a class
2087 template is explicitly specialized then that
2088 specialization shall be declared before the first use of
2089 that specialization that would cause an implicit
2090 instantiation to take place, in every translation unit in
2091 which such a use occurs. */
2092 error ("explicit specialization of %qD after first use",
2095 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
2097 /* Don't propagate visibility from the template to the
2098 specialization here. We'll do that in determine_visibility if
2100 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
2102 /* [temp.expl.spec/14] We don't inline explicit specialization
2103 just because the primary template says so. */
2105 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2106 the always_inline attribute. */
2107 if (DECL_DISREGARD_INLINE_LIMITS (olddecl)
2108 && !DECL_DISREGARD_INLINE_LIMITS (newdecl))
2110 if (DECL_DECLARED_INLINE_P (newdecl))
2111 DECL_DISREGARD_INLINE_LIMITS (newdecl) = true;
2113 DECL_ATTRIBUTES (newdecl)
2114 = remove_attribute ("always_inline",
2115 DECL_ATTRIBUTES (newdecl));
2118 else if (new_defines_function && DECL_INITIAL (olddecl))
2120 /* Never inline re-defined extern inline functions.
2121 FIXME: this could be better handled by keeping both
2122 function as separate declarations. */
2123 DECL_UNINLINABLE (newdecl) = 1;
2127 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
2128 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2130 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
2132 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2133 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2135 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2136 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2137 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2138 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2141 /* Preserve abstractness on cloned [cd]tors. */
2142 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
2144 /* Update newdecl's parms to point at olddecl. */
2145 for (parm = DECL_ARGUMENTS (newdecl); parm;
2146 parm = DECL_CHAIN (parm))
2147 DECL_CONTEXT (parm) = olddecl;
2151 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2152 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2153 COPY_DECL_RTL (newdecl, olddecl);
2155 if (! types_match || new_defines_function)
2157 /* These need to be copied so that the names are available.
2158 Note that if the types do match, we'll preserve inline
2159 info and other bits, but if not, we won't. */
2160 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2161 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2163 if (new_defines_function)
2164 /* If defining a function declared with other language
2165 linkage, use the previously declared language linkage. */
2166 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2167 else if (types_match)
2169 /* If redeclaring a builtin function, and not a definition,
2170 it stays built in. */
2171 if (DECL_BUILT_IN (olddecl))
2173 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2174 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2175 /* If we're keeping the built-in definition, keep the rtl,
2176 regardless of declaration matches. */
2177 COPY_DECL_RTL (olddecl, newdecl);
2178 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2180 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2183 /* If a compatible prototype of these builtin functions
2184 is seen, assume the runtime implements it with the
2185 expected semantics. */
2186 case BUILT_IN_STPCPY:
2187 if (builtin_decl_explicit_p (fncode))
2188 set_builtin_decl_implicit_p (fncode, true);
2196 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2197 /* Don't clear out the arguments if we're just redeclaring a
2199 if (DECL_ARGUMENTS (olddecl))
2200 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2203 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2204 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2206 /* Now preserve various other info from the definition. */
2207 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2208 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2209 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2210 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2212 /* Warn about conflicting visibility specifications. */
2213 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2214 && DECL_VISIBILITY_SPECIFIED (newdecl)
2215 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2217 warning_at (input_location, OPT_Wattributes,
2218 "%q+D: visibility attribute ignored because it", newdecl);
2219 warning_at (DECL_SOURCE_LOCATION (olddecl), OPT_Wattributes,
2220 "conflicts with previous declaration here");
2222 /* Choose the declaration which specified visibility. */
2223 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2225 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2226 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2228 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2229 so keep this behavior. */
2230 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2232 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2233 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2235 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2236 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2238 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2239 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2241 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2242 if (TREE_CODE (newdecl) == FIELD_DECL)
2243 DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
2245 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2246 with that from NEWDECL below. */
2247 if (DECL_LANG_SPECIFIC (olddecl))
2249 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2250 != DECL_LANG_SPECIFIC (newdecl));
2251 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2254 /* Merge the USED information. */
2255 if (TREE_USED (olddecl))
2256 TREE_USED (newdecl) = 1;
2257 else if (TREE_USED (newdecl))
2258 TREE_USED (olddecl) = 1;
2259 if (TREE_CODE (newdecl) == VAR_DECL)
2261 if (DECL_READ_P (olddecl))
2262 DECL_READ_P (newdecl) = 1;
2263 else if (DECL_READ_P (newdecl))
2264 DECL_READ_P (olddecl) = 1;
2266 if (DECL_PRESERVE_P (olddecl))
2267 DECL_PRESERVE_P (newdecl) = 1;
2268 else if (DECL_PRESERVE_P (newdecl))
2269 DECL_PRESERVE_P (olddecl) = 1;
2271 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2275 function_size = sizeof (struct tree_decl_common);
2277 memcpy ((char *) olddecl + sizeof (struct tree_common),
2278 (char *) newdecl + sizeof (struct tree_common),
2279 function_size - sizeof (struct tree_common));
2281 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2282 (char *) newdecl + sizeof (struct tree_decl_common),
2283 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2284 if (new_template_info)
2285 /* If newdecl is a template instantiation, it is possible that
2286 the following sequence of events has occurred:
2288 o A friend function was declared in a class template. The
2289 class template was instantiated.
2291 o The instantiation of the friend declaration was
2292 recorded on the instantiation list, and is newdecl.
2294 o Later, however, instantiate_class_template called pushdecl
2295 on the newdecl to perform name injection. But, pushdecl in
2296 turn called duplicate_decls when it discovered that another
2297 declaration of a global function with the same name already
2300 o Here, in duplicate_decls, we decided to clobber newdecl.
2302 If we're going to do that, we'd better make sure that
2303 olddecl, and not newdecl, is on the list of
2304 instantiations so that if we try to do the instantiation
2305 again we won't get the clobbered declaration. */
2306 reregister_specialization (newdecl,
2312 size_t size = tree_code_size (TREE_CODE (olddecl));
2313 memcpy ((char *) olddecl + sizeof (struct tree_common),
2314 (char *) newdecl + sizeof (struct tree_common),
2315 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2316 switch (TREE_CODE (olddecl))
2326 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2327 (char *) newdecl + sizeof (struct tree_decl_common),
2328 size - sizeof (struct tree_decl_common)
2329 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2333 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2334 (char *) newdecl + sizeof (struct tree_decl_common),
2335 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2336 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2340 DECL_UID (olddecl) = olddecl_uid;
2342 DECL_FRIEND_P (olddecl) = 1;
2345 DECL_ANTICIPATED (olddecl) = 1;
2346 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2349 /* NEWDECL contains the merged attribute lists.
2350 Update OLDDECL to be the same. */
2351 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2353 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2354 so that encode_section_info has a chance to look at the new decl
2355 flags and attributes. */
2356 if (DECL_RTL_SET_P (olddecl)
2357 && (TREE_CODE (olddecl) == FUNCTION_DECL
2358 || (TREE_CODE (olddecl) == VAR_DECL
2359 && TREE_STATIC (olddecl))))
2360 make_decl_rtl (olddecl);
2362 /* The NEWDECL will no longer be needed. Because every out-of-class
2363 declaration of a member results in a call to duplicate_decls,
2364 freeing these nodes represents in a significant savings. */
2370 /* Return zero if the declaration NEWDECL is valid
2371 when the declaration OLDDECL (assumed to be for the same name)
2372 has already been seen.
2373 Otherwise return an error message format string with a %s
2374 where the identifier should go. */
2377 redeclaration_error_message (tree newdecl, tree olddecl)
2379 if (TREE_CODE (newdecl) == TYPE_DECL)
2381 /* Because C++ can put things into name space for free,
2382 constructs like "typedef struct foo { ... } foo"
2383 would look like an erroneous redeclaration. */
2384 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2387 return G_("redefinition of %q#D");
2389 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2391 /* If this is a pure function, its olddecl will actually be
2392 the original initialization to `0' (which we force to call
2393 abort()). Don't complain about redefinition in this case. */
2394 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2395 && DECL_INITIAL (olddecl) == NULL_TREE)
2398 /* If both functions come from different namespaces, this is not
2399 a redeclaration - this is a conflict with a used function. */
2400 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2401 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2402 && ! decls_match (olddecl, newdecl))
2403 return G_("%qD conflicts with used function");
2405 /* We'll complain about linkage mismatches in
2406 warn_extern_redeclared_static. */
2408 /* Defining the same name twice is no good. */
2409 if (DECL_INITIAL (olddecl) != NULL_TREE
2410 && DECL_INITIAL (newdecl) != NULL_TREE)
2412 if (DECL_NAME (olddecl) == NULL_TREE)
2413 return G_("%q#D not declared in class");
2414 else if (!GNU_INLINE_P (olddecl)
2415 || GNU_INLINE_P (newdecl))
2416 return G_("redefinition of %q#D");
2419 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2421 bool olda = GNU_INLINE_P (olddecl);
2422 bool newa = GNU_INLINE_P (newdecl);
2427 return G_("%q+D redeclared inline with "
2428 "%<gnu_inline%> attribute");
2430 return G_("%q+D redeclared inline without "
2431 "%<gnu_inline%> attribute");
2437 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2441 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2443 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2444 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2445 return G_("redefinition of %q#D");
2449 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2450 || (DECL_TEMPLATE_RESULT (newdecl)
2451 == DECL_TEMPLATE_RESULT (olddecl)))
2454 nt = DECL_TEMPLATE_RESULT (newdecl);
2455 if (DECL_TEMPLATE_INFO (nt))
2456 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2457 ot = DECL_TEMPLATE_RESULT (olddecl);
2458 if (DECL_TEMPLATE_INFO (ot))
2459 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2460 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2461 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2462 return G_("redefinition of %q#D");
2464 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2466 bool olda = GNU_INLINE_P (ot);
2467 bool newa = GNU_INLINE_P (nt);
2472 return G_("%q+D redeclared inline with "
2473 "%<gnu_inline%> attribute");
2475 return G_("%q+D redeclared inline without "
2476 "%<gnu_inline%> attribute");
2480 /* Core issue #226 (C++0x):
2482 If a friend function template declaration specifies a
2483 default template-argument, that declaration shall be a
2484 definition and shall be the only declaration of the
2485 function template in the translation unit. */
2486 if ((cxx_dialect != cxx98)
2487 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2488 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2489 /*is_primary=*/true,
2490 /*is_partial=*/false,
2491 /*is_friend_decl=*/2))
2492 return G_("redeclaration of friend %q#D "
2493 "may not have default template arguments");
2497 else if (TREE_CODE (newdecl) == VAR_DECL
2498 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2499 && (! DECL_LANG_SPECIFIC (olddecl)
2500 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2501 || DECL_THREAD_LOCAL_P (newdecl)))
2503 /* Only variables can be thread-local, and all declarations must
2504 agree on this property. */
2505 if (DECL_THREAD_LOCAL_P (newdecl))
2506 return G_("thread-local declaration of %q#D follows "
2507 "non-thread-local declaration");
2509 return G_("non-thread-local declaration of %q#D follows "
2510 "thread-local declaration");
2512 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2514 /* The objects have been declared at namespace scope. If either
2515 is a member of an anonymous union, then this is an invalid
2516 redeclaration. For example:
2522 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2523 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2524 return G_("redeclaration of %q#D");
2525 /* If at least one declaration is a reference, there is no
2526 conflict. For example:
2532 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2534 /* Reject two definitions. */
2535 return G_("redefinition of %q#D");
2539 /* Objects declared with block scope: */
2540 /* Reject two definitions, and reject a definition
2541 together with an external reference. */
2542 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2543 return G_("redeclaration of %q#D");
2548 /* Hash and equality functions for the named_label table. */
2551 named_label_entry_hash (const void *data)
2553 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2554 return DECL_UID (ent->label_decl);
2558 named_label_entry_eq (const void *a, const void *b)
2560 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2561 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2562 return ent_a->label_decl == ent_b->label_decl;
2565 /* Create a new label, named ID. */
2568 make_label_decl (tree id, int local_p)
2570 struct named_label_entry *ent;
2574 decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2576 DECL_CONTEXT (decl) = current_function_decl;
2577 DECL_MODE (decl) = VOIDmode;
2578 C_DECLARED_LABEL_FLAG (decl) = local_p;
2580 /* Say where one reference is to the label, for the sake of the
2581 error if it is not defined. */
2582 DECL_SOURCE_LOCATION (decl) = input_location;
2584 /* Record the fact that this identifier is bound to this label. */
2585 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2587 /* Create the label htab for the function on demand. */
2589 named_labels = htab_create_ggc (13, named_label_entry_hash,
2590 named_label_entry_eq, NULL);
2592 /* Record this label on the list of labels used in this function.
2593 We do this before calling make_label_decl so that we get the
2594 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2595 ent = ggc_alloc_cleared_named_label_entry ();
2596 ent->label_decl = decl;
2598 slot = htab_find_slot (named_labels, ent, INSERT);
2599 gcc_assert (*slot == NULL);
2605 /* Look for a label named ID in the current function. If one cannot
2606 be found, create one. (We keep track of used, but undefined,
2607 labels, and complain about them at the end of a function.) */
2610 lookup_label_1 (tree id)
2614 /* You can't use labels at global scope. */
2615 if (current_function_decl == NULL_TREE)
2617 error ("label %qE referenced outside of any function", id);
2621 /* See if we've already got this label. */
2622 decl = IDENTIFIER_LABEL_VALUE (id);
2623 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2626 decl = make_label_decl (id, /*local_p=*/0);
2630 /* Wrapper for lookup_label_1. */
2633 lookup_label (tree id)
2636 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2637 ret = lookup_label_1 (id);
2638 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2642 /* Declare a local label named ID. */
2645 declare_local_label (tree id)
2648 cp_label_binding bind;
2650 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2651 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2652 bind.prev_value = IDENTIFIER_LABEL_VALUE (id);
2654 decl = make_label_decl (id, /*local_p=*/1);
2656 VEC_safe_push (cp_label_binding, gc, current_binding_level->shadowed_labels,
2662 /* Returns nonzero if it is ill-formed to jump past the declaration of
2663 DECL. Returns 2 if it's also a real problem. */
2666 decl_jump_unsafe (tree decl)
2668 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2669 with automatic storage duration is not in scope to a point where it is
2670 in scope is ill-formed unless the variable has scalar type, class type
2671 with a trivial default constructor and a trivial destructor, a
2672 cv-qualified version of one of these types, or an array of one of the
2673 preceding types and is declared without an initializer (8.5). */
2674 tree type = TREE_TYPE (decl);
2676 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2677 || type == error_mark_node)
2680 type = strip_array_types (type);
2682 if (type_has_nontrivial_default_init (TREE_TYPE (decl))
2683 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2686 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2692 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2695 identify_goto (tree decl, const location_t *locus)
2698 permerror (input_location, "jump to label %qD", decl);
2700 permerror (input_location, "jump to case label");
2702 permerror (*locus, " from here");
2705 /* Check that a single previously seen jump to a newly defined label
2706 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2707 the jump context; NAMES are the names in scope in LEVEL at the jump
2708 context; LOCUS is the source position of the jump or 0. Returns
2709 true if all is well. */
2712 check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
2713 bool exited_omp, const location_t *locus)
2715 cp_binding_level *b;
2716 bool identified = false, saw_eh = false, saw_omp = false;
2720 identify_goto (decl, locus);
2721 error (" exits OpenMP structured block");
2722 identified = saw_omp = true;
2725 for (b = current_binding_level; b ; b = b->level_chain)
2727 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2729 for (new_decls = b->names; new_decls != old_decls;
2730 new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls)
2731 : TREE_CHAIN (new_decls)))
2733 int problem = decl_jump_unsafe (new_decls);
2739 identify_goto (decl, locus);
2743 error (" crosses initialization of %q+#D", new_decls);
2745 permerror (input_location, " enters scope of %q+#D which has "
2746 "non-trivial destructor", new_decls);
2751 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2755 identify_goto (decl, locus);
2758 if (b->kind == sk_try)
2759 error (" enters try block");
2761 error (" enters catch block");
2764 if (b->kind == sk_omp && !saw_omp)
2768 identify_goto (decl, locus);
2771 error (" enters OpenMP structured block");
2780 check_previous_goto (tree decl, struct named_label_use_entry *use)
2782 check_previous_goto_1 (decl, use->binding_level,
2783 use->names_in_scope, use->in_omp_scope,
2784 &use->o_goto_locus);
2788 check_switch_goto (cp_binding_level* level)
2790 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2793 /* Check that a new jump to a label DECL is OK. Called by
2794 finish_goto_stmt. */
2797 check_goto (tree decl)
2799 struct named_label_entry *ent, dummy;
2800 bool saw_catch = false, identified = false;
2804 /* We can't know where a computed goto is jumping.
2805 So we assume that it's OK. */
2806 if (TREE_CODE (decl) != LABEL_DECL)
2809 /* We didn't record any information about this label when we created it,
2810 and there's not much point since it's trivial to analyze as a return. */
2811 if (decl == cdtor_label)
2814 dummy.label_decl = decl;
2815 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2816 gcc_assert (ent != NULL);
2818 /* If the label hasn't been defined yet, defer checking. */
2819 if (! DECL_INITIAL (decl))
2821 struct named_label_use_entry *new_use;
2823 /* Don't bother creating another use if the last goto had the
2824 same data, and will therefore create the same set of errors. */
2826 && ent->uses->names_in_scope == current_binding_level->names)
2829 new_use = ggc_alloc_named_label_use_entry ();
2830 new_use->binding_level = current_binding_level;
2831 new_use->names_in_scope = current_binding_level->names;
2832 new_use->o_goto_locus = input_location;
2833 new_use->in_omp_scope = false;
2835 new_use->next = ent->uses;
2836 ent->uses = new_use;
2840 if (ent->in_try_scope || ent->in_catch_scope
2841 || ent->in_omp_scope || !VEC_empty (tree, ent->bad_decls))
2843 permerror (input_location, "jump to label %q+D", decl);
2844 permerror (input_location, " from here");
2848 FOR_EACH_VEC_ELT (tree, ent->bad_decls, ix, bad)
2850 int u = decl_jump_unsafe (bad);
2852 if (u > 1 && DECL_ARTIFICIAL (bad))
2854 /* Can't skip init of __exception_info. */
2855 error_at (DECL_SOURCE_LOCATION (bad), " enters catch block");
2859 error (" skips initialization of %q+#D", bad);
2861 permerror (input_location, " enters scope of %q+#D which has "
2862 "non-trivial destructor", bad);
2865 if (ent->in_try_scope)
2866 error (" enters try block");
2867 else if (ent->in_catch_scope && !saw_catch)
2868 error (" enters catch block");
2870 if (ent->in_omp_scope)
2871 error (" enters OpenMP structured block");
2872 else if (flag_openmp)
2874 cp_binding_level *b;
2875 for (b = current_binding_level; b ; b = b->level_chain)
2877 if (b == ent->binding_level)
2879 if (b->kind == sk_omp)
2883 permerror (input_location, "jump to label %q+D", decl);
2884 permerror (input_location, " from here");
2887 error (" exits OpenMP structured block");
2894 /* Check that a return is ok wrt OpenMP structured blocks.
2895 Called by finish_return_stmt. Returns true if all is well. */
2898 check_omp_return (void)
2900 cp_binding_level *b;
2901 for (b = current_binding_level; b ; b = b->level_chain)
2902 if (b->kind == sk_omp)
2904 error ("invalid exit from OpenMP structured block");
2907 else if (b->kind == sk_function_parms)
2912 /* Define a label, specifying the location in the source file.
2913 Return the LABEL_DECL node for the label. */
2916 define_label_1 (location_t location, tree name)
2918 struct named_label_entry *ent, dummy;
2919 cp_binding_level *p;
2922 decl = lookup_label (name);
2924 dummy.label_decl = decl;
2925 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2926 gcc_assert (ent != NULL);
2928 /* After labels, make any new cleanups in the function go into their
2929 own new (temporary) binding contour. */
2930 for (p = current_binding_level;
2931 p->kind != sk_function_parms;
2933 p->more_cleanups_ok = 0;
2935 if (name == get_identifier ("wchar_t"))
2936 permerror (input_location, "label named wchar_t");
2938 if (DECL_INITIAL (decl) != NULL_TREE)
2940 error ("duplicate label %qD", decl);
2941 return error_mark_node;
2945 struct named_label_use_entry *use;
2947 /* Mark label as having been defined. */
2948 DECL_INITIAL (decl) = error_mark_node;
2949 /* Say where in the source. */
2950 DECL_SOURCE_LOCATION (decl) = location;
2952 ent->binding_level = current_binding_level;
2953 ent->names_in_scope = current_binding_level->names;
2955 for (use = ent->uses; use ; use = use->next)
2956 check_previous_goto (decl, use);
2963 /* Wrapper for define_label_1. */
2966 define_label (location_t location, tree name)
2969 bool running = timevar_cond_start (TV_NAME_LOOKUP);
2970 ret = define_label_1 (location, name);
2971 timevar_cond_stop (TV_NAME_LOOKUP, running);
2978 cp_binding_level *level;
2979 struct cp_switch *next;
2980 /* The SWITCH_STMT being built. */
2982 /* A splay-tree mapping the low element of a case range to the high
2983 element, or NULL_TREE if there is no high element. Used to
2984 determine whether or not a new case label duplicates an old case
2985 label. We need a tree, rather than simply a hash table, because
2986 of the GNU case range extension. */
2990 /* A stack of the currently active switch statements. The innermost
2991 switch statement is on the top of the stack. There is no need to
2992 mark the stack for garbage collection because it is only active
2993 during the processing of the body of a function, and we never
2994 collect at that point. */
2996 static struct cp_switch *switch_stack;
2998 /* Called right after a switch-statement condition is parsed.
2999 SWITCH_STMT is the switch statement being parsed. */
3002 push_switch (tree switch_stmt)
3004 struct cp_switch *p = XNEW (struct cp_switch);
3005 p->level = current_binding_level;
3006 p->next = switch_stack;
3007 p->switch_stmt = switch_stmt;
3008 p->cases = splay_tree_new (case_compare, NULL, NULL);
3015 struct cp_switch *cs = switch_stack;
3016 location_t switch_location;
3018 /* Emit warnings as needed. */
3019 switch_location = EXPR_LOC_OR_HERE (cs->switch_stmt);
3020 if (!processing_template_decl)
3021 c_do_switch_warnings (cs->cases, switch_location,
3022 SWITCH_STMT_TYPE (cs->switch_stmt),
3023 SWITCH_STMT_COND (cs->switch_stmt));
3025 splay_tree_delete (cs->cases);
3026 switch_stack = switch_stack->next;
3030 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3031 condition. Note that if TYPE and VALUE are already integral we don't
3032 really do the conversion because the language-independent
3033 warning/optimization code will work better that way. */
3036 case_conversion (tree type, tree value)
3038 if (value == NULL_TREE)
3041 if (cxx_dialect >= cxx0x
3042 && (SCOPED_ENUM_P (type)
3043 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
3045 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
3046 type = type_promotes_to (type);
3047 value = perform_implicit_conversion (type, value, tf_warning_or_error);
3049 return cxx_constant_value (value);
3052 /* Note that we've seen a definition of a case label, and complain if this
3053 is a bad place for one. */
3056 finish_case_label (location_t loc, tree low_value, tree high_value)
3059 cp_binding_level *p;
3062 if (processing_template_decl)
3066 /* For templates, just add the case label; we'll do semantic
3067 analysis at instantiation-time. */
3068 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
3069 return add_stmt (build_case_label (low_value, high_value, label));
3072 /* Find the condition on which this switch statement depends. */
3073 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
3074 if (cond && TREE_CODE (cond) == TREE_LIST)
3075 cond = TREE_VALUE (cond);
3077 if (!check_switch_goto (switch_stack->level))
3078 return error_mark_node;
3080 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt);
3082 low_value = case_conversion (type, low_value);
3083 high_value = case_conversion (type, high_value);
3085 r = c_add_case_label (loc, switch_stack->cases, cond, type,
3086 low_value, high_value);
3088 /* After labels, make any new cleanups in the function go into their
3089 own new (temporary) binding contour. */
3090 for (p = current_binding_level;
3091 p->kind != sk_function_parms;
3093 p->more_cleanups_ok = 0;
3098 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3101 typename_hash (const void* k)
3104 const_tree const t = (const_tree) k;
3106 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
3107 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
3112 typedef struct typename_info {
3120 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3121 really of type `typename_info*' */
3124 typename_compare (const void * k1, const void * k2)
3126 const_tree const t1 = (const_tree) k1;
3127 const typename_info *const t2 = (const typename_info *) k2;
3129 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
3130 && TYPE_CONTEXT (t1) == t2->scope
3131 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
3132 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
3133 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
3136 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3137 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3139 Returns the new TYPENAME_TYPE. */
3141 static GTY ((param_is (union tree_node))) htab_t typename_htab;
3144 build_typename_type (tree context, tree name, tree fullname,
3145 enum tag_types tag_type)
3153 if (typename_htab == NULL)
3154 typename_htab = htab_create_ggc (61, &typename_hash,
3155 &typename_compare, NULL);
3157 ti.scope = FROB_CONTEXT (context);
3159 ti.template_id = fullname;
3160 ti.enum_p = tag_type == enum_type;
3161 ti.class_p = (tag_type == class_type
3162 || tag_type == record_type
3163 || tag_type == union_type);
3164 hash = (htab_hash_pointer (ti.scope)
3165 ^ htab_hash_pointer (ti.name));
3167 /* See if we already have this type. */
3168 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
3173 /* Build the TYPENAME_TYPE. */
3174 t = cxx_make_type (TYPENAME_TYPE);
3175 TYPE_CONTEXT (t) = ti.scope;
3176 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
3177 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
3178 TYPENAME_IS_CLASS_P (t) = ti.class_p;
3180 /* Build the corresponding TYPE_DECL. */
3181 d = build_decl (input_location, TYPE_DECL, name, t);
3182 TYPE_NAME (TREE_TYPE (d)) = d;
3183 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3184 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3185 DECL_ARTIFICIAL (d) = 1;
3187 /* Store it in the hash table. */
3190 /* TYPENAME_TYPEs must always be compared structurally, because
3191 they may or may not resolve down to another type depending on
3192 the currently open classes. */
3193 SET_TYPE_STRUCTURAL_EQUALITY (t);
3199 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3200 provided to name the type. Returns an appropriate type, unless an
3201 error occurs, in which case error_mark_node is returned. If we
3202 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3203 return that, rather than the _TYPE it corresponds to, in other
3204 cases we look through the type decl. If TF_ERROR is set, complain
3205 about errors, otherwise be quiet. */
3208 make_typename_type (tree context, tree name, enum tag_types tag_type,
3209 tsubst_flags_t complain)
3215 if (name == error_mark_node
3216 || context == NULL_TREE
3217 || context == error_mark_node)
3218 return error_mark_node;
3222 if (!(TYPE_LANG_SPECIFIC (name)
3223 && (CLASSTYPE_IS_TEMPLATE (name)
3224 || CLASSTYPE_USE_TEMPLATE (name))))
3225 name = TYPE_IDENTIFIER (name);
3227 /* Create a TEMPLATE_ID_EXPR for the type. */
3228 name = build_nt (TEMPLATE_ID_EXPR,
3229 CLASSTYPE_TI_TEMPLATE (name),
3230 CLASSTYPE_TI_ARGS (name));
3232 else if (TREE_CODE (name) == TYPE_DECL)
3233 name = DECL_NAME (name);
3237 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3239 name = TREE_OPERAND (name, 0);
3240 if (TREE_CODE (name) == TEMPLATE_DECL)
3241 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3242 else if (TREE_CODE (name) == OVERLOAD)
3244 if (complain & tf_error)
3245 error ("%qD is not a type", name);
3246 return error_mark_node;
3249 if (TREE_CODE (name) == TEMPLATE_DECL)
3251 if (complain & tf_error)
3252 error ("%qD used without template parameters", name);
3253 return error_mark_node;
3255 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3256 gcc_assert (TYPE_P (context));
3258 if (!MAYBE_CLASS_TYPE_P (context))
3260 if (complain & tf_error)
3261 error ("%q#T is not a class", context);
3262 return error_mark_node;
3265 /* When the CONTEXT is a dependent type, NAME could refer to a
3266 dependent base class of CONTEXT. But look inside it anyway
3267 if CONTEXT is a currently open scope, in case it refers to a
3268 member of the current instantiation or a non-dependent base;
3269 lookup will stop when we hit a dependent base. */
3270 if (!dependent_scope_p (context))
3271 /* We should only set WANT_TYPE when we're a nested typename type.
3272 Then we can give better diagnostics if we find a non-type. */
3273 t = lookup_field (context, name, 2, /*want_type=*/true);
3277 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3278 return build_typename_type (context, name, fullname, tag_type);
3280 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3284 if (complain & tf_error)
3285 error (want_template ? G_("no class template named %q#T in %q#T")
3286 : G_("no type named %q#T in %q#T"), name, context);
3287 return error_mark_node;
3290 /* Pull out the template from an injected-class-name (or multiple). */
3292 t = maybe_get_template_decl_from_type_decl (t);
3294 if (TREE_CODE (t) == TREE_LIST)
3296 if (complain & tf_error)
3298 error ("lookup of %qT in %qT is ambiguous", name, context);
3299 print_candidates (t);
3301 return error_mark_node;
3304 if (want_template && !DECL_TYPE_TEMPLATE_P (t))
3306 if (complain & tf_error)
3307 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3309 return error_mark_node;
3311 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3313 if (complain & tf_error)
3314 error ("%<typename %T::%D%> names %q#T, which is not a type",
3316 return error_mark_node;
3319 if (!perform_or_defer_access_check (TYPE_BINFO (context), t, t, complain))
3320 return error_mark_node;
3322 /* If we are currently parsing a template and if T is a typedef accessed
3323 through CONTEXT then we need to remember and check access of T at
3324 template instantiation time. */
3325 add_typedef_to_current_template_for_access_check (t, context, input_location);
3328 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3330 /*entering_scope=*/0,
3331 tf_warning_or_error | tf_user);
3333 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3336 maybe_record_typedef_use (t);
3341 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3342 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3343 in which case error_mark_node is returned.
3345 If PARM_LIST is non-NULL, also make sure that the template parameter
3346 list of TEMPLATE_DECL matches.
3348 If COMPLAIN zero, don't complain about any errors that occur. */
3351 make_unbound_class_template (tree context, tree name, tree parm_list,
3352 tsubst_flags_t complain)
3358 name = TYPE_IDENTIFIER (name);
3359 else if (DECL_P (name))
3360 name = DECL_NAME (name);
3361 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3363 if (!dependent_type_p (context)
3364 || currently_open_class (context))
3366 tree tmpl = NULL_TREE;
3368 if (MAYBE_CLASS_TYPE_P (context))
3369 tmpl = lookup_field (context, name, 0, false);
3371 if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
3372 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
3374 if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl))
3376 if (complain & tf_error)
3377 error ("no class template named %q#T in %q#T", name, context);
3378 return error_mark_node;
3382 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3384 if (complain & tf_error)
3386 error ("template parameters do not match template");
3387 error ("%q+D declared here", tmpl);
3389 return error_mark_node;
3392 if (!perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl,
3394 return error_mark_node;
3399 /* Build the UNBOUND_CLASS_TEMPLATE. */
3400 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3401 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3402 TREE_TYPE (t) = NULL_TREE;
3403 SET_TYPE_STRUCTURAL_EQUALITY (t);
3405 /* Build the corresponding TEMPLATE_DECL. */
3406 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3407 TYPE_NAME (TREE_TYPE (d)) = d;
3408 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3409 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3410 DECL_ARTIFICIAL (d) = 1;
3411 DECL_TEMPLATE_PARMS (d) = parm_list;
3418 /* Push the declarations of builtin types into the namespace.
3419 RID_INDEX is the index of the builtin type in the array
3420 RID_POINTERS. NAME is the name used when looking up the builtin
3421 type. TYPE is the _TYPE node for the builtin type. */
3424 record_builtin_type (enum rid rid_index,
3428 tree rname = NULL_TREE, tname = NULL_TREE;
3429 tree tdecl = NULL_TREE;
3431 if ((int) rid_index < (int) RID_MAX)
3432 rname = ridpointers[(int) rid_index];
3434 tname = get_identifier (name);
3436 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3437 eliminated. Built-in types should not be looked up name; their
3438 names are keywords that the parser can recognize. However, there
3439 is code in c-common.c that uses identifier_global_value to look
3440 up built-in types by name. */
3443 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3444 DECL_ARTIFICIAL (tdecl) = 1;
3445 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3451 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3452 DECL_ARTIFICIAL (tdecl) = 1;
3454 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3457 if (!TYPE_NAME (type))
3458 TYPE_NAME (type) = tdecl;
3461 debug_hooks->type_decl (tdecl, 0);
3464 /* Record one of the standard Java types.
3465 * Declare it as having the given NAME.
3466 * If SIZE > 0, it is the size of one of the integral types;
3467 * otherwise it is the negative of the size of one of the other types. */
3470 record_builtin_java_type (const char* name, int size)
3475 type = build_nonstandard_integer_type (size, 0);
3476 type = build_distinct_type_copy (type);
3478 else if (size > -32)
3481 /* "__java_char" or ""__java_boolean". */
3482 type = build_nonstandard_integer_type (-size, 1);
3483 type = build_distinct_type_copy (type);
3484 /* Get the signed type cached and attached to the unsigned type,
3485 so it doesn't get garbage-collected at "random" times,
3486 causing potential codegen differences out of different UIDs
3487 and different alias set numbers. */
3488 stype = build_nonstandard_integer_type (-size, 0);
3489 stype = build_distinct_type_copy (stype);
3490 TREE_CHAIN (type) = stype;
3491 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3494 { /* "__java_float" or ""__java_double". */
3495 type = make_node (REAL_TYPE);
3496 TYPE_PRECISION (type) = - size;
3499 record_builtin_type (RID_MAX, name, type);
3500 decl = TYPE_NAME (type);
3502 /* Suppress generate debug symbol entries for these types,
3503 since for normal C++ they are just clutter.
3504 However, push_lang_context undoes this if extern "Java" is seen. */
3505 DECL_IGNORED_P (decl) = 1;
3507 TYPE_FOR_JAVA (type) = 1;
3511 /* Push a type into the namespace so that the back ends ignore it. */
3514 record_unknown_type (tree type, const char* name)
3516 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3517 TYPE_DECL, get_identifier (name), type));
3518 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3519 DECL_IGNORED_P (decl) = 1;
3520 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3521 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3522 TYPE_ALIGN (type) = 1;
3523 TYPE_USER_ALIGN (type) = 0;
3524 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3527 /* A string for which we should create an IDENTIFIER_NODE at
3530 typedef struct predefined_identifier
3532 /* The name of the identifier. */
3533 const char *const name;
3534 /* The place where the IDENTIFIER_NODE should be stored. */
3536 /* Nonzero if this is the name of a constructor or destructor. */
3537 const int ctor_or_dtor_p;
3538 } predefined_identifier;
3540 /* Create all the predefined identifiers. */
3543 initialize_predefined_identifiers (void)
3545 const predefined_identifier *pid;
3547 /* A table of identifiers to create at startup. */
3548 static const predefined_identifier predefined_identifiers[] = {
3549 { "C++", &lang_name_cplusplus, 0 },
3550 { "C", &lang_name_c, 0 },
3551 { "Java", &lang_name_java, 0 },
3552 /* Some of these names have a trailing space so that it is
3553 impossible for them to conflict with names written by users. */
3554 { "__ct ", &ctor_identifier, 1 },
3555 { "__base_ctor ", &base_ctor_identifier, 1 },
3556 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3557 { "__dt ", &dtor_identifier, 1 },
3558 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3559 { "__base_dtor ", &base_dtor_identifier, 1 },
3560 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3561 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3562 { "nelts", &nelts_identifier, 0 },
3563 { THIS_NAME, &this_identifier, 0 },
3564 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3565 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3566 { "_vptr", &vptr_identifier, 0 },
3567 { "__vtt_parm", &vtt_parm_identifier, 0 },
3568 { "::", &global_scope_name, 0 },
3569 { "std", &std_identifier, 0 },
3573 for (pid = predefined_identifiers; pid->name; ++pid)
3575 *pid->node = get_identifier (pid->name);
3576 if (pid->ctor_or_dtor_p)
3577 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3581 /* Create the predefined scalar types of C,
3582 and some nodes representing standard constants (0, 1, (void *)0).
3583 Initialize the global binding level.
3584 Make definitions for built-in primitive functions. */
3587 cxx_init_decl_processing (void)
3590 tree void_ftype_ptr;
3592 /* Create all the identifiers we need. */
3593 initialize_predefined_identifiers ();
3595 /* Create the global variables. */
3596 push_to_top_level ();
3598 current_function_decl = NULL_TREE;
3599 current_binding_level = NULL;
3600 /* Enter the global namespace. */
3601 gcc_assert (global_namespace == NULL_TREE);
3602 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3604 DECL_CONTEXT (global_namespace) = build_translation_unit_decl (NULL_TREE);
3605 TREE_PUBLIC (global_namespace) = 1;
3606 begin_scope (sk_namespace, global_namespace);
3608 if (flag_visibility_ms_compat)
3609 default_visibility = VISIBILITY_HIDDEN;
3612 current_lang_name = lang_name_c;
3614 /* Create the `std' namespace. */
3615 push_namespace (std_identifier);
3616 std_node = current_namespace;
3619 c_common_nodes_and_builtins ();
3621 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3622 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3623 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3624 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3625 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3626 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3627 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3628 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3630 integer_two_node = build_int_cst (NULL_TREE, 2);
3632 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3633 truthvalue_type_node = boolean_type_node;
3634 truthvalue_false_node = boolean_false_node;
3635 truthvalue_true_node = boolean_true_node;
3637 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3638 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE);
3639 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE);
3642 record_builtin_type (RID_MAX, NULL, string_type_node);
3645 delta_type_node = ptrdiff_type_node;
3646 vtable_index_type = ptrdiff_type_node;
3648 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3649 void_ftype = build_function_type_list (void_type_node, NULL_TREE);
3650 void_ftype_ptr = build_function_type_list (void_type_node,
3651 ptr_type_node, NULL_TREE);
3653 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3655 /* C++ extensions */
3657 unknown_type_node = make_node (LANG_TYPE);
3658 record_unknown_type (unknown_type_node, "unknown type");
3660 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3661 TREE_TYPE (unknown_type_node) = unknown_type_node;
3663 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3665 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3666 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3668 init_list_type_node = make_node (LANG_TYPE);
3669 record_unknown_type (init_list_type_node, "init list");
3672 /* Make sure we get a unique function type, so we can give
3673 its pointer type a name. (This wins for gdb.) */
3674 tree vfunc_type = make_node (FUNCTION_TYPE);
3675 TREE_TYPE (vfunc_type) = integer_type_node;
3676 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3677 layout_type (vfunc_type);
3679 vtable_entry_type = build_pointer_type (vfunc_type);
3681 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3684 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3685 layout_type (vtbl_type_node);
3686 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3687 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3688 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3689 layout_type (vtbl_ptr_type_node);
3690 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3692 push_namespace (get_identifier ("__cxxabiv1"));
3693 abi_node = current_namespace;
3696 global_type_node = make_node (LANG_TYPE);
3697 record_unknown_type (global_type_node, "global type");
3700 current_lang_name = lang_name_cplusplus;
3703 tree newattrs, extvisattr;
3704 tree newtype, deltype;
3705 tree ptr_ftype_sizetype;
3709 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE);
3710 if (cxx_dialect == cxx98)
3713 tree bad_alloc_type_node;
3714 tree bad_alloc_decl;
3716 push_namespace (std_identifier);
3717 bad_alloc_id = get_identifier ("bad_alloc");
3718 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3719 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3721 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3722 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3726 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
3729 new_eh_spec = noexcept_false_spec;
3731 /* Ensure attribs.c is initialized. */
3733 extvisattr = build_tree_list (get_identifier ("externally_visible"),
3735 newattrs = tree_cons (get_identifier ("alloc_size"),
3736 build_tree_list (NULL_TREE, integer_one_node),
3738 newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs);
3739 newtype = build_exception_variant (newtype, new_eh_spec);
3740 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
3741 deltype = build_exception_variant (deltype, empty_except_spec);
3742 push_cp_library_fn (NEW_EXPR, newtype);
3743 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3744 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3745 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3747 nullptr_type_node = make_node (NULLPTR_TYPE);
3748 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
3749 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode));
3750 TYPE_UNSIGNED (nullptr_type_node) = 1;
3751 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode);
3752 SET_TYPE_MODE (nullptr_type_node, ptr_mode);
3753 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node);
3754 nullptr_node = build_int_cst (nullptr_type_node, 0);
3758 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3760 /* Perform other language dependent initializations. */
3761 init_class_processing ();
3762 init_rtti_processing ();
3763 init_template_processing ();
3765 if (flag_exceptions)
3766 init_exception_processing ();
3768 if (! supports_one_only ())
3771 make_fname_decl = cp_make_fname_decl;
3772 start_fname_decls ();
3774 /* Show we use EH for cleanups. */
3775 if (flag_exceptions)
3776 using_eh_for_cleanups ();
3779 /* Generate an initializer for a function naming variable from
3780 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3781 filled in with the type of the init. */
3784 cp_fname_init (const char* name, tree *type_p)
3786 tree domain = NULL_TREE;
3788 tree init = NULL_TREE;
3793 length = strlen (name);
3794 domain = build_index_type (size_int (length));
3795 init = build_string (length + 1, name);
3798 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3799 type = build_cplus_array_type (type, domain);
3804 TREE_TYPE (init) = type;
3806 init = error_mark_node;
3811 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3812 the decl, LOC is the location to give the decl, NAME is the
3813 initialization string and TYPE_DEP indicates whether NAME depended
3814 on the type of the function. We make use of that to detect
3815 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3816 at the point of first use, so we mustn't push the decl now. */
3819 cp_make_fname_decl (location_t loc, tree id, int type_dep)
3821 const char *const name = (type_dep && processing_template_decl
3822 ? NULL : fname_as_string (type_dep));
3824 tree init = cp_fname_init (name, &type);
3825 tree decl = build_decl (loc, VAR_DECL, id, type);
3828 free (CONST_CAST (char *, name));
3830 /* As we're using pushdecl_with_scope, we must set the context. */
3831 DECL_CONTEXT (decl) = current_function_decl;
3833 TREE_STATIC (decl) = 1;
3834 TREE_READONLY (decl) = 1;
3835 DECL_ARTIFICIAL (decl) = 1;
3837 TREE_USED (decl) = 1;
3839 if (current_function_decl)
3841 cp_binding_level *b = current_binding_level;
3842 if (b->kind == sk_function_parms)
3843 return error_mark_node;
3844 while (b->level_chain->kind != sk_function_parms)
3846 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3847 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3848 LOOKUP_ONLYCONVERTING);
3852 DECL_THIS_STATIC (decl) = true;
3853 pushdecl_top_level_and_finish (decl, init);
3860 builtin_function_1 (tree decl, tree context, bool is_global)
3862 tree id = DECL_NAME (decl);
3863 const char *name = IDENTIFIER_POINTER (id);
3865 retrofit_lang_decl (decl);
3867 DECL_ARTIFICIAL (decl) = 1;
3868 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3869 SET_DECL_LANGUAGE (decl, lang_c);
3870 /* Runtime library routines are, by definition, available in an
3871 external shared object. */
3872 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3873 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3875 DECL_CONTEXT (decl) = context;
3878 pushdecl_top_level (decl);
3882 /* A function in the user's namespace should have an explicit
3883 declaration before it is used. Mark the built-in function as
3884 anticipated but not actually declared. */
3885 if (name[0] != '_' || name[1] != '_')
3886 DECL_ANTICIPATED (decl) = 1;
3887 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3889 size_t len = strlen (name);
3891 /* Treat __*_chk fortification functions as anticipated as well,
3892 unless they are __builtin_*. */
3893 if (len > strlen ("___chk")
3894 && memcmp (name + len - strlen ("_chk"),
3895 "_chk", strlen ("_chk") + 1) == 0)
3896 DECL_ANTICIPATED (decl) = 1;
3903 cxx_builtin_function (tree decl)
3905 tree id = DECL_NAME (decl);
3906 const char *name = IDENTIFIER_POINTER (id);
3907 /* All builtins that don't begin with an '_' should additionally
3908 go in the 'std' namespace. */
3911 tree decl2 = copy_node(decl);
3912 push_namespace (std_identifier);
3913 builtin_function_1 (decl2, std_node, false);
3917 return builtin_function_1 (decl, NULL_TREE, false);
3920 /* Like cxx_builtin_function, but guarantee the function is added to the global
3921 scope. This is to allow function specific options to add new machine
3922 dependent builtins when the target ISA changes via attribute((target(...)))
3923 which saves space on program startup if the program does not use non-generic
3927 cxx_builtin_function_ext_scope (tree decl)
3930 tree id = DECL_NAME (decl);
3931 const char *name = IDENTIFIER_POINTER (id);
3932 /* All builtins that don't begin with an '_' should additionally
3933 go in the 'std' namespace. */
3936 tree decl2 = copy_node(decl);
3937 push_namespace (std_identifier);
3938 builtin_function_1 (decl2, std_node, true);
3942 return builtin_function_1 (decl, NULL_TREE, true);
3945 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3946 function. Not called directly. */
3949 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3951 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3952 DECL_EXTERNAL (fn) = 1;
3953 TREE_PUBLIC (fn) = 1;
3954 DECL_ARTIFICIAL (fn) = 1;
3955 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3956 SET_DECL_LANGUAGE (fn, lang_c);
3957 /* Runtime library routines are, by definition, available in an
3958 external shared object. */
3959 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3960 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3964 /* Returns the _DECL for a library function with C linkage.
3965 We assume that such functions never throw; if this is incorrect,
3966 callers should unset TREE_NOTHROW. */
3969 build_library_fn (tree name, tree type)
3971 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3972 TREE_NOTHROW (fn) = 1;
3976 /* Returns the _DECL for a library function with C++ linkage. */
3979 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3981 tree fn = build_library_fn_1 (name, operator_code, type);
3982 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3983 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3984 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3988 /* Like build_library_fn, but takes a C string instead of an
3992 build_library_fn_ptr (const char* name, tree type)
3994 return build_library_fn (get_identifier (name), type);
3997 /* Like build_cp_library_fn, but takes a C string instead of an
4001 build_cp_library_fn_ptr (const char* name, tree type)
4003 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
4006 /* Like build_library_fn, but also pushes the function so that we will
4007 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4008 may throw exceptions listed in RAISES. */
4011 push_library_fn (tree name, tree type, tree raises)
4016 type = build_exception_variant (type, raises);
4018 fn = build_library_fn (name, type);
4019 pushdecl_top_level (fn);
4023 /* Like build_cp_library_fn, but also pushes the function so that it
4024 will be found by normal lookup. */
4027 push_cp_library_fn (enum tree_code operator_code, tree type)
4029 tree fn = build_cp_library_fn (ansi_opname (operator_code),
4034 apply_tm_attr (fn, get_identifier ("transaction_safe"));
4038 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4042 push_void_library_fn (tree name, tree parmtypes)
4044 tree type = build_function_type (void_type_node, parmtypes);
4045 return push_library_fn (name, type, NULL_TREE);
4048 /* Like push_library_fn, but also note that this function throws
4049 and does not return. Used for __throw_foo and the like. */
4052 push_throw_library_fn (tree name, tree type)
4054 tree fn = push_library_fn (name, type, NULL_TREE);
4055 TREE_THIS_VOLATILE (fn) = 1;
4056 TREE_NOTHROW (fn) = 0;
4060 /* When we call finish_struct for an anonymous union, we create
4061 default copy constructors and such. But, an anonymous union
4062 shouldn't have such things; this function undoes the damage to the
4063 anonymous union type T.
4065 (The reason that we create the synthesized methods is that we don't
4066 distinguish `union { int i; }' from `typedef union { int i; } U'.
4067 The first is an anonymous union; the second is just an ordinary
4071 fixup_anonymous_aggr (tree t)
4075 /* Wipe out memory of synthesized methods. */
4076 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
4077 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
4078 TYPE_HAS_COPY_CTOR (t) = 0;
4079 TYPE_HAS_CONST_COPY_CTOR (t) = 0;
4080 TYPE_HAS_COPY_ASSIGN (t) = 0;
4081 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0;
4083 /* Splice the implicitly generated functions out of the TYPE_METHODS
4085 q = &TYPE_METHODS (t);
4088 if (DECL_ARTIFICIAL (*q))
4089 *q = TREE_CHAIN (*q);
4091 q = &DECL_CHAIN (*q);
4094 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4095 if (TYPE_METHODS (t))
4097 tree decl = TYPE_MAIN_DECL (t);
4099 if (TREE_CODE (t) != UNION_TYPE)
4100 error_at (DECL_SOURCE_LOCATION (decl),
4101 "an anonymous struct cannot have function members");
4103 error_at (DECL_SOURCE_LOCATION (decl),
4104 "an anonymous union cannot have function members");
4107 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4108 assignment operators (because they cannot have these methods themselves).
4109 For anonymous unions this is already checked because they are not allowed
4110 in any union, otherwise we have to check it. */
4111 if (TREE_CODE (t) != UNION_TYPE)
4115 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4116 if (TREE_CODE (field) == FIELD_DECL)
4118 type = TREE_TYPE (field);
4119 if (CLASS_TYPE_P (type))
4121 if (TYPE_NEEDS_CONSTRUCTING (type))
4122 error ("member %q+#D with constructor not allowed "
4123 "in anonymous aggregate", field);
4124 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4125 error ("member %q+#D with destructor not allowed "
4126 "in anonymous aggregate", field);
4127 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
4128 error ("member %q+#D with copy assignment operator "
4129 "not allowed in anonymous aggregate", field);
4135 /* Make sure that a declaration with no declarator is well-formed, i.e.
4136 just declares a tagged type or anonymous union.
4138 Returns the type declared; or NULL_TREE if none. */
4141 check_tag_decl (cp_decl_specifier_seq *declspecs)
4143 int saw_friend = decl_spec_seq_has_spec_p (declspecs, ds_friend);
4144 int saw_typedef = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
4145 /* If a class, struct, or enum type is declared by the DECLSPECS
4146 (i.e, if a class-specifier, enum-specifier, or non-typename
4147 elaborated-type-specifier appears in the DECLSPECS),
4148 DECLARED_TYPE is set to the corresponding type. */
4149 tree declared_type = NULL_TREE;
4150 bool error_p = false;
4152 if (declspecs->multiple_types_p)
4153 error ("multiple types in one declaration");
4154 else if (declspecs->redefined_builtin_type)
4156 if (!in_system_header)
4157 permerror (declspecs->locations[ds_redefined_builtin_type_spec],
4158 "redeclaration of C++ built-in type %qT",
4159 declspecs->redefined_builtin_type);
4164 && TYPE_P (declspecs->type)
4165 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
4166 && MAYBE_CLASS_TYPE_P (declspecs->type))
4167 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
4168 declared_type = declspecs->type;
4169 else if (declspecs->type == error_mark_node)
4171 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
4172 permerror (input_location, "declaration does not declare anything");
4173 else if (declared_type != NULL_TREE && type_uses_auto (declared_type))
4175 error ("%<auto%> can only be specified for variables "
4176 "or function declarations");
4177 return error_mark_node;
4179 /* Check for an anonymous union. */
4180 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
4181 && TYPE_ANONYMOUS_P (declared_type))
4183 /* 7/3 In a simple-declaration, the optional init-declarator-list
4184 can be omitted only when declaring a class (clause 9) or
4185 enumeration (7.2), that is, when the decl-specifier-seq contains
4186 either a class-specifier, an elaborated-type-specifier with
4187 a class-key (9.1), or an enum-specifier. In these cases and
4188 whenever a class-specifier or enum-specifier is present in the
4189 decl-specifier-seq, the identifiers in these specifiers are among
4190 the names being declared by the declaration (as class-name,
4191 enum-names, or enumerators, depending on the syntax). In such
4192 cases, and except for the declaration of an unnamed bit-field (9.6),
4193 the decl-specifier-seq shall introduce one or more names into the
4194 program, or shall redeclare a name introduced by a previous
4195 declaration. [Example:
4196 enum { }; // ill-formed
4197 typedef class { }; // ill-formed
4201 error ("missing type-name in typedef-declaration");
4204 /* Anonymous unions are objects, so they can have specifiers. */;
4205 SET_ANON_AGGR_TYPE_P (declared_type);
4207 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
4208 pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
4213 if (decl_spec_seq_has_spec_p (declspecs, ds_inline)
4214 || decl_spec_seq_has_spec_p (declspecs, ds_virtual))
4215 error ("%qs can only be specified for functions",
4216 decl_spec_seq_has_spec_p (declspecs, ds_inline)
4217 ? "inline" : "virtual");
4219 && (!current_class_type
4220 || current_scope () != current_class_type))
4221 error ("%<friend%> can only be specified inside a class");
4222 else if (decl_spec_seq_has_spec_p (declspecs, ds_explicit))
4223 error ("%<explicit%> can only be specified for constructors");
4224 else if (declspecs->storage_class)
4225 error ("a storage class can only be specified for objects "
4227 else if (decl_spec_seq_has_spec_p (declspecs, ds_const)
4228 || decl_spec_seq_has_spec_p (declspecs, ds_volatile)
4229 || decl_spec_seq_has_spec_p (declspecs, ds_restrict)
4230 || decl_spec_seq_has_spec_p (declspecs, ds_thread))
4231 error ("qualifiers can only be specified for objects "
4233 else if (saw_typedef)
4234 warning (0, "%<typedef%> was ignored in this declaration");
4235 else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr))
4236 error ("%<constexpr%> cannot be used for type declarations");
4239 if (declspecs->attributes && warn_attributes && declared_type)
4242 if (!CLASS_TYPE_P (declared_type)
4243 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type))
4244 /* For a non-template class, use the name location. */
4245 loc = location_of (declared_type);
4247 /* For a template class (an explicit instantiation), use the
4248 current location. */
4249 loc = input_location;
4250 warning_at (loc, OPT_Wattributes, "attribute ignored in declaration "
4251 "of %q#T", declared_type);
4252 inform (loc, "attribute for %q#T must follow the %qs keyword",
4253 declared_type, class_key_or_enum_as_string (declared_type));
4256 return declared_type;
4259 /* Called when a declaration is seen that contains no names to declare.
4260 If its type is a reference to a structure, union or enum inherited
4261 from a containing scope, shadow that tag name for the current scope
4262 with a forward reference.
4263 If its type defines a new named structure or union
4264 or defines an enum, it is valid but we need not do anything here.
4265 Otherwise, it is an error.
4267 C++: may have to grok the declspecs to learn about static,
4268 complain for anonymous unions.
4270 Returns the TYPE declared -- or NULL_TREE if none. */
4273 shadow_tag (cp_decl_specifier_seq *declspecs)
4275 tree t = check_tag_decl (declspecs);
4280 if (maybe_process_partial_specialization (t) == error_mark_node)
4283 /* This is where the variables in an anonymous union are
4284 declared. An anonymous union declaration looks like:
4286 because there is no declarator after the union, the parser
4287 sends that declaration here. */
4288 if (ANON_AGGR_TYPE_P (t))
4290 fixup_anonymous_aggr (t);
4292 if (TYPE_FIELDS (t))
4294 tree decl = grokdeclarator (/*declarator=*/NULL,
4295 declspecs, NORMAL, 0, NULL);
4296 finish_anon_union (decl);
4303 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4306 groktypename (cp_decl_specifier_seq *type_specifiers,
4307 const cp_declarator *declarator,
4308 bool is_template_arg)
4312 enum decl_context context
4313 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
4314 attrs = type_specifiers->attributes;
4315 type_specifiers->attributes = NULL_TREE;
4316 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
4317 if (attrs && type != error_mark_node)
4319 if (CLASS_TYPE_P (type))
4320 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
4321 "outside of definition", type);
4322 else if (MAYBE_CLASS_TYPE_P (type))
4323 /* A template type parameter or other dependent type. */
4324 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
4325 "type %qT without an associated declaration", type);
4327 cplus_decl_attributes (&type, attrs, 0);
4332 /* Process a DECLARATOR for a function-scope variable declaration,
4333 namespace-scope variable declaration, or function declaration.
4334 (Function definitions go through start_function; class member
4335 declarations appearing in the body of the class go through
4336 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4337 If an error occurs, the error_mark_node is returned instead.
4339 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4340 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4341 for an explicitly defaulted function, or SD_DELETED for an explicitly
4342 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4343 implicitly initialized via a default constructor. ATTRIBUTES and
4344 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4346 The scope represented by the context of the returned DECL is pushed
4347 (if it is not the global namespace) and is assigned to
4348 *PUSHED_SCOPE_P. The caller is then responsible for calling
4349 pop_scope on *PUSHED_SCOPE_P if it is set. */
4352 start_decl (const cp_declarator *declarator,
4353 cp_decl_specifier_seq *declspecs,
4356 tree prefix_attributes,
4357 tree *pushed_scope_p)
4365 *pushed_scope_p = NULL_TREE;
4367 /* An object declared as __attribute__((deprecated)) suppresses
4368 warnings of uses of other deprecated items. */
4369 if (lookup_attribute ("deprecated", attributes))
4370 deprecated_state = DEPRECATED_SUPPRESS;
4372 attributes = chainon (attributes, prefix_attributes);
4374 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4377 deprecated_state = DEPRECATED_NORMAL;
4379 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
4380 || decl == error_mark_node)
4381 return error_mark_node;
4383 context = CP_DECL_CONTEXT (decl);
4384 if (context != global_namespace)
4385 *pushed_scope_p = push_scope (context);
4388 /* Is it valid for this decl to have an initializer at all?
4389 If not, set INITIALIZED to zero, which will indirectly
4390 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4391 switch (TREE_CODE (decl))
4394 error ("typedef %qD is initialized (use decltype instead)", decl);
4395 return error_mark_node;
4398 if (initialized == SD_DELETED)
4399 /* We'll handle the rest of the semantics later, but we need to
4400 set this now so it's visible to duplicate_decls. */
4401 DECL_DELETED_FN (decl) = 1;
4410 if (! toplevel_bindings_p ()
4411 && DECL_EXTERNAL (decl))
4412 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4414 DECL_EXTERNAL (decl) = 0;
4415 if (toplevel_bindings_p ())
4416 TREE_STATIC (decl) = 1;
4418 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0;
4420 if (alias && TREE_CODE (decl) == FUNCTION_DECL)
4421 record_key_method_defined (decl);
4423 /* If this is a typedef that names the class for linkage purposes
4424 (7.1.3p8), apply any attributes directly to the type. */
4425 if (TREE_CODE (decl) == TYPE_DECL
4426 && TAGGED_TYPE_P (TREE_TYPE (decl))
4427 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4428 flags = ATTR_FLAG_TYPE_IN_PLACE;
4432 /* Set attributes here so if duplicate decl, will have proper attributes. */
4433 cplus_decl_attributes (&decl, attributes, flags);
4435 /* Dllimported symbols cannot be defined. Static data members (which
4436 can be initialized in-class and dllimported) go through grokfield,
4437 not here, so we don't need to exclude those decls when checking for
4439 if (initialized && DECL_DLLIMPORT_P (decl))
4441 error ("definition of %q#D is marked %<dllimport%>", decl);
4442 DECL_DLLIMPORT_P (decl) = 0;
4445 /* If #pragma weak was used, mark the decl weak now. */
4446 if (!processing_template_decl)
4447 maybe_apply_pragma_weak (decl);
4449 if (TREE_CODE (decl) == FUNCTION_DECL
4450 && DECL_DECLARED_INLINE_P (decl)
4451 && DECL_UNINLINABLE (decl)
4452 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4453 warning (0, "inline function %q+D given attribute noinline", decl);
4455 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context)))
4457 if (TREE_CODE (decl) == VAR_DECL)
4459 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4460 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4461 error ("%q#D is not a static member of %q#T", decl, context);
4464 if (DECL_CONTEXT (field) != context)
4466 if (!same_type_p (DECL_CONTEXT (field), context))
4467 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4468 "to be defined as %<%T::%D%>",
4469 DECL_CONTEXT (field), DECL_NAME (decl),
4470 context, DECL_NAME (decl));
4471 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4473 /* Static data member are tricky; an in-class initialization
4474 still doesn't provide a definition, so the in-class
4475 declaration will have DECL_EXTERNAL set, but will have an
4476 initialization. Thus, duplicate_decls won't warn
4477 about this situation, and so we check here. */
4478 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4479 error ("duplicate initialization of %qD", decl);
4480 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4482 if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr)
4483 && !DECL_DECLARED_CONSTEXPR_P (field))
4484 error ("%qD declared %<constexpr%> outside its class", field);
4489 tree field = check_classfn (context, decl,
4490 (processing_template_decl
4491 > template_class_depth (context))
4492 ? current_template_parms
4494 if (field && field != error_mark_node
4495 && duplicate_decls (decl, field,
4496 /*newdecl_is_friend=*/false))
4500 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4501 DECL_IN_AGGR_P (decl) = 0;
4502 /* Do not mark DECL as an explicit specialization if it was not
4503 already marked as an instantiation; a declaration should
4504 never be marked as a specialization unless we know what
4505 template is being specialized. */
4506 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4508 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4510 /* [temp.expl.spec] An explicit specialization of a static data
4511 member of a template is a definition if the declaration
4512 includes an initializer; otherwise, it is a declaration.
4514 We check for processing_specialization so this only applies
4515 to the new specialization syntax. */
4516 if (!initialized && processing_specialization)
4517 DECL_EXTERNAL (decl) = 1;
4520 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
4521 /* Aliases are definitions. */
4523 permerror (input_location, "declaration of %q#D outside of class is not definition",
4527 was_public = TREE_PUBLIC (decl);
4529 /* Enter this declaration into the symbol table. */
4530 decl = maybe_push_decl (decl);
4532 if (processing_template_decl)
4533 decl = push_template_decl (decl);
4534 if (decl == error_mark_node)
4535 return error_mark_node;
4537 if (TREE_CODE (decl) == VAR_DECL
4538 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4539 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4541 /* This is a const variable with implicit 'static'. Set
4542 DECL_THIS_STATIC so we can tell it from variables that are
4543 !TREE_PUBLIC because of the anonymous namespace. */
4544 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)) || errorcount);
4545 DECL_THIS_STATIC (decl) = 1;
4548 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4549 start_decl_1 (decl, initialized);
4554 /* Process the declaration of a variable DECL. INITIALIZED is true
4555 iff DECL is explicitly initialized. (INITIALIZED is false if the
4556 variable is initialized via an implicitly-called constructor.)
4557 This function must be called for ordinary variables (including, for
4558 example, implicit instantiations of templates), but must not be
4559 called for template declarations. */
4562 start_decl_1 (tree decl, bool initialized)
4566 bool aggregate_definition_p;
4568 gcc_assert (!processing_template_decl);
4570 if (error_operand_p (decl))
4573 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4575 type = TREE_TYPE (decl);
4576 complete_p = COMPLETE_TYPE_P (type);
4577 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4579 /* If an explicit initializer is present, or if this is a definition
4580 of an aggregate, then we need a complete type at this point.
4581 (Scalars are always complete types, so there is nothing to
4582 check.) This code just sets COMPLETE_P; errors (if necessary)
4583 are issued below. */
4584 if ((initialized || aggregate_definition_p)
4586 && COMPLETE_TYPE_P (complete_type (type)))
4589 /* We will not yet have set TREE_READONLY on DECL if the type
4590 was "const", but incomplete, before this point. But, now, we
4591 have a complete type, so we can try again. */
4592 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4596 /* Is it valid for this decl to have an initializer at all? */
4598 /* Don't allow initializations for incomplete types except for
4599 arrays which might be completed by the initialization. */
4601 ; /* A complete type is ok. */
4602 else if (type_uses_auto (type))
4603 ; /* An auto type is ok. */
4604 else if (TREE_CODE (type) != ARRAY_TYPE)
4606 error ("variable %q#D has initializer but incomplete type", decl);
4607 type = TREE_TYPE (decl) = error_mark_node;
4609 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4611 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4612 error ("elements of array %q#D have incomplete type", decl);
4613 /* else we already gave an error in start_decl. */
4616 else if (aggregate_definition_p && !complete_p)
4618 if (type_uses_auto (type))
4619 error ("declaration of %q#D has no initializer", decl);
4621 error ("aggregate %q#D has incomplete type and cannot be defined",
4623 /* Change the type so that assemble_variable will give
4624 DECL an rtl we can live with: (mem (const_int 0)). */
4625 type = TREE_TYPE (decl) = error_mark_node;
4628 /* Create a new scope to hold this declaration if necessary.
4629 Whether or not a new scope is necessary cannot be determined
4630 until after the type has been completed; if the type is a
4631 specialization of a class template it is not until after
4632 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4633 will be set correctly. */
4634 maybe_push_cleanup_level (type);
4637 /* Handle initialization of references. DECL, TYPE, and INIT have the
4638 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4639 but will be set to a new CLEANUP_STMT if a temporary is created
4640 that must be destroyed subsequently.
4642 Returns an initializer expression to use to initialize DECL, or
4643 NULL if the initialization can be performed statically.
4645 Quotes on semantics can be found in ARM 8.4.3. */
4648 grok_reference_init (tree decl, tree type, tree init, int flags)
4650 if (init == NULL_TREE)
4652 if ((DECL_LANG_SPECIFIC (decl) == 0
4653 || DECL_IN_AGGR_P (decl) == 0)
4654 && ! DECL_THIS_EXTERN (decl))
4655 error ("%qD declared as reference but not initialized", decl);
4659 if (TREE_CODE (init) == TREE_LIST)
4660 init = build_x_compound_expr_from_list (init, ELK_INIT,
4661 tf_warning_or_error);
4663 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4664 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4665 /* Note: default conversion is only called in very special cases. */
4666 init = decay_conversion (init, tf_warning_or_error);
4668 /* Convert INIT to the reference type TYPE. This may involve the
4669 creation of a temporary, whose lifetime must be the same as that
4670 of the reference. If so, a DECL_EXPR for the temporary will be
4671 added just after the DECL_EXPR for DECL. That's why we don't set
4672 DECL_INITIAL for local references (instead assigning to them
4673 explicitly); we need to allow the temporary to be initialized
4675 return initialize_reference (type, init, flags,
4676 tf_warning_or_error);
4679 /* Designated initializers in arrays are not supported in GNU C++.
4680 The parser cannot detect this error since it does not know whether
4681 a given brace-enclosed initializer is for a class type or for an
4682 array. This function checks that CE does not use a designated
4683 initializer. If it does, an error is issued. Returns true if CE
4684 is valid, i.e., does not have a designated initializer. */
4687 check_array_designated_initializer (const constructor_elt *ce,
4688 unsigned HOST_WIDE_INT index)
4690 /* Designated initializers for array elements are not supported. */
4693 /* The parser only allows identifiers as designated
4695 if (ce->index == error_mark_node)
4696 error ("name used in a GNU-style designated "
4697 "initializer for an array");
4698 else if (TREE_CODE (ce->index) == INTEGER_CST)
4700 /* A C99 designator is OK if it matches the current index. */
4701 if (TREE_INT_CST_LOW (ce->index) == index)
4704 sorry ("non-trivial designated initializers not supported");
4708 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4709 error ("name %qD used in a GNU-style designated "
4710 "initializer for an array", ce->index);
4718 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4719 array until we finish parsing the initializer. If that's the
4720 situation we're in, update DECL accordingly. */
4723 maybe_deduce_size_from_array_init (tree decl, tree init)
4725 tree type = TREE_TYPE (decl);
4727 if (TREE_CODE (type) == ARRAY_TYPE
4728 && TYPE_DOMAIN (type) == NULL_TREE
4729 && TREE_CODE (decl) != TYPE_DECL)
4731 /* do_default is really a C-ism to deal with tentative definitions.
4732 But let's leave it here to ease the eventual merge. */
4733 int do_default = !DECL_EXTERNAL (decl);
4734 tree initializer = init ? init : DECL_INITIAL (decl);
4737 /* Check that there are no designated initializers in INIT, as
4738 those are not supported in GNU C++, and as the middle-end
4739 will crash if presented with a non-numeric designated
4741 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4743 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4744 constructor_elt *ce;
4746 FOR_EACH_VEC_ELT (constructor_elt, v, i, ce)
4747 if (!check_array_designated_initializer (ce, i))
4753 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4757 error ("initializer fails to determine size of %qD", decl);
4758 TREE_TYPE (decl) = error_mark_node;
4760 else if (failure == 2)
4764 error ("array size missing in %qD", decl);
4765 TREE_TYPE (decl) = error_mark_node;
4767 /* If a `static' var's size isn't known, make it extern as
4768 well as static, so it does not get allocated. If it's not
4769 `static', then don't mark it extern; finish_incomplete_decl
4770 will give it a default size and it will get allocated. */
4771 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4772 DECL_EXTERNAL (decl) = 1;
4774 else if (failure == 3)
4776 error ("zero-size array %qD", decl);
4777 TREE_TYPE (decl) = error_mark_node;
4781 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4783 relayout_decl (decl);
4787 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4788 any appropriate error messages regarding the layout. */
4791 layout_var_decl (tree decl)
4795 type = TREE_TYPE (decl);
4796 if (type == error_mark_node)
4799 /* If we haven't already layed out this declaration, do so now.
4800 Note that we must not call complete type for an external object
4801 because it's type might involve templates that we are not
4802 supposed to instantiate yet. (And it's perfectly valid to say
4803 `extern X x' for some incomplete type `X'.) */
4804 if (!DECL_EXTERNAL (decl))
4805 complete_type (type);
4806 if (!DECL_SIZE (decl)
4807 && TREE_TYPE (decl) != error_mark_node
4808 && (COMPLETE_TYPE_P (type)
4809 || (TREE_CODE (type) == ARRAY_TYPE
4810 && !TYPE_DOMAIN (type)
4811 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4812 layout_decl (decl, 0);
4814 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4816 /* An automatic variable with an incomplete type: that is an error.
4817 Don't talk about array types here, since we took care of that
4818 message in grokdeclarator. */
4819 error ("storage size of %qD isn%'t known", decl);
4820 TREE_TYPE (decl) = error_mark_node;
4823 /* Keep this code around in case we later want to control debug info
4824 based on whether a type is "used". (jason 1999-11-11) */
4826 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
4827 /* Let debugger know it should output info for this type. */
4828 note_debug_info_needed (ttype);
4830 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4831 note_debug_info_needed (DECL_CONTEXT (decl));
4834 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4835 && DECL_SIZE (decl) != NULL_TREE
4836 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4838 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4839 constant_expression_warning (DECL_SIZE (decl));
4842 error ("storage size of %qD isn%'t constant", decl);
4843 TREE_TYPE (decl) = error_mark_node;
4848 /* If a local static variable is declared in an inline function, or if
4849 we have a weak definition, we must endeavor to create only one
4850 instance of the variable at link-time. */
4853 maybe_commonize_var (tree decl)
4855 /* Static data in a function with comdat linkage also has comdat
4857 if (TREE_STATIC (decl)
4858 /* Don't mess with __FUNCTION__. */
4859 && ! DECL_ARTIFICIAL (decl)
4860 && DECL_FUNCTION_SCOPE_P (decl)
4861 && vague_linkage_p (DECL_CONTEXT (decl)))
4865 /* With weak symbols, we simply make the variable COMDAT;
4866 that will cause copies in multiple translations units to
4868 comdat_linkage (decl);
4872 if (DECL_INITIAL (decl) == NULL_TREE
4873 || DECL_INITIAL (decl) == error_mark_node)
4875 /* Without weak symbols, we can use COMMON to merge
4876 uninitialized variables. */
4877 TREE_PUBLIC (decl) = 1;
4878 DECL_COMMON (decl) = 1;
4882 /* While for initialized variables, we must use internal
4883 linkage -- which means that multiple copies will not
4885 TREE_PUBLIC (decl) = 0;
4886 DECL_COMMON (decl) = 0;
4887 warning_at (input_location, 0,
4888 "sorry: semantics of inline function static "
4889 "data %q+#D are wrong (you%'ll wind up "
4890 "with multiple copies)", decl);
4891 warning_at (DECL_SOURCE_LOCATION (decl), 0,
4892 " you can work around this by removing "
4897 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4898 /* Set it up again; we might have set DECL_INITIAL since the last
4900 comdat_linkage (decl);
4903 /* Issue an error message if DECL is an uninitialized const variable. */
4906 check_for_uninitialized_const_var (tree decl)
4908 tree type = strip_array_types (TREE_TYPE (decl));
4910 /* ``Unless explicitly declared extern, a const object does not have
4911 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4913 if (TREE_CODE (decl) == VAR_DECL
4914 && TREE_CODE (type) != REFERENCE_TYPE
4915 && CP_TYPE_CONST_P (type)
4916 && !DECL_INITIAL (decl))
4918 tree field = default_init_uninitialized_part (type);
4922 permerror (DECL_SOURCE_LOCATION (decl),
4923 "uninitialized const %qD", decl);
4925 if (CLASS_TYPE_P (type))
4927 tree defaulted_ctor;
4929 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
4930 "%q#T has no user-provided default constructor", type);
4931 defaulted_ctor = in_class_defaulted_default_constructor (type);
4933 inform (DECL_SOURCE_LOCATION (defaulted_ctor),
4934 "constructor is not user-provided because it is "
4935 "explicitly defaulted in the class body");
4936 inform (0, "and the implicitly-defined constructor does not "
4937 "initialize %q+#D", field);
4942 /* Structure holding the current initializer being processed by reshape_init.
4943 CUR is a pointer to the current element being processed, END is a pointer
4944 after the last element present in the initializer. */
4945 typedef struct reshape_iterator_t
4947 constructor_elt *cur;
4948 constructor_elt *end;
4951 static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t);
4953 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4954 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4955 initialized. If there are no more such fields, the return value
4959 next_initializable_field (tree field)
4962 && (TREE_CODE (field) != FIELD_DECL
4963 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4964 || DECL_ARTIFICIAL (field)))
4965 field = DECL_CHAIN (field);
4970 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4971 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4972 INTEGER_CST representing the size of the array minus one (the maximum index),
4973 or NULL_TREE if the array was declared without specifying the size. D is
4974 the iterator within the constructor. */
4977 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d,
4978 tsubst_flags_t complain)
4981 bool sized_array_p = (max_index != NULL_TREE);
4982 unsigned HOST_WIDE_INT max_index_cst = 0;
4983 unsigned HOST_WIDE_INT index;
4985 /* The initializer for an array is always a CONSTRUCTOR. */
4986 new_init = build_constructor (init_list_type_node, NULL);
4990 /* Minus 1 is used for zero sized arrays. */
4991 if (integer_all_onesp (max_index))
4994 if (host_integerp (max_index, 1))
4995 max_index_cst = tree_low_cst (max_index, 1);
4996 /* sizetype is sign extended, not zero extended. */
4998 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
5002 /* Loop until there are no more initializers. */
5004 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
5009 check_array_designated_initializer (d->cur, index);
5010 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false,
5012 if (elt_init == error_mark_node)
5013 return error_mark_node;
5014 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
5015 size_int (index), elt_init);
5016 if (!TREE_CONSTANT (elt_init))
5017 TREE_CONSTANT (new_init) = false;
5023 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5024 Parameters are the same of reshape_init_r. */
5027 reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain)
5029 tree max_index = NULL_TREE;
5031 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
5033 if (TYPE_DOMAIN (type))
5034 max_index = array_type_nelts (type);
5036 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5039 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5040 Parameters are the same of reshape_init_r. */
5043 reshape_init_vector (tree type, reshape_iter *d, tsubst_flags_t complain)
5045 tree max_index = NULL_TREE;
5047 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
5049 if (COMPOUND_LITERAL_P (d->cur->value))
5051 tree value = d->cur->value;
5052 if (!same_type_p (TREE_TYPE (value), type))
5054 if (complain & tf_error)
5055 error ("invalid type %qT as initializer for a vector of type %qT",
5056 TREE_TYPE (d->cur->value), type);
5057 value = error_mark_node;
5063 /* For a vector, we initialize it as an array of the appropriate size. */
5064 if (TREE_CODE (type) == VECTOR_TYPE)
5065 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1);
5067 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5070 /* Subroutine of reshape_init_r, processes the initializers for classes
5071 or union. Parameters are the same of reshape_init_r. */
5074 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
5075 tsubst_flags_t complain)
5080 gcc_assert (CLASS_TYPE_P (type));
5082 /* The initializer for a class is always a CONSTRUCTOR. */
5083 new_init = build_constructor (init_list_type_node, NULL);
5084 field = next_initializable_field (TYPE_FIELDS (type));
5090 An initializer for an aggregate member that is an
5091 empty class shall have the form of an empty
5092 initializer-list {}. */
5093 if (!first_initializer_p)
5095 if (complain & tf_error)
5096 error ("initializer for %qT must be brace-enclosed", type);
5097 return error_mark_node;
5102 /* Loop through the initializable fields, gathering initializers. */
5103 while (d->cur != d->end)
5106 constructor_elt *old_cur = d->cur;
5108 /* Handle designated initializers, as an extension. */
5111 if (TREE_CODE (d->cur->index) == INTEGER_CST)
5113 if (complain & tf_error)
5114 error ("%<[%E] =%> used in a GNU-style designated initializer"
5115 " for class %qT", d->cur->index, type);
5116 return error_mark_node;
5119 if (TREE_CODE (d->cur->index) == FIELD_DECL)
5120 /* We already reshaped this. */
5121 gcc_assert (d->cur->index == field);
5123 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
5125 if (!field || TREE_CODE (field) != FIELD_DECL)
5127 if (complain & tf_error)
5128 error ("%qT has no non-static data member named %qD", type,
5130 return error_mark_node;
5134 /* If we processed all the member of the class, we are done. */
5138 field_init = reshape_init_r (TREE_TYPE (field), d,
5139 /*first_initializer_p=*/false, complain);
5140 if (field_init == error_mark_node)
5141 return error_mark_node;
5143 if (d->cur == old_cur && d->cur->index)
5145 /* This can happen with an invalid initializer for a flexible
5146 array member (c++/54441). */
5147 if (complain & tf_error)
5148 error ("invalid initializer for %q#D", field);
5149 return error_mark_node;
5152 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
5156 When a union is initialized with a brace-enclosed
5157 initializer, the braces shall only contain an
5158 initializer for the first member of the union. */
5159 if (TREE_CODE (type) == UNION_TYPE)
5162 field = next_initializable_field (DECL_CHAIN (field));
5168 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5169 designators are not valid; either complain or return true to indicate
5170 that reshape_init_r should return error_mark_node. */
5173 has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
5177 if (complain & tf_error)
5178 error ("C99 designator %qE outside aggregate initializer",
5186 /* Subroutine of reshape_init, which processes a single initializer (part of
5187 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5188 iterator within the CONSTRUCTOR which points to the initializer to process.
5189 FIRST_INITIALIZER_P is true if this is the first initializer of the
5190 outermost CONSTRUCTOR node. */
5193 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
5194 tsubst_flags_t complain)
5196 tree init = d->cur->value;
5198 if (error_operand_p (init))
5199 return error_mark_node;
5201 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
5202 && has_designator_problem (d, complain))
5203 return error_mark_node;
5205 if (TREE_CODE (type) == COMPLEX_TYPE)
5207 /* A complex type can be initialized from one or two initializers,
5208 but braces are not elided. */
5210 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5212 if (CONSTRUCTOR_NELTS (init) > 2)
5214 if (complain & tf_error)
5215 error ("too many initializers for %qT", type);
5217 return error_mark_node;
5220 else if (first_initializer_p && d->cur != d->end)
5222 VEC(constructor_elt, gc) *v = 0;
5223 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
5224 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
5225 if (has_designator_problem (d, complain))
5226 return error_mark_node;
5228 init = build_constructor (init_list_type_node, v);
5233 /* A non-aggregate type is always initialized with a single
5235 if (!CP_AGGREGATE_TYPE_P (type))
5237 /* It is invalid to initialize a non-aggregate type with a
5238 brace-enclosed initializer before C++0x.
5239 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5240 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5241 a CONSTRUCTOR (with a record type). */
5242 if (TREE_CODE (init) == CONSTRUCTOR
5243 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
5245 if (SCALAR_TYPE_P (type))
5247 if (complain & tf_error)
5248 error ("braces around scalar initializer for type %qT", type);
5249 init = error_mark_node;
5252 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5261 All implicit type conversions (clause _conv_) are considered when
5262 initializing the aggregate member with an initializer from an
5263 initializer-list. If the initializer can initialize a member,
5264 the member is initialized. Otherwise, if the member is itself a
5265 non-empty subaggregate, brace elision is assumed and the
5266 initializer is considered for the initialization of the first
5267 member of the subaggregate. */
5268 if (TREE_CODE (init) != CONSTRUCTOR
5269 /* But don't try this for the first initializer, since that would be
5270 looking through the outermost braces; A a2 = { a1 }; is not a
5271 valid aggregate initialization. */
5272 && !first_initializer_p
5273 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
5274 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL,
5281 /* [dcl.init.string]
5283 A char array (whether plain char, signed char, or unsigned char)
5284 can be initialized by a string-literal (optionally enclosed in
5285 braces); a wchar_t array can be initialized by a wide
5286 string-literal (optionally enclosed in braces). */
5287 if (TREE_CODE (type) == ARRAY_TYPE
5288 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
5290 tree str_init = init;
5292 /* Strip one level of braces if and only if they enclose a single
5293 element (as allowed by [dcl.init.string]). */
5294 if (!first_initializer_p
5295 && TREE_CODE (str_init) == CONSTRUCTOR
5296 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
5298 str_init = VEC_index (constructor_elt,
5299 CONSTRUCTOR_ELTS (str_init), 0).value;
5302 /* If it's a string literal, then it's the initializer for the array
5303 as a whole. Otherwise, continue with normal initialization for
5304 array types (one value per array element). */
5305 if (TREE_CODE (str_init) == STRING_CST)
5307 if (has_designator_problem (d, complain))
5308 return error_mark_node;
5314 /* The following cases are about aggregates. If we are not within a full
5315 initializer already, and there is not a CONSTRUCTOR, it means that there
5316 is a missing set of braces (that is, we are processing the case for
5317 which reshape_init exists). */
5318 if (!first_initializer_p)
5320 if (TREE_CODE (init) == CONSTRUCTOR)
5322 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
5323 /* There is no need to reshape pointer-to-member function
5324 initializers, as they are always constructed correctly
5325 by the front end. */
5327 else if (COMPOUND_LITERAL_P (init))
5328 /* For a nested compound literal, there is no need to reshape since
5329 brace elision is not allowed. Even if we decided to allow it,
5330 we should add a call to reshape_init in finish_compound_literal,
5331 before calling digest_init, so changing this code would still
5332 not be necessary. */
5333 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
5337 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5338 return reshape_init (type, init, complain);
5342 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
5346 /* Dispatch to specialized routines. */
5347 if (CLASS_TYPE_P (type))
5348 return reshape_init_class (type, d, first_initializer_p, complain);
5349 else if (TREE_CODE (type) == ARRAY_TYPE)
5350 return reshape_init_array (type, d, complain);
5351 else if (TREE_CODE (type) == VECTOR_TYPE)
5352 return reshape_init_vector (type, d, complain);
5357 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5358 brace-enclosed aggregate initializer.
5360 INIT is the CONSTRUCTOR containing the list of initializers describing
5361 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5362 It may not presently match the shape of the TYPE; for example:
5364 struct S { int a; int b; };
5365 struct S a[] = { 1, 2, 3, 4 };
5367 Here INIT will hold a VEC of four elements, rather than a
5368 VEC of two elements, each itself a VEC of two elements. This
5369 routine transforms INIT from the former form into the latter. The
5370 revised CONSTRUCTOR node is returned. */
5373 reshape_init (tree type, tree init, tsubst_flags_t complain)
5375 VEC(constructor_elt, gc) *v;
5379 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5381 v = CONSTRUCTOR_ELTS (init);
5383 /* An empty constructor does not need reshaping, and it is always a valid
5385 if (VEC_empty (constructor_elt, v))
5388 /* Recurse on this CONSTRUCTOR. */
5389 d.cur = &VEC_index (constructor_elt, v, 0);
5390 d.end = d.cur + VEC_length (constructor_elt, v);
5392 new_init = reshape_init_r (type, &d, true, complain);
5393 if (new_init == error_mark_node)
5394 return error_mark_node;
5396 /* Make sure all the element of the constructor were used. Otherwise,
5397 issue an error about exceeding initializers. */
5400 if (complain & tf_error)
5401 error ("too many initializers for %qT", type);
5403 return error_mark_node;
5409 /* Verify array initializer. Returns true if errors have been reported. */
5412 check_array_initializer (tree decl, tree type, tree init)
5414 tree element_type = TREE_TYPE (type);
5416 /* The array type itself need not be complete, because the
5417 initializer may tell us how many elements are in the array.
5418 But, the elements of the array must be complete. */
5419 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5422 error ("elements of array %q#D have incomplete type", decl);
5424 error ("elements of array %q#T have incomplete type", type);
5427 /* It is not valid to initialize a VLA. */
5429 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5430 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5433 error ("variable-sized object %qD may not be initialized", decl);
5435 error ("variable-sized compound literal");
5441 /* Subroutine of check_initializer; args are passed down from that function.
5442 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5445 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5448 gcc_assert (stmts_are_full_exprs_p ());
5449 return build_aggr_init (decl, init, flags, tf_warning_or_error);
5452 /* Verify INIT (the initializer for DECL), and record the
5453 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5454 grok_reference_init.
5456 If the return value is non-NULL, it is an expression that must be
5457 evaluated dynamically to initialize DECL. */
5460 check_initializer (tree decl, tree init, int flags, VEC(tree,gc) **cleanups)
5462 tree type = TREE_TYPE (decl);
5463 tree init_code = NULL;
5464 tree extra_init = NULL_TREE;
5467 /* Things that are going to be initialized need to have complete
5469 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5471 if (DECL_HAS_VALUE_EXPR_P (decl))
5473 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5474 it doesn't have storage to be initialized. */
5475 gcc_assert (init == NULL_TREE);
5479 if (type == error_mark_node)
5480 /* We will have already complained. */
5483 if (TREE_CODE (type) == ARRAY_TYPE)
5485 if (check_array_initializer (decl, type, init))
5488 else if (!COMPLETE_TYPE_P (type))
5490 error ("%q#D has incomplete type", decl);
5491 TREE_TYPE (decl) = error_mark_node;
5495 /* There is no way to make a variable-sized class type in GNU C++. */
5496 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5498 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5500 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
5501 if (SCALAR_TYPE_P (type))
5505 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5506 init = build_zero_init (type, NULL_TREE, false);
5508 else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
5510 error ("scalar object %qD requires one element in initializer",
5512 TREE_TYPE (decl) = error_mark_node;
5518 if (TREE_CODE (decl) == CONST_DECL)
5520 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5522 DECL_INITIAL (decl) = init;
5524 gcc_assert (init != NULL_TREE);
5527 else if (!init && DECL_REALLY_EXTERN (decl))
5529 else if (init || type_build_ctor_call (type)
5530 || TREE_CODE (type) == REFERENCE_TYPE)
5532 if (TREE_CODE (type) == REFERENCE_TYPE)
5534 init = grok_reference_init (decl, type, init, flags);
5535 flags |= LOOKUP_ALREADY_DIGESTED;
5538 check_for_uninitialized_const_var (decl);
5539 /* Do not reshape constructors of vectors (they don't need to be
5541 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
5543 if (is_std_init_list (type))
5545 init = perform_implicit_conversion (type, init,
5546 tf_warning_or_error);
5547 flags |= LOOKUP_ALREADY_DIGESTED;
5549 else if (TYPE_NON_AGGREGATE_CLASS (type))
5551 /* Don't reshape if the class has constructors. */
5552 if (cxx_dialect == cxx98)
5553 error ("in C++98 %qD must be initialized by constructor, "
5557 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5559 error ("opaque vector types cannot be initialized");
5560 init = error_mark_node;
5564 init = reshape_init (type, init, tf_warning_or_error);
5565 if (SCALAR_TYPE_P (type))
5566 check_narrowing (type, init);
5570 /* If DECL has an array type without a specific bound, deduce the
5571 array size from the initializer. */
5572 maybe_deduce_size_from_array_init (decl, init);
5573 type = TREE_TYPE (decl);
5574 if (type == error_mark_node)
5577 if ((type_build_ctor_call (type) || CLASS_TYPE_P (type))
5578 && !(flags & LOOKUP_ALREADY_DIGESTED)
5579 && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
5580 && CP_AGGREGATE_TYPE_P (type)))
5582 init_code = build_aggr_init_full_exprs (decl, init, flags);
5584 /* If this is a constexpr initializer, expand_default_init will
5585 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5586 case, pull the initializer back out and pass it down into
5587 store_init_value. */
5588 while (TREE_CODE (init_code) == EXPR_STMT
5589 || TREE_CODE (init_code) == CONVERT_EXPR)
5590 init_code = TREE_OPERAND (init_code, 0);
5591 if (TREE_CODE (init_code) == INIT_EXPR)
5593 init = TREE_OPERAND (init_code, 1);
5594 init_code = NULL_TREE;
5595 /* Don't call digest_init; it's unnecessary and will complain
5596 about aggregate initialization of non-aggregate classes. */
5597 flags |= LOOKUP_ALREADY_DIGESTED;
5599 else if (DECL_DECLARED_CONSTEXPR_P (decl))
5601 /* Declared constexpr, but no suitable initializer; massage
5602 init appropriately so we can pass it into store_init_value
5604 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5605 init = finish_compound_literal (type, init,
5606 tf_warning_or_error);
5607 else if (CLASS_TYPE_P (type)
5608 && (!init || TREE_CODE (init) == TREE_LIST))
5610 init = build_functional_cast (type, init, tf_none);
5611 if (init != error_mark_node)
5612 TARGET_EXPR_DIRECT_INIT_P (init) = true;
5614 init_code = NULL_TREE;
5620 if (init && TREE_CODE (init) != TREE_VEC)
5622 /* In aggregate initialization of a variable, each element
5623 initialization is a full-expression because there is no
5624 enclosing expression. */
5625 gcc_assert (stmts_are_full_exprs_p ());
5627 init_code = store_init_value (decl, init, cleanups, flags);
5629 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5630 && DECL_INITIAL (decl)
5631 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5632 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5633 warning (0, "array %qD initialized by parenthesized string literal %qE",
5634 decl, DECL_INITIAL (decl));
5640 if (CLASS_TYPE_P (core_type = strip_array_types (type))
5641 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
5642 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
5643 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
5646 check_for_uninitialized_const_var (decl);
5649 if (init && init != error_mark_node)
5650 init_code = build2 (INIT_EXPR, type, decl, init);
5653 init_code = add_stmt_to_compound (extra_init, init_code);
5655 if (init_code && DECL_IN_AGGR_P (decl))
5657 static int explained = 0;
5659 if (cxx_dialect < cxx0x)
5660 error ("initializer invalid for static member with constructor");
5662 error ("non-constant in-class initialization invalid for static "
5663 "member %qD", decl);
5666 error ("(an out of class initialization is required)");
5674 /* If DECL is not a local variable, give it RTL. */
5677 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5679 int toplev = toplevel_bindings_p ();
5681 const char *filename;
5683 /* Set the DECL_ASSEMBLER_NAME for the object. */
5686 /* The `register' keyword, when used together with an
5687 asm-specification, indicates that the variable should be
5688 placed in a particular register. */
5689 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5691 set_user_assembler_name (decl, asmspec);
5692 DECL_HARD_REGISTER (decl) = 1;
5696 if (TREE_CODE (decl) == FUNCTION_DECL
5697 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5698 set_builtin_user_assembler_name (decl, asmspec);
5699 set_user_assembler_name (decl, asmspec);
5703 /* Handle non-variables up front. */
5704 if (TREE_CODE (decl) != VAR_DECL)
5706 rest_of_decl_compilation (decl, toplev, at_eof);
5710 /* If we see a class member here, it should be a static data
5712 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5714 gcc_assert (TREE_STATIC (decl));
5715 /* An in-class declaration of a static data member should be
5716 external; it is only a declaration, and not a definition. */
5717 if (init == NULL_TREE)
5718 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5721 /* We don't create any RTL for local variables. */
5722 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5725 /* We defer emission of local statics until the corresponding
5726 DECL_EXPR is expanded. */
5727 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5729 /* We try to defer namespace-scope static constants so that they are
5730 not emitted into the object file unnecessarily. */
5731 filename = input_filename;
5732 if (!DECL_VIRTUAL_P (decl)
5733 && TREE_READONLY (decl)
5734 && DECL_INITIAL (decl) != NULL_TREE
5735 && DECL_INITIAL (decl) != error_mark_node
5737 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5739 && !TREE_PUBLIC (decl))
5741 /* Fool with the linkage of static consts according to #pragma
5743 struct c_fileinfo *finfo = get_fileinfo (filename);
5744 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5746 TREE_PUBLIC (decl) = 1;
5747 DECL_EXTERNAL (decl) = finfo->interface_only;
5752 /* Likewise for template instantiations. */
5753 else if (DECL_LANG_SPECIFIC (decl)
5754 && DECL_IMPLICIT_INSTANTIATION (decl))
5757 /* If we're not deferring, go ahead and assemble the variable. */
5759 rest_of_decl_compilation (decl, toplev, at_eof);
5762 /* walk_tree helper for wrap_temporary_cleanups, below. */
5765 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5767 /* Stop at types or full-expression boundaries. */
5768 if (TYPE_P (*stmt_p)
5769 || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR)
5775 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5777 tree guard = (tree)data;
5778 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5780 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5781 /* Tell honor_protect_cleanup_actions to handle this as a separate
5783 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5785 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5791 /* We're initializing a local variable which has a cleanup GUARD. If there
5792 are any temporaries used in the initializer INIT of this variable, we
5793 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5794 variable will be cleaned up properly if one of them throws.
5796 Unfortunately, there's no way to express this properly in terms of
5797 nesting, as the regions for the temporaries overlap the region for the
5798 variable itself; if there are two temporaries, the variable needs to be
5799 the first thing destroyed if either of them throws. However, we only
5800 want to run the variable's cleanup if it actually got constructed. So
5801 we need to guard the temporary cleanups with the variable's cleanup if
5802 they are run on the normal path, but not if they are run on the
5803 exceptional path. We implement this by telling
5804 honor_protect_cleanup_actions to strip the variable cleanup from the
5805 exceptional path. */
5808 wrap_temporary_cleanups (tree init, tree guard)
5810 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5813 /* Generate code to initialize DECL (a local variable). */
5816 initialize_local_var (tree decl, tree init)
5818 tree type = TREE_TYPE (decl);
5822 gcc_assert (TREE_CODE (decl) == VAR_DECL
5823 || TREE_CODE (decl) == RESULT_DECL);
5824 gcc_assert (!TREE_STATIC (decl));
5826 if (DECL_SIZE (decl) == NULL_TREE)
5828 /* If we used it already as memory, it must stay in memory. */
5829 DECL_INITIAL (decl) = NULL_TREE;
5830 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5834 if (type == error_mark_node)
5837 /* Compute and store the initial value. */
5838 already_used = TREE_USED (decl) || TREE_USED (type);
5839 if (TREE_USED (type))
5840 DECL_READ_P (decl) = 1;
5842 /* Generate a cleanup, if necessary. */
5843 cleanup = cxx_maybe_build_cleanup (decl, tf_warning_or_error);
5845 /* Perform the initialization. */
5848 if (TREE_CODE (init) == INIT_EXPR
5849 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init, 1)))
5851 /* Stick simple initializers in DECL_INITIAL so that
5852 -Wno-init-self works (c++/34772). */
5853 gcc_assert (TREE_OPERAND (init, 0) == decl);
5854 DECL_INITIAL (decl) = TREE_OPERAND (init, 1);
5858 int saved_stmts_are_full_exprs_p;
5860 /* If we're only initializing a single object, guard the
5861 destructors of any temporaries used in its initializer with
5862 its destructor. This isn't right for arrays because each
5863 element initialization is a full-expression. */
5864 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5865 wrap_temporary_cleanups (init, cleanup);
5867 gcc_assert (building_stmt_list_p ());
5868 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5869 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5870 finish_expr_stmt (init);
5871 current_stmt_tree ()->stmts_are_full_exprs_p =
5872 saved_stmts_are_full_exprs_p;
5876 /* Set this to 0 so we can tell whether an aggregate which was
5877 initialized was ever used. Don't do this if it has a
5878 destructor, so we don't complain about the 'resource
5879 allocation is initialization' idiom. Now set
5880 attribute((unused)) on types so decls of that type will be
5881 marked used. (see TREE_USED, above.) */
5882 if (TYPE_NEEDS_CONSTRUCTING (type)
5884 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5885 && DECL_NAME (decl))
5886 TREE_USED (decl) = 0;
5887 else if (already_used)
5888 TREE_USED (decl) = 1;
5891 finish_decl_cleanup (decl, cleanup);
5894 /* DECL is a VAR_DECL for a compiler-generated variable with static
5895 storage duration (like a virtual table) whose initializer is a
5896 compile-time constant. Initialize the variable and provide it to the
5900 initialize_artificial_var (tree decl, VEC(constructor_elt,gc) *v)
5903 gcc_assert (DECL_ARTIFICIAL (decl));
5904 init = build_constructor (TREE_TYPE (decl), v);
5905 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5906 DECL_INITIAL (decl) = init;
5907 DECL_INITIALIZED_P (decl) = 1;
5908 determine_visibility (decl);
5909 layout_var_decl (decl);
5910 maybe_commonize_var (decl);
5911 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5914 /* INIT is the initializer for a variable, as represented by the
5915 parser. Returns true iff INIT is type-dependent. */
5918 type_dependent_init_p (tree init)
5920 if (TREE_CODE (init) == TREE_LIST)
5921 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5922 return any_type_dependent_elements_p (init);
5923 else if (TREE_CODE (init) == CONSTRUCTOR)
5924 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5926 VEC(constructor_elt, gc) *elts;
5930 elts = CONSTRUCTOR_ELTS (init);
5931 nelts = VEC_length (constructor_elt, elts);
5932 for (i = 0; i < nelts; ++i)
5933 if (type_dependent_init_p (VEC_index (constructor_elt,
5938 /* It must be a simple expression, e.g., int i = 3; */
5939 return type_dependent_expression_p (init);
5944 /* INIT is the initializer for a variable, as represented by the
5945 parser. Returns true iff INIT is value-dependent. */
5948 value_dependent_init_p (tree init)
5950 if (TREE_CODE (init) == TREE_LIST)
5951 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5952 return any_value_dependent_elements_p (init);
5953 else if (TREE_CODE (init) == CONSTRUCTOR)
5954 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5956 VEC(constructor_elt, gc) *elts;
5960 elts = CONSTRUCTOR_ELTS (init);
5961 nelts = VEC_length (constructor_elt, elts);
5962 for (i = 0; i < nelts; ++i)
5963 if (value_dependent_init_p (VEC_index (constructor_elt,
5968 /* It must be a simple expression, e.g., int i = 3; */
5969 return value_dependent_expression_p (init);
5974 /* Finish processing of a declaration;
5975 install its line number and initial value.
5976 If the length of an array type is not known before,
5977 it must be determined now, from the initial value, or it is an error.
5979 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5980 true, then INIT is an integral constant expression.
5982 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5983 if the (init) syntax was used. */
5986 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5987 tree asmspec_tree, int flags)
5990 VEC(tree,gc) *cleanups = NULL;
5991 const char *asmspec = NULL;
5992 int was_readonly = 0;
5993 bool var_definition_p = false;
5996 if (decl == error_mark_node)
6001 error ("assignment (not initialization) in declaration");
6005 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
6006 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6007 gcc_assert (TREE_CODE (decl) != PARM_DECL);
6009 type = TREE_TYPE (decl);
6010 if (type == error_mark_node)
6013 /* If a name was specified, get the string. */
6014 if (at_namespace_scope_p ())
6015 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
6016 if (asmspec_tree && asmspec_tree != error_mark_node)
6017 asmspec = TREE_STRING_POINTER (asmspec_tree);
6019 if (current_class_type
6020 && CP_DECL_CONTEXT (decl) == current_class_type
6021 && TYPE_BEING_DEFINED (current_class_type)
6022 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type)
6023 && (DECL_INITIAL (decl) || init))
6024 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
6026 if (TREE_CODE (decl) != FUNCTION_DECL
6027 && (auto_node = type_uses_auto (type)))
6030 if (init == NULL_TREE)
6032 error ("declaration of %q#D has no initializer", decl);
6033 TREE_TYPE (decl) = error_mark_node;
6037 if (TREE_CODE (d_init) == TREE_LIST)
6038 d_init = build_x_compound_expr_from_list (d_init, ELK_INIT,
6039 tf_warning_or_error);
6040 d_init = resolve_nondeduced_context (d_init);
6041 type = TREE_TYPE (decl) = do_auto_deduction (type, d_init,
6043 if (type == error_mark_node)
6047 if (!ensure_literal_type_for_constexpr_object (decl))
6048 DECL_DECLARED_CONSTEXPR_P (decl) = 0;
6050 if (TREE_CODE (decl) == VAR_DECL
6051 && DECL_CLASS_SCOPE_P (decl)
6052 && DECL_INITIALIZED_IN_CLASS_P (decl))
6053 check_static_variable_definition (decl, type);
6055 if (init && TREE_CODE (decl) == FUNCTION_DECL)
6058 if (init == ridpointers[(int)RID_DELETE])
6060 /* FIXME check this is 1st decl. */
6061 DECL_DELETED_FN (decl) = 1;
6062 DECL_DECLARED_INLINE_P (decl) = 1;
6063 DECL_INITIAL (decl) = error_mark_node;
6064 FOR_EACH_CLONE (clone, decl)
6066 DECL_DELETED_FN (clone) = 1;
6067 DECL_DECLARED_INLINE_P (clone) = 1;
6068 DECL_INITIAL (clone) = error_mark_node;
6072 else if (init == ridpointers[(int)RID_DEFAULT])
6074 if (defaultable_fn_check (decl))
6075 DECL_DEFAULTED_FN (decl) = 1;
6077 DECL_INITIAL (decl) = NULL_TREE;
6081 if (init && TREE_CODE (decl) == VAR_DECL)
6083 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
6084 /* If DECL is a reference, then we want to know whether init is a
6085 reference constant; init_const_expr_p as passed tells us whether
6086 it's an rvalue constant. */
6087 if (TREE_CODE (type) == REFERENCE_TYPE)
6088 init_const_expr_p = potential_constant_expression (init);
6089 if (init_const_expr_p)
6091 /* Set these flags now for templates. We'll update the flags in
6092 store_init_value for instantiations. */
6093 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
6094 if (decl_maybe_constant_var_p (decl))
6095 TREE_CONSTANT (decl) = 1;
6099 if (processing_template_decl)
6101 bool type_dependent_p;
6103 /* Add this declaration to the statement-tree. */
6104 if (at_function_scope_p ())
6105 add_decl_expr (decl);
6107 type_dependent_p = dependent_type_p (type);
6109 if (check_for_bare_parameter_packs (init))
6112 DECL_INITIAL (decl) = NULL_TREE;
6115 /* Generally, initializers in templates are expanded when the
6116 template is instantiated. But, if DECL is a variable constant
6117 then it can be used in future constant expressions, so its value
6118 must be available. */
6120 if (TREE_CODE (decl) != VAR_DECL || dependent_type_p (type))
6121 /* We can't do anything if the decl has dependent type. */;
6123 && init_const_expr_p
6124 && !type_dependent_p
6125 && decl_maybe_constant_var_p (decl)
6126 && !type_dependent_init_p (init)
6127 && !value_dependent_init_p (init))
6129 /* This variable seems to be a non-dependent constant, so process
6130 its initializer. If check_initializer returns non-null the
6131 initialization wasn't constant after all. */
6133 cleanups = make_tree_vector ();
6134 init_code = check_initializer (decl, init, flags, &cleanups);
6135 if (init_code == NULL_TREE)
6137 release_tree_vector (cleanups);
6139 else if (!DECL_PRETTY_FUNCTION_P (decl))
6141 /* Deduce array size even if the initializer is dependent. */
6142 maybe_deduce_size_from_array_init (decl, init);
6143 /* And complain about multiple initializers. */
6144 if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init)
6145 && !MAYBE_CLASS_TYPE_P (type))
6146 init = build_x_compound_expr_from_list (init, ELK_INIT,
6147 tf_warning_or_error);
6151 DECL_INITIAL (decl) = init;
6155 /* Just store non-static data member initializers for later. */
6156 if (init && TREE_CODE (decl) == FIELD_DECL)
6157 DECL_INITIAL (decl) = init;
6159 /* Take care of TYPE_DECLs up front. */
6160 if (TREE_CODE (decl) == TYPE_DECL)
6162 if (type != error_mark_node
6163 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
6165 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6166 warning (0, "shadowing previous type declaration of %q#D", decl);
6167 set_identifier_type_value (DECL_NAME (decl), decl);
6170 /* If we have installed this as the canonical typedef for this
6171 type, and that type has not been defined yet, delay emitting
6172 the debug information for it, as we will emit it later. */
6173 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
6174 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
6175 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6177 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl),
6182 /* A reference will be modified here, as it is initialized. */
6183 if (! DECL_EXTERNAL (decl)
6184 && TREE_READONLY (decl)
6185 && TREE_CODE (type) == REFERENCE_TYPE)
6188 TREE_READONLY (decl) = 0;
6191 if (TREE_CODE (decl) == VAR_DECL)
6193 /* Only variables with trivial initialization and destruction can
6194 have thread-local storage. */
6195 if (DECL_THREAD_LOCAL_P (decl)
6196 && (type_has_nontrivial_default_init (TREE_TYPE (decl))
6197 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
6198 error ("%qD cannot be thread-local because it has non-trivial "
6199 "type %qT", decl, TREE_TYPE (decl));
6200 /* If this is a local variable that will need a mangled name,
6201 register it now. We must do this before processing the
6202 initializer for the variable, since the initialization might
6203 require a guard variable, and since the mangled name of the
6204 guard variable will depend on the mangled name of this
6206 if (DECL_FUNCTION_SCOPE_P (decl)
6207 && TREE_STATIC (decl)
6208 && !DECL_ARTIFICIAL (decl))
6210 push_local_name (decl);
6211 if (DECL_CONSTRUCTOR_P (current_function_decl)
6212 || DECL_DESTRUCTOR_P (current_function_decl))
6213 /* Normally local_decls is populated during GIMPLE lowering,
6214 but [cd]tors are never actually compiled directly. We need
6215 to put statics on the list so we can deal with the label
6216 address extension. FIXME. */
6217 add_local_decl (cfun, decl);
6220 /* Convert the initializer to the type of DECL, if we have not
6221 already initialized DECL. */
6222 if (!DECL_INITIALIZED_P (decl)
6223 /* If !DECL_EXTERNAL then DECL is being defined. In the
6224 case of a static data member initialized inside the
6225 class-specifier, there can be an initializer even if DECL
6226 is *not* defined. */
6227 && (!DECL_EXTERNAL (decl) || init))
6229 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6232 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6233 /* Allow libjava/prims.cc define primitive classes. */
6234 if (init != NULL_TREE
6235 || jclass == NULL_TREE
6236 || TREE_CODE (jclass) != TYPE_DECL
6237 || !POINTER_TYPE_P (TREE_TYPE (jclass))
6238 || !same_type_ignoring_top_level_qualifiers_p
6239 (type, TREE_TYPE (TREE_TYPE (jclass))))
6240 error ("Java object %qD not allocated with %<new%>", decl);
6243 cleanups = make_tree_vector ();
6244 init = check_initializer (decl, init, flags, &cleanups);
6245 /* Thread-local storage cannot be dynamically initialized. */
6246 if (DECL_THREAD_LOCAL_P (decl) && init)
6248 error ("%qD is thread-local and so cannot be dynamically "
6249 "initialized", decl);
6253 /* Check that the initializer for a static data member was a
6254 constant. Although we check in the parser that the
6255 initializer is an integral constant expression, we do not
6256 simplify division-by-zero at the point at which it
6257 occurs. Therefore, in:
6259 struct S { static const int i = 7 / 0; };
6261 we issue an error at this point. It would
6262 probably be better to forbid division by zero in
6263 integral constant expressions. */
6264 if (DECL_EXTERNAL (decl) && init)
6266 error ("%qD cannot be initialized by a non-constant expression"
6267 " when being declared", decl);
6268 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
6276 The memory occupied by any object of static storage
6277 duration is zero-initialized at program startup before
6278 any other initialization takes place.
6280 We cannot create an appropriate initializer until after
6281 the type of DECL is finalized. If DECL_INITIAL is set,
6282 then the DECL is statically initialized, and any
6283 necessary zero-initialization has already been performed. */
6284 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
6285 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
6286 /*nelts=*/NULL_TREE,
6287 /*static_storage_p=*/true);
6288 /* Remember that the initialization for this variable has
6290 DECL_INITIALIZED_P (decl) = 1;
6291 /* This declaration is the definition of this variable,
6292 unless we are initializing a static data member within
6293 the class specifier. */
6294 if (!DECL_EXTERNAL (decl))
6295 var_definition_p = true;
6297 /* If the variable has an array type, lay out the type, even if
6298 there is no initializer. It is valid to index through the
6299 array, and we must get TYPE_ALIGN set correctly on the array
6301 else if (TREE_CODE (type) == ARRAY_TYPE)
6304 if (TREE_STATIC (decl)
6305 && !at_function_scope_p ()
6306 && current_function_decl == NULL)
6307 /* So decl is a global variable or a static member of a
6308 non local class. Record the types it uses
6309 so that we can decide later to emit debug info for them. */
6310 record_types_used_by_current_var_decl (decl);
6312 else if (TREE_CODE (decl) == FIELD_DECL
6313 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6314 error ("non-static data member %qD has Java class type", decl);
6316 /* Add this declaration to the statement-tree. This needs to happen
6317 after the call to check_initializer so that the DECL_EXPR for a
6318 reference temp is added before the DECL_EXPR for the reference itself. */
6319 if (DECL_FUNCTION_SCOPE_P (decl))
6320 add_decl_expr (decl);
6322 /* Let the middle end know about variables and functions -- but not
6323 static data members in uninstantiated class templates. */
6324 if (TREE_CODE (decl) == VAR_DECL
6325 || TREE_CODE (decl) == FUNCTION_DECL)
6327 if (TREE_CODE (decl) == VAR_DECL)
6329 layout_var_decl (decl);
6330 maybe_commonize_var (decl);
6333 /* This needs to happen after the linkage is set. */
6334 determine_visibility (decl);
6336 if (var_definition_p && TREE_STATIC (decl))
6338 /* If a TREE_READONLY variable needs initialization
6339 at runtime, it is no longer readonly and we need to
6340 avoid MEM_READONLY_P being set on RTL created for it. */
6343 if (TREE_READONLY (decl))
6344 TREE_READONLY (decl) = 0;
6347 else if (was_readonly)
6348 TREE_READONLY (decl) = 1;
6351 make_rtl_for_nonlocal_decl (decl, init, asmspec);
6353 /* Check for abstractness of the type. Notice that there is no
6354 need to strip array types here since the check for those types
6355 is already done within create_array_type_for_decl. */
6356 if (TREE_CODE (type) == FUNCTION_TYPE
6357 || TREE_CODE (type) == METHOD_TYPE)
6358 abstract_virtuals_error (decl, TREE_TYPE (type));
6360 abstract_virtuals_error (decl, type);
6362 if (TREE_TYPE (decl) == error_mark_node)
6363 /* No initialization required. */
6365 else if (TREE_CODE (decl) == FUNCTION_DECL)
6369 if (init == ridpointers[(int)RID_DEFAULT])
6371 /* An out-of-class default definition is defined at
6372 the point where it is explicitly defaulted. */
6373 if (DECL_DELETED_FN (decl))
6374 maybe_explain_implicit_delete (decl);
6375 else if (DECL_INITIAL (decl) == error_mark_node)
6376 synthesize_method (decl);
6379 error ("function %q#D is initialized like a variable", decl);
6381 /* else no initialization required. */
6383 else if (DECL_EXTERNAL (decl)
6384 && ! (DECL_LANG_SPECIFIC (decl)
6385 && DECL_NOT_REALLY_EXTERN (decl)))
6388 DECL_INITIAL (decl) = init;
6390 /* A variable definition. */
6391 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6392 /* Initialize the local variable. */
6393 initialize_local_var (decl, init);
6395 /* If a variable is defined, and then a subsequent
6396 definition with external linkage is encountered, we will
6397 get here twice for the same variable. We want to avoid
6398 calling expand_static_init more than once. For variables
6399 that are not static data members, we can call
6400 expand_static_init only when we actually process the
6401 initializer. It is not legal to redeclare a static data
6402 member, so this issue does not arise in that case. */
6403 else if (var_definition_p && TREE_STATIC (decl))
6404 expand_static_init (decl, init);
6407 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6408 reference, insert it in the statement-tree now. */
6412 FOR_EACH_VEC_ELT (tree, cleanups, i, t)
6413 push_cleanup (decl, t, false);
6414 release_tree_vector (cleanups);
6418 TREE_READONLY (decl) = 1;
6420 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
6423 /* Returns a declaration for a VAR_DECL as if:
6425 extern "C" TYPE NAME;
6427 had been seen. Used to create compiler-generated global
6431 declare_global_var (tree name, tree type)
6435 push_to_top_level ();
6436 decl = build_decl (input_location, VAR_DECL, name, type);
6437 TREE_PUBLIC (decl) = 1;
6438 DECL_EXTERNAL (decl) = 1;
6439 DECL_ARTIFICIAL (decl) = 1;
6440 /* If the user has explicitly declared this variable (perhaps
6441 because the code we are compiling is part of a low-level runtime
6442 library), then it is possible that our declaration will be merged
6443 with theirs by pushdecl. */
6444 decl = pushdecl (decl);
6445 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
6446 pop_from_top_level ();
6451 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6452 if "__cxa_atexit" is not being used) corresponding to the function
6453 to be called when the program exits. */
6456 get_atexit_fn_ptr_type (void)
6460 if (!atexit_fn_ptr_type_node)
6463 if (flag_use_cxa_atexit
6464 && !targetm.cxx.use_atexit_for_cxa_atexit ())
6465 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6466 arg_type = ptr_type_node;
6468 /* The parameter to "atexit" is "void (*)(void)". */
6469 arg_type = NULL_TREE;
6471 fn_type = build_function_type_list (void_type_node,
6472 arg_type, NULL_TREE);
6473 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
6476 return atexit_fn_ptr_type_node;
6479 /* Returns a pointer to the `atexit' function. Note that if
6480 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6481 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6484 get_atexit_node (void)
6490 bool use_aeabi_atexit;
6495 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6497 /* The declaration for `__cxa_atexit' is:
6499 int __cxa_atexit (void (*)(void *), void *, void *)
6501 We build up the argument types and then the function type
6503 tree argtype0, argtype1, argtype2;
6505 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
6506 /* First, build the pointer-to-function type for the first
6508 fn_ptr_type = get_atexit_fn_ptr_type ();
6509 /* Then, build the rest of the argument types. */
6510 argtype2 = ptr_type_node;
6511 if (use_aeabi_atexit)
6513 argtype1 = fn_ptr_type;
6514 argtype0 = ptr_type_node;
6518 argtype1 = ptr_type_node;
6519 argtype0 = fn_ptr_type;
6521 /* And the final __cxa_atexit type. */
6522 fn_type = build_function_type_list (integer_type_node,
6523 argtype0, argtype1, argtype2,
6525 if (use_aeabi_atexit)
6526 name = "__aeabi_atexit";
6528 name = "__cxa_atexit";
6532 /* The declaration for `atexit' is:
6534 int atexit (void (*)());
6536 We build up the argument types and then the function type
6538 fn_ptr_type = get_atexit_fn_ptr_type ();
6539 /* Build the final atexit type. */
6540 fn_type = build_function_type_list (integer_type_node,
6541 fn_ptr_type, NULL_TREE);
6545 /* Now, build the function declaration. */
6546 push_lang_context (lang_name_c);
6547 atexit_fndecl = build_library_fn_ptr (name, fn_type);
6548 mark_used (atexit_fndecl);
6549 pop_lang_context ();
6550 atexit_node = decay_conversion (atexit_fndecl, tf_warning_or_error);
6555 /* Returns the __dso_handle VAR_DECL. */
6558 get_dso_handle_node (void)
6560 if (dso_handle_node)
6561 return dso_handle_node;
6563 /* Declare the variable. */
6564 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6567 #ifdef HAVE_GAS_HIDDEN
6568 DECL_VISIBILITY (dso_handle_node) = VISIBILITY_HIDDEN;
6569 DECL_VISIBILITY_SPECIFIED (dso_handle_node) = 1;
6572 return dso_handle_node;
6575 /* Begin a new function with internal linkage whose job will be simply
6576 to destroy some particular variable. */
6578 static GTY(()) int start_cleanup_cnt;
6581 start_cleanup_fn (void)
6586 bool use_cxa_atexit = flag_use_cxa_atexit
6587 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6589 push_to_top_level ();
6591 /* No need to mangle this. */
6592 push_lang_context (lang_name_c);
6594 /* Build the name of the function. */
6595 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6596 /* Build the function declaration. */
6597 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6598 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6599 /* It's a function with internal linkage, generated by the
6601 TREE_PUBLIC (fndecl) = 0;
6602 DECL_ARTIFICIAL (fndecl) = 1;
6603 /* Make the function `inline' so that it is only emitted if it is
6604 actually needed. It is unlikely that it will be inlined, since
6605 it is only called via a function pointer, but we avoid unnecessary
6606 emissions this way. */
6607 DECL_DECLARED_INLINE_P (fndecl) = 1;
6608 DECL_INTERFACE_KNOWN (fndecl) = 1;
6609 /* Build the parameter. */
6614 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6615 DECL_CONTEXT (parmdecl) = fndecl;
6616 TREE_USED (parmdecl) = 1;
6617 DECL_READ_P (parmdecl) = 1;
6618 DECL_ARGUMENTS (fndecl) = parmdecl;
6622 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6624 pop_lang_context ();
6626 return current_function_decl;
6629 /* Finish the cleanup function begun by start_cleanup_fn. */
6632 end_cleanup_fn (void)
6634 expand_or_defer_fn (finish_function (0));
6636 pop_from_top_level ();
6639 /* Generate code to handle the destruction of DECL, an object with
6640 static storage duration. */
6643 register_dtor_fn (tree decl)
6650 tree arg0, arg1 = NULL_TREE, arg2 = NULL_TREE;
6652 type = TREE_TYPE (decl);
6653 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6654 return void_zero_node;
6656 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6657 a class object, we can just pass the destructor to
6658 "__cxa_atexit"; we don't have to build a temporary function to do
6660 use_dtor = (flag_use_cxa_atexit
6661 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6662 && CLASS_TYPE_P (type));
6667 /* Find the destructor. */
6668 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6669 gcc_assert (idx >= 0);
6670 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6671 /* Make sure it is accessible. */
6672 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup,
6673 tf_warning_or_error);
6677 /* Call build_cleanup before we enter the anonymous function so
6678 that any access checks will be done relative to the current
6679 scope, rather than the scope of the anonymous function. */
6680 build_cleanup (decl);
6682 /* Now start the function. */
6683 cleanup = start_cleanup_fn ();
6685 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6686 to the original function, rather than the anonymous one. That
6687 will make the back end think that nested functions are in use,
6688 which causes confusion. */
6689 push_deferring_access_checks (dk_no_check);
6690 fcall = build_cleanup (decl);
6691 pop_deferring_access_checks ();
6693 /* Create the body of the anonymous function. */
6694 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6695 finish_expr_stmt (fcall);
6696 finish_compound_stmt (compound_stmt);
6700 /* Call atexit with the cleanup function. */
6701 mark_used (cleanup);
6702 cleanup = build_address (cleanup);
6703 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6709 /* We must convert CLEANUP to the type that "__cxa_atexit"
6711 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6712 /* "__cxa_atexit" will pass the address of DECL to the
6713 cleanup function. */
6715 addr = build_address (decl);
6716 /* The declared type of the parameter to "__cxa_atexit" is
6717 "void *". For plain "T*", we could just let the
6718 machinery in cp_build_function_call convert it -- but if the
6719 type is "cv-qualified T *", then we need to convert it
6720 before passing it in, to avoid spurious errors. */
6721 addr = build_nop (ptr_type_node, addr);
6724 /* Since the cleanup functions we build ignore the address
6725 they're given, there's no reason to pass the actual address
6726 in, and, in general, it's cheaper to pass NULL than any
6728 addr = null_pointer_node;
6729 arg2 = cp_build_addr_expr (get_dso_handle_node (),
6730 tf_warning_or_error);
6731 if (targetm.cxx.use_aeabi_atexit ())
6744 return cp_build_function_call_nary (get_atexit_node (), tf_warning_or_error,
6745 arg0, arg1, arg2, NULL_TREE);
6748 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6749 is its initializer. Generate code to handle the construction
6750 and destruction of DECL. */
6753 expand_static_init (tree decl, tree init)
6755 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6756 gcc_assert (TREE_STATIC (decl));
6758 /* Some variables require no dynamic initialization. */
6760 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6763 if (DECL_FUNCTION_SCOPE_P (decl))
6765 /* Emit code to perform this initialization but once. */
6766 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6767 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6768 tree guard, guard_addr;
6771 /* Emit code to perform this initialization but once. This code
6774 static <type> guard;
6775 if (!guard.first_byte) {
6776 if (__cxa_guard_acquire (&guard)) {
6779 // Do initialization.
6780 flag = true; __cxa_guard_release (&guard);
6781 // Register variable for destruction at end of program.
6783 if (!flag) __cxa_guard_abort (&guard);
6787 Note that the `flag' variable is only set to 1 *after* the
6788 initialization is complete. This ensures that an exception,
6789 thrown during the construction, will cause the variable to
6790 reinitialized when we pass through this code again, as per:
6794 If the initialization exits by throwing an exception, the
6795 initialization is not complete, so it will be tried again
6796 the next time control enters the declaration.
6798 This process should be thread-safe, too; multiple threads
6799 should not be able to initialize the variable more than
6802 /* Create the guard variable. */
6803 guard = get_guard (decl);
6805 /* This optimization isn't safe on targets with relaxed memory
6806 consistency. On such targets we force synchronization in
6807 __cxa_guard_acquire. */
6808 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6810 /* Begin the conditional initialization. */
6811 if_stmt = begin_if_stmt ();
6812 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6813 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6816 if (flag_threadsafe_statics)
6818 tree vfntype = NULL_TREE;
6819 tree acquire_name, release_name, abort_name;
6820 tree acquire_fn, release_fn, abort_fn;
6821 guard_addr = build_address (guard);
6823 acquire_name = get_identifier ("__cxa_guard_acquire");
6824 release_name = get_identifier ("__cxa_guard_release");
6825 abort_name = get_identifier ("__cxa_guard_abort");
6826 acquire_fn = identifier_global_value (acquire_name);
6827 release_fn = identifier_global_value (release_name);
6828 abort_fn = identifier_global_value (abort_name);
6830 acquire_fn = push_library_fn
6831 (acquire_name, build_function_type_list (integer_type_node,
6832 TREE_TYPE (guard_addr),
6835 if (!release_fn || !abort_fn)
6836 vfntype = build_function_type_list (void_type_node,
6837 TREE_TYPE (guard_addr),
6840 release_fn = push_library_fn (release_name, vfntype, NULL_TREE);
6842 abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE);
6844 inner_if_stmt = begin_if_stmt ();
6845 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6848 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6849 begin = get_target_expr (boolean_false_node);
6850 flag = TARGET_EXPR_SLOT (begin);
6852 TARGET_EXPR_CLEANUP (begin)
6853 = build3 (COND_EXPR, void_type_node, flag,
6855 build_call_n (abort_fn, 1, guard_addr));
6856 CLEANUP_EH_ONLY (begin) = 1;
6858 /* Do the initialization itself. */
6859 init = add_stmt_to_compound (begin, init);
6860 init = add_stmt_to_compound
6861 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6862 init = add_stmt_to_compound
6863 (init, build_call_n (release_fn, 1, guard_addr));
6866 init = add_stmt_to_compound (init, set_guard (guard));
6868 /* Use atexit to register a function for destroying this static
6870 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6872 finish_expr_stmt (init);
6874 if (flag_threadsafe_statics)
6876 finish_compound_stmt (inner_then_clause);
6877 finish_then_clause (inner_if_stmt);
6878 finish_if_stmt (inner_if_stmt);
6881 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6883 finish_compound_stmt (then_clause);
6884 finish_then_clause (if_stmt);
6885 finish_if_stmt (if_stmt);
6889 static_aggregates = tree_cons (init, decl, static_aggregates);
6893 /* Make TYPE a complete type based on INITIAL_VALUE.
6894 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6895 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6896 3 if the initializer list is empty (in pedantic mode). */
6899 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6902 tree type, elt_type;
6906 unsigned HOST_WIDE_INT i;
6909 /* An array of character type can be initialized from a
6910 brace-enclosed string constant.
6912 FIXME: this code is duplicated from reshape_init. Probably
6913 we should just call reshape_init here? */
6914 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6915 && TREE_CODE (initial_value) == CONSTRUCTOR
6916 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6918 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6919 tree value = VEC_index (constructor_elt, v, 0).value;
6921 if (TREE_CODE (value) == STRING_CST
6922 && VEC_length (constructor_elt, v) == 1)
6923 initial_value = value;
6926 /* If any of the elements are parameter packs, we can't actually
6927 complete this type now because the array size is dependent. */
6928 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6930 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6933 if (PACK_EXPANSION_P (value))
6939 failure = complete_array_type (ptype, initial_value, do_default);
6941 /* We can create the array before the element type is complete, which
6942 means that we didn't have these two bits set in the original type
6943 either. In completing the type, we are expected to propagate these
6944 bits. See also complete_type which does the same thing for arrays
6947 if (TYPE_DOMAIN (type))
6949 elt_type = TREE_TYPE (type);
6950 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6951 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6952 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6958 /* As above, but either give an error or reject zero-size arrays, depending
6962 cp_complete_array_type_or_error (tree *ptype, tree initial_value,
6963 bool do_default, tsubst_flags_t complain)
6966 bool sfinae = !(complain & tf_error);
6967 /* In SFINAE context we can't be lenient about zero-size arrays. */
6970 failure = cp_complete_array_type (ptype, initial_value, do_default);
6976 /* Not an error. */;
6977 else if (failure == 1)
6978 error ("initializer fails to determine size of %qT", *ptype);
6979 else if (failure == 2)
6982 error ("array size missing in %qT", *ptype);
6984 else if (failure == 3)
6985 error ("zero-size array %qT", *ptype);
6986 *ptype = error_mark_node;
6991 /* Return zero if something is declared to be a member of type
6992 CTYPE when in the context of CUR_TYPE. STRING is the error
6993 message to print in that case. Otherwise, quietly return 1. */
6996 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6998 if (ctype && ctype != cur_type)
7000 if (flags == DTOR_FLAG)
7001 error ("destructor for alien class %qT cannot be a member", ctype);
7003 error ("constructor for alien class %qT cannot be a member", ctype);
7009 /* Subroutine of `grokdeclarator'. */
7011 /* Generate errors possibly applicable for a given set of specifiers.
7012 This is for ARM $7.1.2. */
7015 bad_specifiers (tree object,
7016 enum bad_spec_place type,
7027 error ("%qD declared as a %<virtual%> variable", object);
7029 error ("%qD declared as an %<inline%> variable", object);
7031 error ("%<const%> and %<volatile%> function specifiers on "
7032 "%qD invalid in variable declaration", object);
7036 error ("%qD declared as a %<virtual%> parameter", object);
7038 error ("%qD declared as an %<inline%> parameter", object);
7040 error ("%<const%> and %<volatile%> function specifiers on "
7041 "%qD invalid in parameter declaration", object);
7045 error ("%qD declared as a %<virtual%> type", object);
7047 error ("%qD declared as an %<inline%> type", object);
7049 error ("%<const%> and %<volatile%> function specifiers on "
7050 "%qD invalid in type declaration", object);
7054 error ("%qD declared as a %<virtual%> field", object);
7056 error ("%qD declared as an %<inline%> field", object);
7058 error ("%<const%> and %<volatile%> function specifiers on "
7059 "%qD invalid in field declaration", object);
7065 error ("%q+D declared as a friend", object);
7067 && (TREE_CODE (object) == TYPE_DECL
7068 || (!TYPE_PTRFN_P (TREE_TYPE (object))
7069 && !TYPE_REFFN_P (TREE_TYPE (object))
7070 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
7071 error ("%q+D declared with an exception specification", object);
7074 /* DECL is a member function or static data member and is presently
7075 being defined. Check that the definition is taking place in a
7079 check_class_member_definition_namespace (tree decl)
7081 /* These checks only apply to member functions and static data
7083 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
7084 || TREE_CODE (decl) == VAR_DECL);
7085 /* We check for problems with specializations in pt.c in
7086 check_specialization_namespace, where we can issue better
7088 if (processing_specialization)
7090 /* There are no restrictions on the placement of
7091 explicit instantiations. */
7092 if (processing_explicit_instantiation)
7096 A member function definition that appears outside of the
7097 class definition shall appear in a namespace scope enclosing
7098 the class definition.
7102 The definition for a static data member shall appear in a
7103 namespace scope enclosing the member's class definition. */
7104 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
7105 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
7106 decl, DECL_CONTEXT (decl));
7109 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7110 METHOD_TYPE for a non-static member function; QUALS are the
7111 cv-qualifiers that apply to the function. */
7114 build_this_parm (tree type, cp_cv_quals quals)
7119 cp_cv_quals this_quals;
7121 if (CLASS_TYPE_P (type))
7124 = cp_build_qualified_type (type, quals & ~TYPE_QUAL_RESTRICT);
7125 this_type = build_pointer_type (this_type);
7128 this_type = type_of_this_parm (type);
7129 /* The `this' parameter is implicitly `const'; it cannot be
7131 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
7132 qual_type = cp_build_qualified_type (this_type, this_quals);
7133 parm = build_artificial_parm (this_identifier, qual_type);
7134 cp_apply_type_quals_to_decl (this_quals, parm);
7138 /* DECL is a static member function. Complain if it was declared
7139 with function-cv-quals. */
7142 check_static_quals (tree decl, cp_cv_quals quals)
7144 if (quals != TYPE_UNQUALIFIED)
7145 error ("static member function %q#D declared with type qualifiers",
7149 /* CTYPE is class type, or null if non-class.
7150 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7152 DECLARATOR is the function's name.
7153 PARMS is a chain of PARM_DECLs for the function.
7154 VIRTUALP is truthvalue of whether the function is virtual or not.
7155 FLAGS are to be passed through to `grokclassfn'.
7156 QUALS are qualifiers indicating whether the function is `const'
7158 RAISES is a list of exceptions that this function can raise.
7159 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7160 not look, and -1 if we should not call `grokclassfn' at all.
7162 SFK is the kind of special function (if any) for the new function.
7164 Returns `NULL_TREE' if something goes wrong, after issuing
7165 applicable error messages. */
7168 grokfndecl (tree ctype,
7172 tree orig_declarator,
7174 enum overload_flags flags,
7181 special_function_kind sfk,
7186 location_t location)
7189 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
7193 type = build_exception_variant (type, raises);
7195 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
7197 /* If we have an explicit location, use it, otherwise use whatever
7198 build_lang_decl used (probably input_location). */
7199 if (location != UNKNOWN_LOCATION)
7200 DECL_SOURCE_LOCATION (decl) = location;
7202 if (TREE_CODE (type) == METHOD_TYPE)
7205 parm = build_this_parm (type, quals);
7206 DECL_CHAIN (parm) = parms;
7209 DECL_ARGUMENTS (decl) = parms;
7210 for (t = parms; t; t = DECL_CHAIN (t))
7211 DECL_CONTEXT (t) = decl;
7212 /* Propagate volatile out from type to decl. */
7213 if (TYPE_VOLATILE (type))
7214 TREE_THIS_VOLATILE (decl) = 1;
7216 /* Setup decl according to sfk. */
7219 case sfk_constructor:
7220 case sfk_copy_constructor:
7221 case sfk_move_constructor:
7222 DECL_CONSTRUCTOR_P (decl) = 1;
7224 case sfk_destructor:
7225 DECL_DESTRUCTOR_P (decl) = 1;
7231 /* If pointers to member functions use the least significant bit to
7232 indicate whether a function is virtual, ensure a pointer
7233 to this function will have that bit clear. */
7234 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
7235 && TREE_CODE (type) == METHOD_TYPE
7236 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
7237 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
7240 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7244 ("defining explicit specialization %qD in friend declaration",
7248 tree fns = TREE_OPERAND (orig_declarator, 0);
7249 tree args = TREE_OPERAND (orig_declarator, 1);
7251 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7253 /* Something like `template <class T> friend void f<T>()'. */
7254 error ("invalid use of template-id %qD in declaration "
7255 "of primary template",
7261 /* A friend declaration of the form friend void f<>(). Record
7262 the information in the TEMPLATE_ID_EXPR. */
7263 SET_DECL_IMPLICIT_INSTANTIATION (decl);
7265 if (TREE_CODE (fns) == COMPONENT_REF)
7267 /* Due to bison parser ickiness, we will have already looked
7268 up an operator_name or PFUNCNAME within the current class
7269 (see template_id in parse.y). If the current class contains
7270 such a name, we'll get a COMPONENT_REF here. Undo that. */
7272 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
7273 == current_class_type);
7274 fns = TREE_OPERAND (fns, 1);
7276 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
7277 || TREE_CODE (fns) == OVERLOAD);
7278 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
7280 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7281 if (TREE_PURPOSE (t)
7282 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7284 error ("default arguments are not allowed in declaration "
7285 "of friend template specialization %qD",
7292 error ("%<inline%> is not allowed in declaration of friend "
7293 "template specialization %qD",
7300 /* If this decl has namespace scope, set that up. */
7302 set_decl_namespace (decl, in_namespace, friendp);
7304 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
7306 /* `main' and builtins have implicit 'C' linkage. */
7307 if ((MAIN_NAME_P (declarator)
7308 || (IDENTIFIER_LENGTH (declarator) > 10
7309 && IDENTIFIER_POINTER (declarator)[0] == '_'
7310 && IDENTIFIER_POINTER (declarator)[1] == '_'
7311 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
7312 && current_lang_name == lang_name_cplusplus
7313 && ctype == NULL_TREE
7314 && DECL_FILE_SCOPE_P (decl))
7315 SET_DECL_LANGUAGE (decl, lang_c);
7317 /* Should probably propagate const out from type to decl I bet (mrs). */
7320 DECL_STATIC_FUNCTION_P (decl) = 1;
7321 DECL_CONTEXT (decl) = ctype;
7326 DECL_CONTEXT (decl) = ctype;
7328 check_class_member_definition_namespace (decl);
7331 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7333 if (processing_template_decl)
7334 error ("cannot declare %<::main%> to be a template");
7336 error ("cannot declare %<::main%> to be inline");
7338 error ("cannot declare %<::main%> to be static");
7343 /* Members of anonymous types and local classes have no linkage; make
7344 them internal. If a typedef is made later, this will be changed. */
7345 if (ctype && (TYPE_ANONYMOUS_P (ctype)
7346 || decl_function_context (TYPE_MAIN_DECL (ctype))))
7349 if (publicp && cxx_dialect == cxx98)
7351 /* [basic.link]: A name with no linkage (notably, the name of a class
7352 or enumeration declared in a local scope) shall not be used to
7353 declare an entity with linkage.
7355 DR 757 relaxes this restriction for C++0x. */
7356 t = no_linkage_check (TREE_TYPE (decl),
7357 /*relaxed_p=*/false);
7360 if (TYPE_ANONYMOUS_P (t))
7362 if (DECL_EXTERN_C_P (decl))
7363 /* Allow this; it's pretty common in C. */;
7366 permerror (input_location, "anonymous type with no linkage "
7367 "used to declare function %q#D with linkage",
7369 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7370 permerror (input_location, "%q+#D does not refer to the unqualified "
7371 "type, so it is not used for linkage",
7376 permerror (input_location, "type %qT with no linkage used to "
7377 "declare function %q#D with linkage", t, decl);
7381 TREE_PUBLIC (decl) = publicp;
7384 DECL_INTERFACE_KNOWN (decl) = 1;
7385 DECL_NOT_REALLY_EXTERN (decl) = 1;
7388 /* If the declaration was declared inline, mark it as such. */
7390 DECL_DECLARED_INLINE_P (decl) = 1;
7392 DECL_DECLARED_CONSTEXPR_P (decl) = true;
7394 DECL_EXTERNAL (decl) = 1;
7395 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
7398 ? G_("static member function %qD cannot have cv-qualifier")
7399 : G_("non-member function %qD cannot have cv-qualifier"),
7401 quals = TYPE_UNQUALIFIED;
7404 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
7405 && !grok_op_properties (decl, /*complain=*/true))
7407 else if (UDLIT_OPER_P (DECL_NAME (decl)))
7409 bool long_long_unsigned_p;
7411 const char *suffix = NULL;
7412 /* [over.literal]/6: Literal operators shall not have C linkage. */
7413 if (DECL_LANGUAGE (decl) == lang_c)
7415 error ("literal operator with C linkage");
7419 if (DECL_NAMESPACE_SCOPE_P (decl))
7421 if (!check_literal_operator_args (decl, &long_long_unsigned_p,
7424 error ("%qD has invalid argument list", decl);
7428 suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl));
7429 if (long_long_unsigned_p)
7431 if (cpp_interpret_int_suffix (suffix, strlen (suffix)))
7432 warning (0, "integer suffix %<%s%>"
7433 " shadowed by implementation", suffix);
7435 else if (long_double_p)
7437 if (cpp_interpret_float_suffix (suffix, strlen (suffix)))
7438 warning (0, "floating point suffix %<%s%>"
7439 " shadowed by implementation", suffix);
7444 error ("%qD must be a non-member function", decl);
7450 /* Make the init_value nonzero so pushdecl knows this is not
7451 tentative. error_mark_node is replaced later with the BLOCK. */
7452 DECL_INITIAL (decl) = error_mark_node;
7454 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
7455 TREE_NOTHROW (decl) = 1;
7457 /* Caller will do the rest of this. */
7461 if (ctype != NULL_TREE)
7462 grokclassfn (ctype, decl, flags);
7465 if (cxx_dialect >= cxx0x
7466 && DECL_DESTRUCTOR_P (decl)
7467 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl))
7468 && !processing_template_decl)
7469 deduce_noexcept_on_destructor (decl);
7471 decl = check_explicit_specialization (orig_declarator, decl,
7474 4 * (friendp != 0));
7475 if (decl == error_mark_node)
7478 if (DECL_STATIC_FUNCTION_P (decl))
7479 check_static_quals (decl, quals);
7483 cplus_decl_attributes (&decl, *attrlist, 0);
7484 *attrlist = NULL_TREE;
7487 /* Check main's type after attributes have been applied. */
7488 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7490 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
7493 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
7495 error ("%<::main%> must return %<int%>");
7496 newtype = build_function_type (integer_type_node, oldtypeargs);
7497 TREE_TYPE (decl) = newtype;
7500 check_main_parameter_types (decl);
7503 if (ctype != NULL_TREE
7504 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
7507 tree old_decl = check_classfn (ctype, decl,
7508 (processing_template_decl
7509 > template_class_depth (ctype))
7510 ? current_template_parms
7513 if (old_decl == error_mark_node)
7521 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
7522 /* Because grokfndecl is always supposed to return a
7523 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7524 here. We depend on our callers to figure out that its
7525 really a template that's being returned. */
7526 old_decl = DECL_TEMPLATE_RESULT (old_decl);
7528 if (DECL_STATIC_FUNCTION_P (old_decl)
7529 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
7531 /* Remove the `this' parm added by grokclassfn. */
7532 revert_static_member_fn (decl);
7533 check_static_quals (decl, quals);
7535 if (DECL_ARTIFICIAL (old_decl))
7537 error ("definition of implicitly-declared %qD", old_decl);
7540 else if (DECL_DEFAULTED_FN (old_decl))
7542 error ("definition of explicitly-defaulted %q+D", decl);
7543 error ("%q+#D explicitly defaulted here", old_decl);
7547 /* Since we've smashed OLD_DECL to its
7548 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7549 if (TREE_CODE (decl) == TEMPLATE_DECL)
7550 decl = DECL_TEMPLATE_RESULT (decl);
7552 /* Attempt to merge the declarations. This can fail, in
7553 the case of some invalid specialization declarations. */
7554 pushed_scope = push_scope (ctype);
7555 ok = duplicate_decls (decl, old_decl, friendp);
7557 pop_scope (pushed_scope);
7560 error ("no %q#D member function declared in class %qT",
7568 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
7571 if (ctype == NULL_TREE || check)
7575 DECL_VIRTUAL_P (decl) = 1;
7580 /* decl is a FUNCTION_DECL.
7581 specifiers are the parsed virt-specifiers.
7583 Set flags to reflect the virt-specifiers.
7588 set_virt_specifiers (tree decl, cp_virt_specifiers specifiers)
7590 if (decl == NULL_TREE)
7592 if (specifiers & VIRT_SPEC_OVERRIDE)
7593 DECL_OVERRIDE_P (decl) = 1;
7594 if (specifiers & VIRT_SPEC_FINAL)
7595 DECL_FINAL_P (decl) = 1;
7599 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7600 the linkage that DECL will receive in the object file. */
7603 set_linkage_for_static_data_member (tree decl)
7605 /* A static data member always has static storage duration and
7606 external linkage. Note that static data members are forbidden in
7607 local classes -- the only situation in which a class has
7608 non-external linkage. */
7609 TREE_PUBLIC (decl) = 1;
7610 TREE_STATIC (decl) = 1;
7611 /* For non-template classes, static data members are always put
7612 out in exactly those files where they are defined, just as
7613 with ordinary namespace-scope variables. */
7614 if (!processing_template_decl)
7615 DECL_INTERFACE_KNOWN (decl) = 1;
7618 /* Create a VAR_DECL named NAME with the indicated TYPE.
7620 If SCOPE is non-NULL, it is the class type or namespace containing
7621 the variable. If SCOPE is NULL, the variable should is created in
7622 the innermost enclosings scope. */
7625 grokvardecl (tree type,
7627 const cp_decl_specifier_seq *declspecs,
7633 tree explicit_scope;
7635 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
7637 /* Compute the scope in which to place the variable, but remember
7638 whether or not that scope was explicitly specified by the user. */
7639 explicit_scope = scope;
7642 /* An explicit "extern" specifier indicates a namespace-scope
7644 if (declspecs->storage_class == sc_extern)
7645 scope = current_decl_namespace ();
7646 else if (!at_function_scope_p ())
7647 scope = current_scope ();
7651 && (/* If the variable is a namespace-scope variable declared in a
7652 template, we need DECL_LANG_SPECIFIC. */
7653 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
7654 /* Similarly for namespace-scope variables with language linkage
7656 || (TREE_CODE (scope) == NAMESPACE_DECL
7657 && current_lang_name != lang_name_cplusplus)
7658 /* Similarly for static data members. */
7660 decl = build_lang_decl (VAR_DECL, name, type);
7662 decl = build_decl (input_location, VAR_DECL, name, type);
7664 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
7665 set_decl_namespace (decl, explicit_scope, 0);
7667 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
7669 if (declspecs->storage_class == sc_extern)
7671 DECL_THIS_EXTERN (decl) = 1;
7672 DECL_EXTERNAL (decl) = !initialized;
7675 if (DECL_CLASS_SCOPE_P (decl))
7677 set_linkage_for_static_data_member (decl);
7678 /* This function is only called with out-of-class definitions. */
7679 DECL_EXTERNAL (decl) = 0;
7680 check_class_member_definition_namespace (decl);
7682 /* At top level, either `static' or no s.c. makes a definition
7683 (perhaps tentative), and absence of `static' makes it public. */
7684 else if (toplevel_bindings_p ())
7686 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
7687 && (DECL_THIS_EXTERN (decl) || ! constp));
7688 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
7690 /* Not at top level, only `static' makes a static definition. */
7693 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
7694 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
7697 if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
7698 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
7700 /* If the type of the decl has no linkage, make sure that we'll
7701 notice that in mark_used. */
7702 if (cxx_dialect > cxx98
7703 && decl_linkage (decl) != lk_none
7704 && DECL_LANG_SPECIFIC (decl) == NULL
7705 && !DECL_EXTERN_C_P (decl)
7706 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
7707 retrofit_lang_decl (decl);
7709 if (TREE_PUBLIC (decl))
7711 /* [basic.link]: A name with no linkage (notably, the name of a class
7712 or enumeration declared in a local scope) shall not be used to
7713 declare an entity with linkage.
7715 DR 757 relaxes this restriction for C++0x. */
7716 tree t = (cxx_dialect > cxx98 ? NULL_TREE
7717 : no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false));
7720 if (TYPE_ANONYMOUS_P (t))
7722 if (DECL_EXTERN_C_P (decl))
7723 /* Allow this; it's pretty common in C. */
7727 /* DRs 132, 319 and 389 seem to indicate types with
7728 no linkage can only be used to declare extern "C"
7729 entities. Since it's not always an error in the
7730 ISO C++ 90 Standard, we only issue a warning. */
7731 warning (0, "anonymous type with no linkage used to declare "
7732 "variable %q#D with linkage", decl);
7733 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7734 warning (0, "%q+#D does not refer to the unqualified "
7735 "type, so it is not used for linkage",
7740 warning (0, "type %qT with no linkage used to declare variable "
7741 "%q#D with linkage", t, decl);
7745 DECL_INTERFACE_KNOWN (decl) = 1;
7750 /* Create and return a canonical pointer to member function type, for
7751 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7754 build_ptrmemfunc_type (tree type)
7758 tree unqualified_variant = NULL_TREE;
7760 if (type == error_mark_node)
7763 /* If a canonical type already exists for this type, use it. We use
7764 this method instead of type_hash_canon, because it only does a
7765 simple equality check on the list of field members. */
7767 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7770 /* Make sure that we always have the unqualified pointer-to-member
7772 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7774 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7776 t = make_class_type (RECORD_TYPE);
7777 xref_basetypes (t, NULL_TREE);
7779 /* Let the front end know this is a pointer to member function... */
7780 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7781 /* ... and not really a class type. */
7782 SET_CLASS_TYPE_P (t, 0);
7784 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
7787 field = build_decl (input_location, FIELD_DECL, delta_identifier,
7789 DECL_CHAIN (field) = fields;
7792 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7794 /* Zap out the name so that the back end will give us the debugging
7795 information for this anonymous RECORD_TYPE. */
7796 TYPE_NAME (t) = NULL_TREE;
7798 /* If this is not the unqualified form of this pointer-to-member
7799 type, set the TYPE_MAIN_VARIANT for this type to be the
7800 unqualified type. Since they are actually RECORD_TYPEs that are
7801 not variants of each other, we must do this manually.
7802 As we just built a new type there is no need to do yet another copy. */
7803 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7805 int type_quals = cp_type_quals (type);
7806 TYPE_READONLY (t) = (type_quals & TYPE_QUAL_CONST) != 0;
7807 TYPE_VOLATILE (t) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
7808 TYPE_RESTRICT (t) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
7809 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7810 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7811 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7812 TREE_TYPE (TYPE_BINFO (t)) = t;
7815 /* Cache this pointer-to-member type so that we can find it again
7817 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7819 if (TYPE_STRUCTURAL_EQUALITY_P (type))
7820 SET_TYPE_STRUCTURAL_EQUALITY (t);
7821 else if (TYPE_CANONICAL (type) != type)
7822 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
7827 /* Create and return a pointer to data member type. */
7830 build_ptrmem_type (tree class_type, tree member_type)
7832 if (TREE_CODE (member_type) == METHOD_TYPE)
7834 cp_cv_quals quals = type_memfn_quals (member_type);
7835 member_type = build_memfn_type (member_type, class_type, quals);
7836 return build_ptrmemfunc_type (build_pointer_type (member_type));
7840 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7841 return build_offset_type (class_type, member_type);
7845 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7846 Check to see that the definition is valid. Issue appropriate error
7847 messages. Return 1 if the definition is particularly bad, or 0
7851 check_static_variable_definition (tree decl, tree type)
7853 /* Can't check yet if we don't know the type. */
7854 if (dependent_type_p (type))
7856 /* If DECL is declared constexpr, we'll do the appropriate checks
7857 in check_initializer. */
7858 if (DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
7860 else if (cxx_dialect >= cxx0x && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7862 if (!COMPLETE_TYPE_P (type))
7863 error ("in-class initialization of static data member %q#D of "
7864 "incomplete type", decl);
7865 else if (literal_type_p (type))
7866 permerror (input_location,
7867 "%<constexpr%> needed for in-class initialization of "
7868 "static data member %q#D of non-integral type", decl);
7870 error ("in-class initialization of static data member %q#D of "
7871 "non-literal type", decl);
7875 /* Motion 10 at San Diego: If a static const integral data member is
7876 initialized with an integral constant expression, the initializer
7877 may appear either in the declaration (within the class), or in
7878 the definition, but not both. If it appears in the class, the
7879 member is a member constant. The file-scope definition is always
7881 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7883 error ("invalid in-class initialization of static data member "
7884 "of non-integral type %qT",
7888 else if (!CP_TYPE_CONST_P (type))
7889 error ("ISO C++ forbids in-class initialization of non-const "
7890 "static member %qD",
7892 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7893 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids initialization of member constant "
7894 "%qD of non-integral type %qT", decl, type);
7899 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
7900 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
7901 expressions out into temporary variables so that walk_tree doesn't
7902 step into them (c++/15764). */
7905 stabilize_save_expr_r (tree *expr_p, int *walk_subtrees, void *data)
7907 struct pointer_set_t *pset = (struct pointer_set_t *)data;
7908 tree expr = *expr_p;
7909 if (TREE_CODE (expr) == SAVE_EXPR)
7911 tree op = TREE_OPERAND (expr, 0);
7912 cp_walk_tree (&op, stabilize_save_expr_r, data, pset);
7913 if (TREE_SIDE_EFFECTS (op))
7914 TREE_OPERAND (expr, 0) = get_temp_regvar (TREE_TYPE (op), op);
7917 else if (!EXPR_P (expr) || !TREE_SIDE_EFFECTS (expr))
7922 /* Entry point for the above. */
7925 stabilize_vla_size (tree size)
7927 struct pointer_set_t *pset = pointer_set_create ();
7928 /* Break out any function calls into temporary variables. */
7929 cp_walk_tree (&size, stabilize_save_expr_r, pset, pset);
7932 /* Given the SIZE (i.e., number of elements) in an array, compute an
7933 appropriate index type for the array. If non-NULL, NAME is the
7934 name of the thing being declared. */
7937 compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
7941 tree abi_1_itype = NULL_TREE;
7943 if (error_operand_p (size))
7944 return error_mark_node;
7946 if (!type_dependent_expression_p (size))
7948 tree type = TREE_TYPE (size);
7950 mark_rvalue_use (size);
7952 if (cxx_dialect < cxx0x && TREE_CODE (size) == NOP_EXPR
7953 && TREE_SIDE_EFFECTS (size))
7954 /* In C++98, we mark a non-constant array bound with a magic
7955 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
7958 size = fold_non_dependent_expr (size);
7960 if (CLASS_TYPE_P (type)
7961 && CLASSTYPE_LITERAL_P (type))
7963 size = build_expr_type_conversion (WANT_INT, size, true);
7966 if (!(complain & tf_error))
7967 return error_mark_node;
7969 error ("size of array %qD has non-integral type %qT",
7972 error ("size of array has non-integral type %qT", type);
7973 size = integer_one_node;
7975 if (size == error_mark_node)
7976 return error_mark_node;
7977 type = TREE_TYPE (size);
7978 /* We didn't support this case in GCC 3.2, so don't bother
7979 trying to model it now in ABI v1. */
7980 abi_1_itype = error_mark_node;
7983 size = maybe_constant_value (size);
7984 if (!TREE_CONSTANT (size))
7988 if (error_operand_p (size))
7989 return error_mark_node;
7991 /* The array bound must be an integer type. */
7992 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
7994 if (!(complain & tf_error))
7995 return error_mark_node;
7997 error ("size of array %qD has non-integral type %qT", name, type);
7999 error ("size of array has non-integral type %qT", type);
8000 size = integer_one_node;
8001 type = TREE_TYPE (size);
8005 /* A type is dependent if it is...an array type constructed from any
8006 dependent type or whose size is specified by a constant expression
8007 that is value-dependent. */
8008 /* We can only call value_dependent_expression_p on integral constant
8009 expressions; treat non-constant expressions as dependent, too. */
8010 if (processing_template_decl
8011 && (type_dependent_expression_p (size)
8012 || !TREE_CONSTANT (size) || value_dependent_expression_p (size)))
8014 /* We cannot do any checking for a SIZE that isn't known to be
8015 constant. Just build the index type and mark that it requires
8016 structural equality checks. */
8017 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8018 size, integer_one_node));
8019 TYPE_DEPENDENT_P (itype) = 1;
8020 TYPE_DEPENDENT_P_VALID (itype) = 1;
8021 SET_TYPE_STRUCTURAL_EQUALITY (itype);
8025 if (!abi_version_at_least (2) && processing_template_decl
8026 && abi_1_itype == NULL_TREE)
8027 /* For abi-1, we handled all instances in templates the same way,
8028 even when they were non-dependent. This affects the manglings
8029 produced. So, we do the normal checking for non-dependent
8030 sizes, but at the end we'll return the same type that abi-1
8031 would have, but with TYPE_CANONICAL set to the "right"
8032 value that the current ABI would provide. */
8033 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8034 osize, integer_one_node));
8036 /* Normally, the array-bound will be a constant. */
8037 if (TREE_CODE (size) == INTEGER_CST)
8039 /* Check to see if the array bound overflowed. Make that an
8040 error, no matter how generous we're being. */
8041 constant_expression_error (size);
8043 /* An array must have a positive number of elements. */
8044 if (INT_CST_LT (size, integer_zero_node))
8046 if (!(complain & tf_error))
8047 return error_mark_node;
8049 error ("size of array %qD is negative", name);
8051 error ("size of array is negative");
8052 size = integer_one_node;
8054 /* As an extension we allow zero-sized arrays. */
8055 else if (integer_zerop (size))
8057 if (!(complain & tf_error))
8058 /* We must fail if performing argument deduction (as
8059 indicated by the state of complain), so that
8060 another substitution can be found. */
8061 return error_mark_node;
8062 else if (in_system_header)
8063 /* Allow them in system headers because glibc uses them. */;
8065 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
8067 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array");
8070 else if (TREE_CONSTANT (size)
8071 /* We don't allow VLAs at non-function scopes, or during
8072 tentative template substitution. */
8073 || !at_function_scope_p () || !(complain & tf_error))
8075 if (!(complain & tf_error))
8076 return error_mark_node;
8077 /* `(int) &fn' is not a valid array bound. */
8079 error ("size of array %qD is not an integral constant-expression",
8082 error ("size of array is not an integral constant-expression");
8083 size = integer_one_node;
8085 else if (pedantic && warn_vla != 0)
8088 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
8090 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
8092 else if (warn_vla > 0)
8096 "variable length array %qD is used", name);
8099 "variable length array is used");
8102 if (processing_template_decl && !TREE_CONSTANT (size))
8103 /* A variable sized array. */
8104 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
8107 HOST_WIDE_INT saved_processing_template_decl;
8109 /* Compute the index of the largest element in the array. It is
8110 one less than the number of elements in the array. We save
8111 and restore PROCESSING_TEMPLATE_DECL so that computations in
8112 cp_build_binary_op will be appropriately folded. */
8113 saved_processing_template_decl = processing_template_decl;
8114 processing_template_decl = 0;
8115 itype = cp_build_binary_op (input_location,
8117 cp_convert (ssizetype, size, complain),
8118 cp_convert (ssizetype, integer_one_node,
8121 itype = fold (itype);
8122 processing_template_decl = saved_processing_template_decl;
8124 if (!TREE_CONSTANT (itype))
8125 /* A variable sized array. */
8126 itype = variable_size (itype);
8127 /* Make sure that there was no overflow when creating to a signed
8128 index type. (For example, on a 32-bit machine, an array with
8129 size 2^32 - 1 is too big.) */
8130 else if (TREE_CODE (itype) == INTEGER_CST
8131 && TREE_OVERFLOW (itype))
8133 if (!(complain & tf_error))
8134 return error_mark_node;
8135 error ("overflow in array dimension");
8136 TREE_OVERFLOW (itype) = 0;
8140 /* Create and return the appropriate index type. */
8141 if (abi_1_itype && abi_1_itype != error_mark_node)
8143 tree t = build_index_type (itype);
8144 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
8145 itype = abi_1_itype;
8148 itype = build_index_type (itype);
8150 /* If the index type were dependent, we would have returned early, so
8151 remember that it isn't. */
8152 TYPE_DEPENDENT_P (itype) = 0;
8153 TYPE_DEPENDENT_P_VALID (itype) = 1;
8157 /* Returns the scope (if any) in which the entity declared by
8158 DECLARATOR will be located. If the entity was declared with an
8159 unqualified name, NULL_TREE is returned. */
8162 get_scope_of_declarator (const cp_declarator *declarator)
8164 while (declarator && declarator->kind != cdk_id)
8165 declarator = declarator->declarator;
8167 /* If the declarator-id is a SCOPE_REF, the scope in which the
8168 declaration occurs is the first operand. */
8170 && declarator->u.id.qualifying_scope)
8171 return declarator->u.id.qualifying_scope;
8173 /* Otherwise, the declarator is not a qualified name; the entity will
8174 be declared in the current scope. */
8178 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8179 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8183 create_array_type_for_decl (tree name, tree type, tree size)
8185 tree itype = NULL_TREE;
8187 /* If things have already gone awry, bail now. */
8188 if (type == error_mark_node || size == error_mark_node)
8189 return error_mark_node;
8191 /* 8.3.4/1: If the type of the identifier of D contains the auto
8192 type-specifier, the program is ill-formed. */
8193 if (pedantic && type_uses_auto (type))
8194 pedwarn (input_location, OPT_Wpedantic,
8195 "declaration of %qD as array of %<auto%>", name);
8197 /* If there are some types which cannot be array elements,
8198 issue an error-message and return. */
8199 switch (TREE_CODE (type))
8203 error ("declaration of %qD as array of void", name);
8205 error ("creating array of void");
8206 return error_mark_node;
8210 error ("declaration of %qD as array of functions", name);
8212 error ("creating array of functions");
8213 return error_mark_node;
8215 case REFERENCE_TYPE:
8217 error ("declaration of %qD as array of references", name);
8219 error ("creating array of references");
8220 return error_mark_node;
8224 error ("declaration of %qD as array of function members", name);
8226 error ("creating array of function members");
8227 return error_mark_node;
8235 The constant expressions that specify the bounds of the arrays
8236 can be omitted only for the first member of the sequence. */
8237 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
8240 error ("declaration of %qD as multidimensional array must "
8241 "have bounds for all dimensions except the first",
8244 error ("multidimensional array must have bounds for all "
8245 "dimensions except the first");
8247 return error_mark_node;
8250 /* Figure out the index type for the array. */
8252 itype = compute_array_index_type (name, size, tf_warning_or_error);
8255 T is called the array element type; this type shall not be [...] an
8256 abstract class type. */
8257 abstract_virtuals_error (name, type);
8259 return build_cplus_array_type (type, itype);
8262 /* Check that it's OK to declare a function with the indicated TYPE.
8263 SFK indicates the kind of special function (if any) that this
8264 function is. OPTYPE is the type given in a conversion operator
8265 declaration, or the class type for a constructor/destructor.
8266 Returns the actual return type of the function; that
8267 may be different than TYPE if an error occurs, or for certain
8268 special functions. */
8271 check_special_function_return_type (special_function_kind sfk,
8277 case sfk_constructor:
8279 error ("return type specification for constructor invalid");
8281 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8282 type = build_pointer_type (optype);
8284 type = void_type_node;
8287 case sfk_destructor:
8289 error ("return type specification for destructor invalid");
8290 /* We can't use the proper return type here because we run into
8291 problems with ambiguous bases and covariant returns.
8292 Java classes are left unchanged because (void *) isn't a valid
8293 Java type, and we don't want to change the Java ABI. */
8294 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8295 type = build_pointer_type (void_type_node);
8297 type = void_type_node;
8300 case sfk_conversion:
8302 error ("return type specified for %<operator %T%>", optype);
8313 /* A variable or data member (whose unqualified name is IDENTIFIER)
8314 has been declared with the indicated TYPE. If the TYPE is not
8315 acceptable, issue an error message and return a type to use for
8316 error-recovery purposes. */
8319 check_var_type (tree identifier, tree type)
8321 if (VOID_TYPE_P (type))
8324 error ("unnamed variable or field declared void");
8325 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
8327 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
8328 error ("variable or field %qE declared void", identifier);
8331 error ("variable or field declared void");
8332 type = error_mark_node;
8338 /* Given declspecs and a declarator (abstract or otherwise), determine
8339 the name and type of the object declared and construct a DECL node
8342 DECLSPECS points to the representation of declaration-specifier
8343 sequence that precedes declarator.
8345 DECL_CONTEXT says which syntactic context this declaration is in:
8346 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8347 FUNCDEF for a function definition. Like NORMAL but a few different
8348 error messages in each case. Return value may be zero meaning
8349 this definition is too screwy to try to parse.
8350 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8351 handle member functions (which have FIELD context).
8352 Return value may be zero meaning this definition is too screwy to
8354 PARM for a parameter declaration (either within a function prototype
8355 or before a function body). Make a PARM_DECL, or return void_type_node.
8356 TPARM for a template parameter declaration.
8357 CATCHPARM for a parameter declaration before a catch clause.
8358 TYPENAME if for a typename (in a cast or sizeof).
8359 Don't make a DECL node; just return the ..._TYPE node.
8360 FIELD for a struct or union field; make a FIELD_DECL.
8361 BITFIELD for a field with specified width.
8363 INITIALIZED is as for start_decl.
8365 ATTRLIST is a pointer to the list of attributes, which may be NULL
8366 if there are none; *ATTRLIST may be modified if attributes from inside
8367 the declarator should be applied to the declaration.
8369 When this function is called, scoping variables (such as
8370 CURRENT_CLASS_TYPE) should reflect the scope in which the
8371 declaration occurs, not the scope in which the new declaration will
8372 be placed. For example, on:
8376 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8379 Returns a DECL (if a declarator is present), a TYPE (if there is no
8380 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8384 grokdeclarator (const cp_declarator *declarator,
8385 const cp_decl_specifier_seq *declspecs,
8386 enum decl_context decl_context,
8390 tree type = NULL_TREE;
8392 int explicit_int128 = 0;
8393 int virtualp, explicitp, friendp, inlinep, staticp;
8394 int explicit_int = 0;
8395 int explicit_char = 0;
8396 int defaulted_int = 0;
8397 tree dependent_name = NULL_TREE;
8399 tree typedef_decl = NULL_TREE;
8400 const char *name = NULL;
8401 tree typedef_type = NULL_TREE;
8402 /* True if this declarator is a function definition. */
8403 bool funcdef_flag = false;
8404 cp_declarator_kind innermost_code = cdk_error;
8407 /* See the code below that used this. */
8408 tree decl_attr = NULL_TREE;
8411 /* Keep track of what sort of function is being processed
8412 so that we can warn about default return values, or explicit
8413 return values which do not match prescribed defaults. */
8414 special_function_kind sfk = sfk_none;
8416 tree dname = NULL_TREE;
8417 tree ctor_return_type = NULL_TREE;
8418 enum overload_flags flags = NO_SPECIAL;
8419 /* cv-qualifiers that apply to the declarator, for a declaration of
8420 a member function. */
8421 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
8422 /* virt-specifiers that apply to the declarator, for a declaration of
8423 a member function. */
8424 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
8425 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8427 tree raises = NULL_TREE;
8428 int template_count = 0;
8429 tree returned_attrs = NULL_TREE;
8430 tree parms = NULL_TREE;
8431 const cp_declarator *id_declarator;
8432 /* The unqualified name of the declarator; either an
8433 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8434 tree unqualified_id;
8435 /* The class type, if any, in which this entity is located,
8436 or NULL_TREE if none. Note that this value may be different from
8437 the current class type; for example if an attempt is made to declare
8438 "A::f" inside "B", this value will be "A". */
8439 tree ctype = current_class_type;
8440 /* The NAMESPACE_DECL for the namespace in which this entity is
8441 located. If an unqualified name is used to declare the entity,
8442 this value will be NULL_TREE, even if the entity is located at
8444 tree in_namespace = NULL_TREE;
8445 cp_storage_class storage_class;
8446 bool unsigned_p, signed_p, short_p, long_p, thread_p;
8447 bool type_was_error_mark_node = false;
8448 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
8449 bool template_type_arg = false;
8450 bool template_parm_flag = false;
8451 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr);
8454 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed);
8455 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned);
8456 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short);
8457 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long);
8458 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long);
8459 explicit_int128 = declspecs->explicit_int128_p;
8460 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread);
8462 if (decl_context == FUNCDEF)
8463 funcdef_flag = true, decl_context = NORMAL;
8464 else if (decl_context == MEMFUNCDEF)
8465 funcdef_flag = true, decl_context = FIELD;
8466 else if (decl_context == BITFIELD)
8467 bitfield = 1, decl_context = FIELD;
8468 else if (decl_context == TEMPLATE_TYPE_ARG)
8469 template_type_arg = true, decl_context = TYPENAME;
8470 else if (decl_context == TPARM)
8471 template_parm_flag = true, decl_context = PARM;
8473 if (initialized > 1)
8474 funcdef_flag = true;
8476 /* Look inside a declarator for the name being declared
8477 and get it as a string, for an error message. */
8478 for (id_declarator = declarator;
8480 id_declarator = id_declarator->declarator)
8482 if (id_declarator->kind != cdk_id)
8483 innermost_code = id_declarator->kind;
8485 switch (id_declarator->kind)
8488 if (id_declarator->declarator
8489 && id_declarator->declarator->kind == cdk_id)
8491 sfk = id_declarator->declarator->u.id.sfk;
8492 if (sfk == sfk_destructor)
8499 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
8500 tree decl = id_declarator->u.id.unqualified_name;
8503 if (qualifying_scope)
8505 if (at_function_scope_p ())
8509 A declarator-id shall not be qualified except
8512 None of the cases are permitted in block
8514 if (qualifying_scope == global_namespace)
8515 error ("invalid use of qualified-name %<::%D%>",
8517 else if (TYPE_P (qualifying_scope))
8518 error ("invalid use of qualified-name %<%T::%D%>",
8519 qualifying_scope, decl);
8521 error ("invalid use of qualified-name %<%D::%D%>",
8522 qualifying_scope, decl);
8523 return error_mark_node;
8525 else if (TYPE_P (qualifying_scope))
8527 ctype = qualifying_scope;
8528 if (!MAYBE_CLASS_TYPE_P (ctype))
8530 error ("%q#T is not a class or a namespace", ctype);
8533 else if (innermost_code != cdk_function
8534 && current_class_type
8535 && !uniquely_derived_from_p (ctype,
8536 current_class_type))
8538 error ("type %qT is not derived from type %qT",
8539 ctype, current_class_type);
8540 return error_mark_node;
8543 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
8544 in_namespace = qualifying_scope;
8546 switch (TREE_CODE (decl))
8552 if (innermost_code != cdk_function)
8554 error ("declaration of %qD as non-function", decl);
8555 return error_mark_node;
8557 else if (!qualifying_scope
8558 && !(current_class_type && at_class_scope_p ()))
8560 error ("declaration of %qD as non-member", decl);
8561 return error_mark_node;
8564 type = TREE_OPERAND (decl, 0);
8566 type = constructor_name (type);
8567 name = identifier_to_locale (IDENTIFIER_POINTER (type));
8572 case TEMPLATE_ID_EXPR:
8574 tree fns = TREE_OPERAND (decl, 0);
8577 if (TREE_CODE (dname) != IDENTIFIER_NODE)
8579 gcc_assert (is_overloaded_fn (dname));
8580 dname = DECL_NAME (get_first_fn (dname));
8585 case IDENTIFIER_NODE:
8586 if (TREE_CODE (decl) == IDENTIFIER_NODE)
8589 if (C_IS_RESERVED_WORD (dname))
8591 error ("declarator-id missing; using reserved word %qD",
8593 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8595 else if (!IDENTIFIER_TYPENAME_P (dname))
8596 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8599 gcc_assert (flags == NO_SPECIAL);
8600 flags = TYPENAME_FLAG;
8601 ctor_return_type = TREE_TYPE (dname);
8602 sfk = sfk_conversion;
8603 if (is_typename_at_global_scope (dname))
8604 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8606 name = "<invalid operator>";
8623 return error_mark_node;
8628 if (id_declarator->kind == cdk_id)
8634 The declarator in a function-definition shall have the form
8635 D1 ( parameter-declaration-clause) ... */
8636 if (funcdef_flag && innermost_code != cdk_function)
8638 error ("function definition does not declare parameters");
8639 return error_mark_node;
8642 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
8643 && innermost_code != cdk_function
8644 && ! (ctype && !declspecs->any_specifiers_p))
8646 error ("declaration of %qD as non-function", dname);
8647 return error_mark_node;
8651 && TREE_CODE (dname) == IDENTIFIER_NODE
8652 && UDLIT_OPER_P (dname)
8653 && innermost_code != cdk_function)
8655 error ("declaration of %qD as non-function", dname);
8656 return error_mark_node;
8659 if (dname && IDENTIFIER_OPNAME_P (dname))
8661 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
8663 error ("declaration of %qD as %<typedef%>", dname);
8664 return error_mark_node;
8666 else if (decl_context == PARM || decl_context == CATCHPARM)
8668 error ("declaration of %qD as parameter", dname);
8669 return error_mark_node;
8673 /* Anything declared one level down from the top level
8674 must be one of the parameters of a function
8675 (because the body is at least two levels down). */
8677 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8678 by not allowing C++ class definitions to specify their parameters
8679 with xdecls (must be spec.d in the parmlist).
8681 Since we now wait to push a class scope until we are sure that
8682 we are in a legitimate method context, we must set oldcname
8683 explicitly (since current_class_name is not yet alive).
8685 We also want to avoid calling this a PARM if it is in a namespace. */
8687 if (decl_context == NORMAL && !toplevel_bindings_p ())
8689 cp_binding_level *b = current_binding_level;
8690 current_binding_level = b->level_chain;
8691 if (current_binding_level != 0 && toplevel_bindings_p ())
8692 decl_context = PARM;
8693 current_binding_level = b;
8697 name = decl_context == PARM ? "parameter" : "type name";
8699 if (constexpr_p && decl_spec_seq_has_spec_p (declspecs, ds_typedef))
8701 error ("%<constexpr%> cannot appear in a typedef declaration");
8702 return error_mark_node;
8705 /* If there were multiple types specified in the decl-specifier-seq,
8706 issue an error message. */
8707 if (declspecs->multiple_types_p)
8709 error ("two or more data types in declaration of %qs", name);
8710 return error_mark_node;
8713 if (declspecs->conflicting_specifiers_p)
8715 error ("conflicting specifiers in declaration of %qs", name);
8716 return error_mark_node;
8719 /* Extract the basic type from the decl-specifier-seq. */
8720 type = declspecs->type;
8721 if (type == error_mark_node)
8724 type_was_error_mark_node = true;
8726 /* If the entire declaration is itself tagged as deprecated then
8727 suppress reports of deprecated items. */
8728 if (type && TREE_DEPRECATED (type)
8729 && deprecated_state != DEPRECATED_SUPPRESS)
8730 warn_deprecated_use (type, NULL_TREE);
8731 if (type && TREE_CODE (type) == TYPE_DECL)
8733 typedef_decl = type;
8734 type = TREE_TYPE (typedef_decl);
8735 if (TREE_DEPRECATED (type)
8736 && DECL_ARTIFICIAL (typedef_decl)
8737 && deprecated_state != DEPRECATED_SUPPRESS)
8738 warn_deprecated_use (type, NULL_TREE);
8740 /* No type at all: default to `int', and set DEFAULTED_INT
8741 because it was not a user-defined typedef. */
8742 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
8744 /* These imply 'int'. */
8745 type = integer_type_node;
8749 explicit_int = declspecs->explicit_int_p;
8750 explicit_char = declspecs->explicit_char_p;
8753 /* See the code below that used this. */
8755 decl_attr = DECL_ATTRIBUTES (typedef_decl);
8757 typedef_type = type;
8760 if (sfk != sfk_conversion)
8761 ctor_return_type = ctype;
8763 if (sfk != sfk_none)
8764 type = check_special_function_return_type (sfk, type,
8766 else if (type == NULL_TREE)
8772 /* We handle `main' specially here, because 'main () { }' is so
8773 common. With no options, it is allowed. With -Wreturn-type,
8774 it is a warning. It is only an error with -pedantic-errors. */
8775 is_main = (funcdef_flag
8776 && dname && TREE_CODE (dname) == IDENTIFIER_NODE
8777 && MAIN_NAME_P (dname)
8778 && ctype == NULL_TREE
8779 && in_namespace == NULL_TREE
8780 && current_namespace == global_namespace);
8782 if (type_was_error_mark_node)
8783 /* We've already issued an error, don't complain more. */;
8784 else if (in_system_header || flag_ms_extensions)
8785 /* Allow it, sigh. */;
8787 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
8789 pedwarn (input_location, OPT_Wpedantic,
8790 "ISO C++ forbids declaration of %qs with no type", name);
8792 warning (OPT_Wreturn_type,
8793 "ISO C++ forbids declaration of %qs with no type", name);
8795 type = integer_type_node;
8800 if (explicit_int128)
8802 if (int128_integer_type_node == NULL_TREE)
8804 error ("%<__int128%> is not supported by this target");
8805 explicit_int128 = false;
8807 else if (pedantic && ! in_system_header)
8808 pedwarn (input_location, OPT_Wpedantic,
8809 "ISO C++ does not support %<__int128%> for %qs", name);
8812 /* Now process the modifiers that were specified
8813 and check for invalid combinations. */
8815 /* Long double is a special combination. */
8816 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
8819 type = cp_build_qualified_type (long_double_type_node,
8820 cp_type_quals (type));
8823 /* Check all other uses of type modifiers. */
8825 if (unsigned_p || signed_p || long_p || short_p)
8829 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
8830 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
8831 else if (signed_p && unsigned_p)
8832 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
8833 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
8834 error ("%<long long%> invalid for %qs", name);
8835 else if (long_p && TREE_CODE (type) == REAL_TYPE)
8836 error ("%<long%> invalid for %qs", name);
8837 else if (short_p && TREE_CODE (type) == REAL_TYPE)
8838 error ("%<short%> invalid for %qs", name);
8839 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
8840 error ("%<long%> or %<short%> invalid for %qs", name);
8841 else if ((long_p || short_p || explicit_char || explicit_int) && explicit_int128)
8842 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
8843 else if ((long_p || short_p) && explicit_char)
8844 error ("%<long%> or %<short%> specified with char for %qs", name);
8845 else if (long_p && short_p)
8846 error ("%<long%> and %<short%> specified together for %qs", name);
8847 else if (type == char16_type_node || type == char32_type_node)
8849 if (signed_p || unsigned_p)
8850 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
8851 else if (short_p || long_p)
8852 error ("%<short%> or %<long%> invalid for %qs", name);
8857 if (!explicit_int && !defaulted_int && !explicit_char && !explicit_int128 && pedantic)
8859 pedwarn (input_location, OPT_Wpedantic,
8860 "long, short, signed or unsigned used invalidly for %qs",
8862 if (flag_pedantic_errors)
8867 /* Discard the type modifiers if they are invalid. */
8878 /* Decide whether an integer type is signed or not.
8879 Optionally treat bitfields as signed by default. */
8883 It is implementation-defined whether a plain (neither
8884 explicitly signed or unsigned) char, short, int, or long
8885 bit-field is signed or unsigned.
8887 Naturally, we extend this to long long as well. Note that
8888 this does not include wchar_t. */
8889 || (bitfield && !flag_signed_bitfields
8891 /* A typedef for plain `int' without `signed' can be
8892 controlled just like plain `int', but a typedef for
8893 `signed int' cannot be so controlled. */
8895 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
8896 && TREE_CODE (type) == INTEGER_TYPE
8897 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
8899 if (explicit_int128)
8900 type = int128_unsigned_type_node;
8902 type = long_long_unsigned_type_node;
8904 type = long_unsigned_type_node;
8906 type = short_unsigned_type_node;
8907 else if (type == char_type_node)
8908 type = unsigned_char_type_node;
8909 else if (typedef_decl)
8910 type = unsigned_type_for (type);
8912 type = unsigned_type_node;
8914 else if (signed_p && type == char_type_node)
8915 type = signed_char_type_node;
8916 else if (explicit_int128)
8917 type = int128_integer_type_node;
8919 type = long_long_integer_type_node;
8921 type = long_integer_type_node;
8923 type = short_integer_type_node;
8925 if (decl_spec_seq_has_spec_p (declspecs, ds_complex))
8927 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8928 error ("complex invalid for %qs", name);
8929 /* If we just have "complex", it is equivalent to
8930 "complex double", but if any modifiers at all are specified it is
8931 the complex form of TYPE. E.g, "complex short" is
8932 "complex short int". */
8933 else if (defaulted_int && ! longlong && ! explicit_int128
8934 && ! (long_p || short_p || signed_p || unsigned_p))
8935 type = complex_double_type_node;
8936 else if (type == integer_type_node)
8937 type = complex_integer_type_node;
8938 else if (type == float_type_node)
8939 type = complex_float_type_node;
8940 else if (type == double_type_node)
8941 type = complex_double_type_node;
8942 else if (type == long_double_type_node)
8943 type = complex_long_double_type_node;
8945 type = build_complex_type (type);
8948 type_quals = TYPE_UNQUALIFIED;
8949 if (decl_spec_seq_has_spec_p (declspecs, ds_const))
8950 type_quals |= TYPE_QUAL_CONST;
8951 if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
8952 type_quals |= TYPE_QUAL_VOLATILE;
8953 if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
8954 type_quals |= TYPE_QUAL_RESTRICT;
8955 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
8956 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8959 /* If we're using the injected-class-name to form a compound type or a
8960 declaration, replace it with the underlying class so we don't get
8961 redundant typedefs in the debug output. But if we are returning the
8962 type unchanged, leave it alone so that it's available to
8963 maybe_get_template_decl_from_type_decl. */
8964 if (CLASS_TYPE_P (type)
8965 && DECL_SELF_REFERENCE_P (TYPE_NAME (type))
8966 && type == TREE_TYPE (TYPE_NAME (type))
8967 && (declarator || type_quals))
8968 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
8970 type_quals |= cp_type_quals (type);
8971 type = cp_build_qualified_type_real
8972 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
8973 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
8974 /* We might have ignored or rejected some of the qualifiers. */
8975 type_quals = cp_type_quals (type);
8978 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline);
8979 virtualp = decl_spec_seq_has_spec_p (declspecs, ds_virtual);
8980 explicitp = decl_spec_seq_has_spec_p (declspecs, ds_explicit);
8982 storage_class = declspecs->storage_class;
8983 if (storage_class == sc_static)
8984 staticp = 1 + (decl_context == FIELD);
8986 if (virtualp && staticp == 2)
8988 error ("member %qD cannot be declared both virtual and static", dname);
8989 storage_class = sc_none;
8992 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
8994 if (dependent_name && !friendp)
8996 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
8997 return error_mark_node;
9000 /* Issue errors about use of storage classes for parameters. */
9001 if (decl_context == PARM)
9003 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9005 error ("typedef declaration invalid in parameter declaration");
9006 return error_mark_node;
9008 else if (template_parm_flag && storage_class != sc_none)
9010 error ("storage class specified for template parameter %qs", name);
9011 return error_mark_node;
9013 else if (storage_class == sc_static
9014 || storage_class == sc_extern
9016 error ("storage class specifiers invalid in parameter declarations");
9018 /* Function parameters cannot be constexpr. If we saw one, moan
9019 and pretend it wasn't there. */
9022 error ("a parameter cannot be declared %<constexpr%>");
9027 /* Give error if `virtual' is used outside of class declaration. */
9029 && (current_class_name == NULL_TREE || decl_context != FIELD))
9031 error ("%<virtual%> outside class declaration");
9035 /* Static anonymous unions are dealt with here. */
9036 if (staticp && decl_context == TYPENAME
9038 && ANON_AGGR_TYPE_P (declspecs->type))
9039 decl_context = FIELD;
9041 /* Warn about storage classes that are invalid for certain
9042 kinds of declarations (parameters, typenames, etc.). */
9045 && storage_class != sc_extern
9046 && storage_class != sc_static)
9047 || decl_spec_seq_has_spec_p (declspecs, ds_typedef)))
9049 error ("multiple storage classes in declaration of %qs", name);
9052 if (decl_context != NORMAL
9053 && ((storage_class != sc_none
9054 && storage_class != sc_mutable)
9057 if ((decl_context == PARM || decl_context == CATCHPARM)
9058 && (storage_class == sc_register
9059 || storage_class == sc_auto))
9061 else if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9063 else if (decl_context == FIELD
9064 /* C++ allows static class elements. */
9065 && storage_class == sc_static)
9066 /* C++ also allows inlines and signed and unsigned elements,
9067 but in those cases we don't come in here. */
9071 if (decl_context == FIELD)
9072 error ("storage class specified for %qs", name);
9075 if (decl_context == PARM || decl_context == CATCHPARM)
9076 error ("storage class specified for parameter %qs", name);
9078 error ("storage class specified for typename");
9080 if (storage_class == sc_register
9081 || storage_class == sc_auto
9082 || storage_class == sc_extern
9084 storage_class = sc_none;
9087 else if (storage_class == sc_extern && funcdef_flag
9088 && ! toplevel_bindings_p ())
9089 error ("nested function %qs declared %<extern%>", name);
9090 else if (toplevel_bindings_p ())
9092 if (storage_class == sc_auto)
9093 error ("top-level declaration of %qs specifies %<auto%>", name);
9096 && storage_class != sc_extern
9097 && storage_class != sc_static)
9099 error ("function-scope %qs implicitly auto and declared %<__thread%>",
9104 if (storage_class && friendp)
9106 error ("storage class specifiers invalid in friend function declarations");
9107 storage_class = sc_none;
9112 unqualified_id = NULL_TREE;
9115 unqualified_id = id_declarator->u.id.unqualified_name;
9116 switch (TREE_CODE (unqualified_id))
9119 unqualified_id = TREE_OPERAND (unqualified_id, 0);
9120 if (TYPE_P (unqualified_id))
9121 unqualified_id = constructor_name (unqualified_id);
9124 case IDENTIFIER_NODE:
9125 case TEMPLATE_ID_EXPR:
9133 /* Determine the type of the entity declared by recurring on the
9135 for (; declarator; declarator = declarator->declarator)
9137 const cp_declarator *inner_declarator;
9140 if (type == error_mark_node)
9141 return error_mark_node;
9143 attrs = declarator->attributes;
9149 if (declarator == NULL || declarator->kind == cdk_id)
9150 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
9151 if (declarator->kind == cdk_function)
9152 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
9153 if (declarator->kind == cdk_array)
9154 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
9155 returned_attrs = decl_attributes (&type,
9156 chainon (returned_attrs, attrs),
9160 if (declarator->kind == cdk_id)
9163 inner_declarator = declarator->declarator;
9165 switch (declarator->kind)
9168 type = create_array_type_for_decl (dname, type,
9169 declarator->u.array.bounds);
9177 /* Declaring a function type.
9178 Make sure we have a valid type for the function to return. */
9180 if (type_quals != TYPE_UNQUALIFIED)
9182 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
9183 warning (OPT_Wignored_qualifiers,
9184 "type qualifiers ignored on function return type");
9185 /* We now know that the TYPE_QUALS don't apply to the
9186 decl, but to its return type. */
9187 type_quals = TYPE_UNQUALIFIED;
9189 errmsg = targetm.invalid_return_type (type);
9193 type = integer_type_node;
9196 /* Error about some types functions can't return. */
9198 if (TREE_CODE (type) == FUNCTION_TYPE)
9200 error ("%qs declared as function returning a function", name);
9201 return error_mark_node;
9203 if (TREE_CODE (type) == ARRAY_TYPE)
9205 error ("%qs declared as function returning an array", name);
9206 return error_mark_node;
9208 /* When decl_context == NORMAL we emit a better error message
9209 later in abstract_virtuals_error. */
9210 if (decl_context == TYPENAME && ABSTRACT_CLASS_TYPE_P (type))
9211 error ("%qs declared as function returning an abstract "
9212 "class type", name);
9214 /* Pick up type qualifiers which should be applied to `this'. */
9215 memfn_quals = declarator->u.function.qualifiers;
9216 /* Pick up virt-specifiers. */
9217 virt_specifiers = declarator->u.function.virt_specifiers;
9218 /* Pick up the exception specifications. */
9219 raises = declarator->u.function.exception_specification;
9220 /* If the exception-specification is ill-formed, let's pretend
9221 there wasn't one. */
9222 if (raises == error_mark_node)
9225 /* Say it's a definition only for the CALL_EXPR
9226 closest to the identifier. */
9227 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
9229 /* Handle a late-specified return type. */
9232 if (type_uses_auto (type))
9234 if (!declarator->u.function.late_return_type)
9236 if (current_class_type
9237 && LAMBDA_TYPE_P (current_class_type))
9238 /* OK for C++11 lambdas. */;
9239 else if (cxx_dialect < cxx1y)
9240 pedwarn (input_location, 0, "%qs function uses "
9241 "%<auto%> type specifier without trailing "
9242 "return type", name);
9244 else if (!is_auto (type))
9246 error ("%qs function with trailing return type has"
9247 " %qT as its type rather than plain %<auto%>",
9249 return error_mark_node;
9252 else if (declarator->u.function.late_return_type)
9254 if (cxx_dialect < cxx0x)
9255 /* Not using maybe_warn_cpp0x because this should
9256 always be an error. */
9257 error ("trailing return type only available with "
9258 "-std=c++11 or -std=gnu++11");
9260 error ("%qs function with trailing return type not "
9261 "declared with %<auto%> type specifier", name);
9262 return error_mark_node;
9265 type = splice_late_return_type
9266 (type, declarator->u.function.late_return_type);
9267 if (type == error_mark_node)
9268 return error_mark_node;
9270 if (ctype == NULL_TREE
9271 && decl_context == FIELD
9273 && (friendp == 0 || dname == current_class_name))
9274 ctype = current_class_type;
9276 if (ctype && (sfk == sfk_constructor
9277 || sfk == sfk_destructor))
9279 /* We are within a class's scope. If our declarator name
9280 is the same as the class name, and we are defining
9281 a function, then it is a constructor/destructor, and
9282 therefore returns a void type. */
9284 /* ISO C++ 12.4/2. A destructor may not be declared
9285 const or volatile. A destructor may not be
9288 ISO C++ 12.1. A constructor may not be declared
9289 const or volatile. A constructor may not be
9290 virtual. A constructor may not be static. */
9292 error ((flags == DTOR_FLAG)
9293 ? G_("destructor cannot be static member function")
9294 : G_("constructor cannot be static member function"));
9297 error ((flags == DTOR_FLAG)
9298 ? G_("destructors may not be cv-qualified")
9299 : G_("constructors may not be cv-qualified"));
9300 memfn_quals = TYPE_UNQUALIFIED;
9303 if (decl_context == FIELD
9304 && !member_function_or_else (ctype,
9307 return error_mark_node;
9309 if (flags != DTOR_FLAG)
9311 /* It's a constructor. */
9316 permerror (input_location, "constructors cannot be declared virtual");
9319 if (decl_context == FIELD
9320 && sfk != sfk_constructor)
9321 return error_mark_node;
9323 if (decl_context == FIELD)
9329 error ("can%'t initialize friend function %qs", name);
9332 /* Cannot be both friend and virtual. */
9333 error ("virtual functions cannot be friends");
9336 if (decl_context == NORMAL)
9337 error ("friend declaration not in class definition");
9338 if (current_function_decl && funcdef_flag)
9339 error ("can%'t define friend function %qs in a local "
9343 else if (ctype && sfk == sfk_conversion)
9347 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION);
9352 arg_types = grokparms (declarator->u.function.parameters,
9355 if (inner_declarator
9356 && inner_declarator->kind == cdk_id
9357 && inner_declarator->u.id.sfk == sfk_destructor
9358 && arg_types != void_list_node)
9360 error ("destructors may not have parameters");
9361 arg_types = void_list_node;
9365 type = build_function_type (type, arg_types);
9372 /* Filter out pointers-to-references and references-to-references.
9373 We can get these if a TYPE_DECL is used. */
9375 if (TREE_CODE (type) == REFERENCE_TYPE)
9377 if (declarator->kind != cdk_reference)
9379 error ("cannot declare pointer to %q#T", type);
9380 type = TREE_TYPE (type);
9383 /* In C++0x, we allow reference to reference declarations
9384 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9385 and template type arguments [14.3.1/4 temp.arg.type]. The
9386 check for direct reference to reference declarations, which
9387 are still forbidden, occurs below. Reasoning behind the change
9388 can be found in DR106, DR540, and the rvalue reference
9390 else if (cxx_dialect == cxx98)
9392 error ("cannot declare reference to %q#T", type);
9393 type = TREE_TYPE (type);
9396 else if (VOID_TYPE_P (type))
9398 if (declarator->kind == cdk_reference)
9399 error ("cannot declare reference to %q#T", type);
9400 else if (declarator->kind == cdk_ptrmem)
9401 error ("cannot declare pointer to %q#T member", type);
9404 /* We now know that the TYPE_QUALS don't apply to the decl,
9405 but to the target of the pointer. */
9406 type_quals = TYPE_UNQUALIFIED;
9408 if (declarator->kind == cdk_ptrmem
9409 && (TREE_CODE (type) == FUNCTION_TYPE
9410 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
9412 memfn_quals |= type_memfn_quals (type);
9413 type = build_memfn_type (type,
9414 declarator->u.pointer.class_type,
9416 if (type == error_mark_node)
9417 return error_mark_node;
9418 memfn_quals = TYPE_UNQUALIFIED;
9421 if (TREE_CODE (type) == FUNCTION_TYPE
9422 && type_memfn_quals (type) != TYPE_UNQUALIFIED)
9423 error (declarator->kind == cdk_reference
9424 ? G_("cannot declare reference to qualified function type %qT")
9425 : G_("cannot declare pointer to qualified function type %qT"),
9428 /* When the pointed-to type involves components of variable size,
9429 care must be taken to ensure that the size evaluation code is
9430 emitted early enough to dominate all the possible later uses
9431 and late enough for the variables on which it depends to have
9434 This is expected to happen automatically when the pointed-to
9435 type has a name/declaration of it's own, but special attention
9436 is required if the type is anonymous.
9438 We handle the NORMAL and FIELD contexts here by inserting a
9439 dummy statement that just evaluates the size at a safe point
9440 and ensures it is not deferred until e.g. within a deeper
9441 conditional context (c++/43555).
9443 We expect nothing to be needed here for PARM or TYPENAME.
9444 Evaluating the size at this point for TYPENAME would
9445 actually be incorrect, as we might be in the middle of an
9446 expression with side effects on the pointed-to type size
9447 "arguments" prior to the pointer declaration point and the
9448 size evaluation could end up prior to the side effects. */
9450 if (!TYPE_NAME (type)
9451 && (decl_context == NORMAL || decl_context == FIELD)
9452 && at_function_scope_p ()
9453 && variably_modified_type_p (type, NULL_TREE))
9455 /* First break out any side-effects. */
9456 stabilize_vla_size (TYPE_SIZE (type));
9457 /* And then force evaluation of the SAVE_EXPR. */
9458 finish_expr_stmt (TYPE_SIZE (type));
9461 if (declarator->kind == cdk_reference)
9463 /* In C++0x, the type we are creating a reference to might be
9464 a typedef which is itself a reference type. In that case,
9465 we follow the reference collapsing rules in
9466 [7.1.3/8 dcl.typedef] to create the final reference type:
9468 "If a typedef TD names a type that is a reference to a type
9469 T, an attempt to create the type 'lvalue reference to cv TD'
9470 creates the type 'lvalue reference to T,' while an attempt
9471 to create the type "rvalue reference to cv TD' creates the
9474 if (VOID_TYPE_P (type))
9475 /* We already gave an error. */;
9476 else if (TREE_CODE (type) == REFERENCE_TYPE)
9478 if (declarator->u.reference.rvalue_ref)
9479 /* Leave type alone. */;
9481 type = cp_build_reference_type (TREE_TYPE (type), false);
9484 type = cp_build_reference_type
9485 (type, declarator->u.reference.rvalue_ref);
9487 /* In C++0x, we need this check for direct reference to
9488 reference declarations, which are forbidden by
9489 [8.3.2/5 dcl.ref]. Reference to reference declarations
9490 are only allowed indirectly through typedefs and template
9491 type arguments. Example:
9493 void foo(int & &); // invalid ref-to-ref decl
9495 typedef int & int_ref;
9496 void foo(int_ref &); // valid ref-to-ref decl
9498 if (inner_declarator && inner_declarator->kind == cdk_reference)
9499 error ("cannot declare reference to %q#T, which is not "
9500 "a typedef or a template type argument", type);
9502 else if (TREE_CODE (type) == METHOD_TYPE)
9503 type = build_ptrmemfunc_type (build_pointer_type (type));
9504 else if (declarator->kind == cdk_ptrmem)
9506 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
9508 if (declarator->u.pointer.class_type == error_mark_node)
9509 /* We will already have complained. */
9510 type = error_mark_node;
9512 type = build_ptrmem_type (declarator->u.pointer.class_type,
9516 type = build_pointer_type (type);
9518 /* Process a list of type modifier keywords (such as
9519 const or volatile) that were given inside the `*' or `&'. */
9521 if (declarator->u.pointer.qualifiers)
9524 = cp_build_qualified_type (type,
9525 declarator->u.pointer.qualifiers);
9526 type_quals = cp_type_quals (type);
9539 /* We need to stabilize side-effects in VLA sizes for regular array
9540 declarations too, not just pointers to arrays. */
9541 if (type != error_mark_node && !TYPE_NAME (type)
9542 && (decl_context == NORMAL || decl_context == FIELD)
9543 && at_function_scope_p ()
9544 && variably_modified_type_p (type, NULL_TREE))
9545 stabilize_vla_size (TYPE_SIZE (type));
9547 /* A `constexpr' specifier used in an object declaration declares
9548 the object as `const'. */
9549 if (constexpr_p && innermost_code != cdk_function)
9551 if (type_quals & TYPE_QUAL_VOLATILE)
9552 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9553 if (TREE_CODE (type) != REFERENCE_TYPE)
9555 type_quals |= TYPE_QUAL_CONST;
9556 type = cp_build_qualified_type (type, type_quals);
9560 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
9561 && TREE_CODE (type) != FUNCTION_TYPE
9562 && TREE_CODE (type) != METHOD_TYPE)
9564 error ("template-id %qD used as a declarator",
9566 unqualified_id = dname;
9569 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9570 qualified with a class-name, turn it into a METHOD_TYPE, unless
9571 we know that the function is static. We take advantage of this
9572 opportunity to do other processing that pertains to entities
9573 explicitly declared to be class members. Note that if DECLARATOR
9574 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9575 would not have exited the loop above. */
9577 && declarator->u.id.qualifying_scope
9578 && MAYBE_CLASS_TYPE_P (declarator->u.id.qualifying_scope))
9580 ctype = declarator->u.id.qualifying_scope;
9581 ctype = TYPE_MAIN_VARIANT (ctype);
9582 template_count = num_template_headers_for_class (ctype);
9584 if (ctype == current_class_type)
9588 permerror (input_location, "member functions are implicitly friends of their class");
9592 permerror (declarator->id_loc,
9593 "extra qualification %<%T::%> on member %qs",
9596 else if (/* If the qualifying type is already complete, then we
9597 can skip the following checks. */
9598 !COMPLETE_TYPE_P (ctype)
9599 && (/* If the function is being defined, then
9600 qualifying type must certainly be complete. */
9602 /* A friend declaration of "T::f" is OK, even if
9603 "T" is a template parameter. But, if this
9604 function is not a friend, the qualifying type
9606 || (!friendp && !CLASS_TYPE_P (ctype))
9607 /* For a declaration, the type need not be
9608 complete, if either it is dependent (since there
9609 is no meaningful definition of complete in that
9610 case) or the qualifying class is currently being
9612 || !(dependent_type_p (ctype)
9613 || currently_open_class (ctype)))
9614 /* Check that the qualifying type is complete. */
9615 && !complete_type_or_else (ctype, NULL_TREE))
9616 return error_mark_node;
9617 else if (TREE_CODE (type) == FUNCTION_TYPE)
9619 if (current_class_type
9620 && (!friendp || funcdef_flag))
9623 ? G_("cannot define member function %<%T::%s%> "
9625 : G_("cannot declare member function %<%T::%s%> "
9627 ctype, name, current_class_type);
9628 return error_mark_node;
9631 else if (decl_spec_seq_has_spec_p (declspecs, ds_typedef)
9632 && current_class_type)
9634 error ("cannot declare member %<%T::%s%> within %qT",
9635 ctype, name, current_class_type);
9636 return error_mark_node;
9640 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0)
9641 ctype = current_class_type;
9643 /* Now TYPE has the actual type. */
9648 *attrlist = chainon (returned_attrs, *attrlist);
9650 attrlist = &returned_attrs;
9653 /* Handle parameter packs. */
9654 if (parameter_pack_p)
9656 if (decl_context == PARM)
9657 /* Turn the type into a pack expansion.*/
9658 type = make_pack_expansion (type);
9660 error ("non-parameter %qs cannot be a parameter pack", name);
9663 /* Did array size calculations overflow or does the array cover more
9664 than half of the address-space? */
9665 if (TREE_CODE (type) == ARRAY_TYPE
9666 && COMPLETE_TYPE_P (type)
9667 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
9668 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type)))
9670 error ("size of array %qs is too large", name);
9671 /* If we proceed with the array type as it is, we'll eventually
9672 crash in tree_low_cst(). */
9673 type = error_mark_node;
9676 if ((decl_context == FIELD || decl_context == PARM)
9677 && !processing_template_decl
9678 && variably_modified_type_p (type, NULL_TREE))
9680 if (decl_context == FIELD)
9681 error ("data member may not have variably modified type %qT", type);
9683 error ("parameter may not have variably modified type %qT", type);
9684 type = error_mark_node;
9687 if (explicitp == 1 || (explicitp && friendp))
9689 /* [dcl.fct.spec] The explicit specifier shall only be used in
9690 declarations of constructors within a class definition. */
9691 error ("only declarations of constructors can be %<explicit%>");
9695 if (storage_class == sc_mutable)
9697 if (decl_context != FIELD || friendp)
9699 error ("non-member %qs cannot be declared %<mutable%>", name);
9700 storage_class = sc_none;
9702 else if (decl_context == TYPENAME
9703 || decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9705 error ("non-object member %qs cannot be declared %<mutable%>", name);
9706 storage_class = sc_none;
9708 else if (TREE_CODE (type) == FUNCTION_TYPE
9709 || TREE_CODE (type) == METHOD_TYPE)
9711 error ("function %qs cannot be declared %<mutable%>", name);
9712 storage_class = sc_none;
9716 error ("static %qs cannot be declared %<mutable%>", name);
9717 storage_class = sc_none;
9719 else if (type_quals & TYPE_QUAL_CONST)
9721 error ("const %qs cannot be declared %<mutable%>", name);
9722 storage_class = sc_none;
9724 else if (TREE_CODE (type) == REFERENCE_TYPE)
9726 permerror (input_location, "reference %qs cannot be declared "
9727 "%<mutable%>", name);
9728 storage_class = sc_none;
9732 /* If this is declaring a typedef name, return a TYPE_DECL. */
9733 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef) && decl_context != TYPENAME)
9737 /* Note that the grammar rejects storage classes
9738 in typenames, fields or parameters. */
9739 if (current_lang_name == lang_name_java)
9740 TYPE_FOR_JAVA (type) = 1;
9742 /* This declaration:
9744 typedef void f(int) const;
9746 declares a function type which is not a member of any
9747 particular class, but which is cv-qualified; for
9748 example "f S::*" declares a pointer to a const-qualified
9749 member function of S. We record the cv-qualification in the
9751 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
9753 type = apply_memfn_quals (type, memfn_quals);
9755 /* We have now dealt with these qualifiers. */
9756 memfn_quals = TYPE_UNQUALIFIED;
9759 if (type_uses_auto (type))
9761 error ("typedef declared %<auto%>");
9762 type = error_mark_node;
9765 if (decl_context == FIELD)
9766 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
9768 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
9769 if (id_declarator && declarator->u.id.qualifying_scope) {
9770 error_at (DECL_SOURCE_LOCATION (decl),
9771 "typedef name may not be a nested-name-specifier");
9772 TREE_TYPE (decl) = error_mark_node;
9775 if (decl_context != FIELD)
9777 if (!current_function_decl)
9778 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
9779 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
9780 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
9781 (current_function_decl)))
9782 /* The TYPE_DECL is "abstract" because there will be
9783 clones of this constructor/destructor, and there will
9784 be copies of this TYPE_DECL generated in those
9786 DECL_ABSTRACT (decl) = 1;
9788 else if (current_class_type
9789 && constructor_name_p (unqualified_id, current_class_type))
9790 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
9791 "as enclosing class",
9794 /* If the user declares "typedef struct {...} foo" then the
9795 struct will have an anonymous name. Fill that name in now.
9796 Nothing can refer to it, so nothing needs know about the name
9798 if (type != error_mark_node
9801 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9802 && TYPE_ANONYMOUS_P (type)
9803 && declspecs->type_definition_p
9804 && cp_type_quals (type) == TYPE_UNQUALIFIED)
9808 /* Replace the anonymous name with the real name everywhere. */
9809 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
9811 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
9812 /* We do not rename the debug info representing the
9813 anonymous tagged type because the standard says in
9814 [dcl.typedef] that the naming applies only for
9815 linkage purposes. */
9816 /*debug_hooks->set_name (t, decl);*/
9817 TYPE_NAME (t) = decl;
9820 if (TYPE_LANG_SPECIFIC (type))
9821 TYPE_WAS_ANONYMOUS (type) = 1;
9823 /* If this is a typedef within a template class, the nested
9824 type is a (non-primary) template. The name for the
9825 template needs updating as well. */
9826 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
9827 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
9828 = TYPE_IDENTIFIER (type);
9830 /* Adjust linkage now that we aren't anonymous anymore. */
9831 set_linkage_according_to_type (type, TYPE_MAIN_DECL (type));
9832 determine_visibility (TYPE_MAIN_DECL (type));
9834 /* FIXME remangle member functions; member functions of a
9835 type with external linkage have external linkage. */
9839 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
9840 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
9842 bad_specifiers (decl, BSP_TYPE, virtualp,
9843 memfn_quals != TYPE_UNQUALIFIED,
9844 inlinep, friendp, raises != NULL_TREE);
9846 if (decl_spec_seq_has_spec_p (declspecs, ds_alias))
9847 /* Acknowledge that this was written:
9848 `using analias = atype;'. */
9849 TYPE_DECL_ALIAS_P (decl) = 1;
9854 /* Detect the case of an array type of unspecified size
9855 which came, as such, direct from a typedef name.
9856 We must copy the type, so that the array's domain can be
9857 individually set by the object's initializer. */
9859 if (type && typedef_type
9860 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
9861 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
9862 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
9864 /* Detect where we're using a typedef of function type to declare a
9865 function. PARMS will not be set, so we must create it now. */
9867 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
9869 tree decls = NULL_TREE;
9872 for (args = TYPE_ARG_TYPES (type);
9873 args && args != void_list_node;
9874 args = TREE_CHAIN (args))
9876 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
9878 DECL_CHAIN (decl) = decls;
9882 parms = nreverse (decls);
9884 if (decl_context != TYPENAME)
9886 /* A cv-qualifier-seq shall only be part of the function type
9887 for a non-static member function. [8.3.5/4 dcl.fct] */
9888 if (type_memfn_quals (type) != TYPE_UNQUALIFIED
9889 && (current_class_type == NULL_TREE || staticp) )
9892 ? G_("qualified function types cannot be used to "
9893 "declare static member functions")
9894 : G_("qualified function types cannot be used to "
9895 "declare free functions"));
9896 type = TYPE_MAIN_VARIANT (type);
9899 /* The qualifiers on the function type become the qualifiers on
9900 the non-static member function. */
9901 memfn_quals |= type_memfn_quals (type);
9902 type_quals = TYPE_UNQUALIFIED;
9906 /* If this is a type name (such as, in a cast or sizeof),
9907 compute the type and return it now. */
9909 if (decl_context == TYPENAME)
9911 /* Note that the grammar rejects storage classes
9912 in typenames, fields or parameters. */
9913 if (type_quals != TYPE_UNQUALIFIED)
9914 type_quals = TYPE_UNQUALIFIED;
9916 /* Special case: "friend class foo" looks like a TYPENAME context. */
9919 if (type_quals != TYPE_UNQUALIFIED)
9921 error ("type qualifiers specified for friend class declaration");
9922 type_quals = TYPE_UNQUALIFIED;
9926 error ("%<inline%> specified for friend class declaration");
9932 /* Don't allow friend declaration without a class-key. */
9933 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9934 permerror (input_location, "template parameters cannot be friends");
9935 else if (TREE_CODE (type) == TYPENAME_TYPE)
9936 permerror (input_location, "friend declaration requires class-key, "
9937 "i.e. %<friend class %T::%D%>",
9938 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
9940 permerror (input_location, "friend declaration requires class-key, "
9941 "i.e. %<friend %#T%>",
9945 /* Only try to do this stuff if we didn't already give up. */
9946 if (type != integer_type_node)
9948 /* A friendly class? */
9949 if (current_class_type)
9950 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
9953 error ("trying to make class %qT a friend of global scope",
9956 type = void_type_node;
9959 else if (memfn_quals)
9961 if (ctype == NULL_TREE
9962 && TREE_CODE (type) == METHOD_TYPE)
9963 ctype = TYPE_METHOD_BASETYPE (type);
9966 type = build_memfn_type (type, ctype, memfn_quals);
9967 /* Core issue #547: need to allow this in template type args. */
9968 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
9969 type = apply_memfn_quals (type, memfn_quals);
9971 error ("invalid qualifiers on non-member function type");
9976 else if (unqualified_id == NULL_TREE && decl_context != PARM
9977 && decl_context != CATCHPARM
9978 && TREE_CODE (type) != UNION_TYPE
9981 error ("abstract declarator %qT used as declaration", type);
9982 return error_mark_node;
9985 /* Only functions may be declared using an operator-function-id. */
9987 && IDENTIFIER_OPNAME_P (unqualified_id)
9988 && TREE_CODE (type) != FUNCTION_TYPE
9989 && TREE_CODE (type) != METHOD_TYPE)
9991 error ("declaration of %qD as non-function", unqualified_id);
9992 return error_mark_node;
9995 /* We don't check parameter types here because we can emit a better
9996 error message later. */
9997 if (decl_context != PARM)
9999 type = check_var_type (unqualified_id, type);
10000 if (type == error_mark_node)
10001 return error_mark_node;
10004 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10005 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10007 if (decl_context == PARM || decl_context == CATCHPARM)
10009 if (ctype || in_namespace)
10010 error ("cannot use %<::%> in parameter declaration");
10012 if (type_uses_auto (type))
10014 error ("parameter declared %<auto%>");
10015 type = error_mark_node;
10018 /* A parameter declared as an array of T is really a pointer to T.
10019 One declared as a function is really a pointer to a function.
10020 One declared as a member is really a pointer to member. */
10022 if (TREE_CODE (type) == ARRAY_TYPE)
10024 /* Transfer const-ness of array into that of type pointed to. */
10025 type = build_pointer_type (TREE_TYPE (type));
10026 type_quals = TYPE_UNQUALIFIED;
10028 else if (TREE_CODE (type) == FUNCTION_TYPE)
10029 type = build_pointer_type (type);
10032 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
10033 && !NEW_DELETE_OPNAME_P (unqualified_id))
10035 cp_cv_quals real_quals = memfn_quals;
10036 if (constexpr_p && sfk != sfk_constructor && sfk != sfk_destructor)
10037 real_quals |= TYPE_QUAL_CONST;
10038 type = build_memfn_type (type, ctype, real_quals);
10044 if (decl_context == PARM)
10046 decl = cp_build_parm_decl (unqualified_id, type);
10048 bad_specifiers (decl, BSP_PARM, virtualp,
10049 memfn_quals != TYPE_UNQUALIFIED,
10050 inlinep, friendp, raises != NULL_TREE);
10052 else if (decl_context == FIELD)
10054 if (!staticp && TREE_CODE (type) != METHOD_TYPE
10055 && type_uses_auto (type))
10057 error ("non-static data member declared %<auto%>");
10058 type = error_mark_node;
10061 /* The C99 flexible array extension. */
10062 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
10063 && TYPE_DOMAIN (type) == NULL_TREE)
10065 tree itype = compute_array_index_type (dname, integer_zero_node,
10066 tf_warning_or_error);
10067 type = build_cplus_array_type (TREE_TYPE (type), itype);
10070 if (type == error_mark_node)
10072 /* Happens when declaring arrays of sizes which
10073 are error_mark_node, for example. */
10076 else if (in_namespace && !friendp)
10078 /* Something like struct S { int N::j; }; */
10079 error ("invalid use of %<::%>");
10080 return error_mark_node;
10082 else if (TREE_CODE (type) == FUNCTION_TYPE
10083 || TREE_CODE (type) == METHOD_TYPE)
10086 tree function_context;
10090 /* This should never happen in pure C++ (the check
10091 could be an assert). It could happen in
10092 Objective-C++ if someone writes invalid code that
10093 uses a function declaration for an instance
10094 variable or property (instance variables and
10095 properties are parsed as FIELD_DECLs, but they are
10096 part of an Objective-C class, not a C++ class).
10097 That code is invalid and is caught by this
10101 error ("declaration of function %qD in invalid context",
10103 return error_mark_node;
10106 /* ``A union may [ ... ] not [ have ] virtual functions.''
10108 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10110 error ("function %qD declared virtual inside a union",
10112 return error_mark_node;
10115 if (NEW_DELETE_OPNAME_P (unqualified_id))
10119 error ("%qD cannot be declared virtual, since it "
10120 "is always static",
10127 /* Check that the name used for a destructor makes sense. */
10128 if (sfk == sfk_destructor)
10130 tree uqname = id_declarator->u.id.unqualified_name;
10134 gcc_assert (friendp);
10135 error ("expected qualified name in friend declaration "
10136 "for destructor %qD", uqname);
10137 return error_mark_node;
10140 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
10142 error ("declaration of %qD as member of %qT",
10144 return error_mark_node;
10148 error ("a destructor cannot be %<constexpr%>");
10149 return error_mark_node;
10152 else if (sfk == sfk_constructor && friendp && !ctype)
10154 error ("expected qualified name in friend declaration "
10155 "for constructor %qD",
10156 id_declarator->u.id.unqualified_name);
10157 return error_mark_node;
10160 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10161 function_context = (ctype != NULL_TREE) ?
10162 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10163 publicp = (! friendp || ! staticp)
10164 && function_context == NULL_TREE;
10165 decl = grokfndecl (ctype, type,
10166 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
10167 ? unqualified_id : dname,
10170 virtualp, flags, memfn_quals, raises,
10171 friendp ? -1 : 0, friendp, publicp,
10172 inlinep | (2 * constexpr_p),
10174 funcdef_flag, template_count, in_namespace,
10175 attrlist, declarator->id_loc);
10176 decl = set_virt_specifiers (decl, virt_specifiers);
10177 if (decl == NULL_TREE)
10178 return error_mark_node;
10180 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10181 /* The decl and setting of decl_attr is also turned off. */
10182 decl = build_decl_attribute_variant (decl, decl_attr);
10185 /* [class.conv.ctor]
10187 A constructor declared without the function-specifier
10188 explicit that can be called with a single parameter
10189 specifies a conversion from the type of its first
10190 parameter to the type of its class. Such a constructor
10191 is called a converting constructor. */
10192 if (explicitp == 2)
10193 DECL_NONCONVERTING_P (decl) = 1;
10195 else if (!staticp && !dependent_type_p (type)
10196 && !COMPLETE_TYPE_P (complete_type (type))
10197 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
10199 if (unqualified_id)
10200 error ("field %qD has incomplete type", unqualified_id);
10202 error ("name %qT has incomplete type", type);
10204 /* If we're instantiating a template, tell them which
10205 instantiation made the field's type be incomplete. */
10206 if (current_class_type
10207 && TYPE_NAME (current_class_type)
10208 && IDENTIFIER_TEMPLATE (current_class_name)
10210 && declspecs->type == type)
10211 error (" in instantiation of template %qT",
10212 current_class_type);
10214 return error_mark_node;
10220 error ("%qE is neither function nor member function; "
10221 "cannot be declared friend", unqualified_id);
10229 /* Friends are treated specially. */
10230 if (ctype == current_class_type)
10231 ; /* We already issued a permerror. */
10232 else if (decl && DECL_NAME (decl))
10234 if (template_class_depth (current_class_type) == 0)
10236 decl = check_explicit_specialization
10237 (unqualified_id, decl, template_count,
10238 2 * funcdef_flag + 4);
10239 if (decl == error_mark_node)
10240 return error_mark_node;
10243 decl = do_friend (ctype, unqualified_id, decl,
10249 return error_mark_node;
10252 /* Structure field. It may not be a function, except for C++. */
10254 if (decl == NULL_TREE)
10258 /* C++ allows static class members. All other work
10259 for this is done by grokfield. */
10260 decl = build_lang_decl_loc (declarator->id_loc,
10261 VAR_DECL, unqualified_id, type);
10262 set_linkage_for_static_data_member (decl);
10263 /* Even if there is an in-class initialization, DECL
10264 is considered undefined until an out-of-class
10265 definition is provided. */
10266 DECL_EXTERNAL (decl) = 1;
10269 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
10271 if (constexpr_p && !initialized)
10273 error ("constexpr static data member %qD must have an "
10274 "initializer", decl);
10275 constexpr_p = false;
10282 error ("non-static data member %qE declared %<constexpr%>",
10284 constexpr_p = false;
10286 decl = build_decl (input_location,
10287 FIELD_DECL, unqualified_id, type);
10288 DECL_NONADDRESSABLE_P (decl) = bitfield;
10289 if (bitfield && !unqualified_id)
10290 TREE_NO_WARNING (decl) = 1;
10292 if (storage_class == sc_mutable)
10294 DECL_MUTABLE_P (decl) = 1;
10295 storage_class = sc_none;
10300 /* An attempt is being made to initialize a non-static
10301 member. This is new in C++11. */
10302 maybe_warn_cpp0x (CPP0X_NSDMI);
10304 /* If this has been parsed with static storage class, but
10305 errors forced staticp to be cleared, ensure NSDMI is
10307 if (declspecs->storage_class == sc_static)
10308 DECL_INITIAL (decl) = error_mark_node;
10312 bad_specifiers (decl, BSP_FIELD, virtualp,
10313 memfn_quals != TYPE_UNQUALIFIED,
10314 inlinep, friendp, raises != NULL_TREE);
10317 else if (TREE_CODE (type) == FUNCTION_TYPE
10318 || TREE_CODE (type) == METHOD_TYPE)
10320 tree original_name;
10323 if (!unqualified_id)
10324 return error_mark_node;
10326 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
10327 original_name = dname;
10329 original_name = unqualified_id;
10331 if (storage_class == sc_auto)
10332 error ("storage class %<auto%> invalid for function %qs", name);
10333 else if (storage_class == sc_register)
10334 error ("storage class %<register%> invalid for function %qs", name);
10336 error ("storage class %<__thread%> invalid for function %qs", name);
10338 if (virt_specifiers)
10339 error ("virt-specifiers in %qs not allowed outside a class definition", name);
10340 /* Function declaration not at top level.
10341 Storage classes other than `extern' are not allowed
10342 and `extern' makes no difference. */
10343 if (! toplevel_bindings_p ()
10344 && (storage_class == sc_static
10345 || decl_spec_seq_has_spec_p (declspecs, ds_inline))
10348 if (storage_class == sc_static)
10349 pedwarn (input_location, OPT_Wpedantic,
10350 "%<static%> specified invalid for function %qs "
10351 "declared out of global scope", name);
10353 pedwarn (input_location, OPT_Wpedantic,
10354 "%<inline%> specifier invalid for function %qs "
10355 "declared out of global scope", name);
10358 if (ctype == NULL_TREE)
10362 error ("virtual non-class function %qs", name);
10365 else if (sfk == sfk_constructor
10366 || sfk == sfk_destructor)
10368 error (funcdef_flag
10369 ? G_("%qs defined in a non-class scope")
10370 : G_("%qs declared in a non-class scope"), name);
10375 /* Record presence of `static'. */
10376 publicp = (ctype != NULL_TREE
10377 || storage_class == sc_extern
10378 || storage_class != sc_static);
10380 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
10381 virtualp, flags, memfn_quals, raises,
10383 publicp, inlinep | (2 * constexpr_p), sfk,
10385 template_count, in_namespace, attrlist,
10386 declarator->id_loc);
10387 if (decl == NULL_TREE)
10388 return error_mark_node;
10392 int invalid_static = 0;
10394 /* Don't allow a static member function in a class, and forbid
10395 declaring main to be static. */
10396 if (TREE_CODE (type) == METHOD_TYPE)
10398 permerror (input_location, "cannot declare member function %qD to have "
10399 "static linkage", decl);
10400 invalid_static = 1;
10402 else if (current_function_decl)
10404 /* FIXME need arm citation */
10405 error ("cannot declare static function inside another function");
10406 invalid_static = 1;
10409 if (invalid_static)
10412 storage_class = sc_none;
10418 /* It's a variable. */
10420 /* An uninitialized decl with `extern' is a reference. */
10421 decl = grokvardecl (type, unqualified_id,
10424 (type_quals & TYPE_QUAL_CONST) != 0,
10425 ctype ? ctype : in_namespace);
10426 bad_specifiers (decl, BSP_VAR, virtualp,
10427 memfn_quals != TYPE_UNQUALIFIED,
10428 inlinep, friendp, raises != NULL_TREE);
10432 DECL_CONTEXT (decl) = ctype;
10435 permerror (input_location, "%<static%> may not be used when defining "
10436 "(as opposed to declaring) a static data member");
10438 storage_class = sc_none;
10440 if (storage_class == sc_register && TREE_STATIC (decl))
10442 error ("static member %qD declared %<register%>", decl);
10443 storage_class = sc_none;
10445 if (storage_class == sc_extern && pedantic)
10447 pedwarn (input_location, OPT_Wpedantic,
10448 "cannot explicitly declare member %q#D to have "
10449 "extern linkage", decl);
10450 storage_class = sc_none;
10453 else if (constexpr_p && DECL_EXTERNAL (decl))
10455 error ("declaration of constexpr variable %qD is not a definition",
10457 constexpr_p = false;
10461 if (storage_class == sc_extern && initialized && !funcdef_flag)
10463 if (toplevel_bindings_p ())
10465 /* It's common practice (and completely valid) to have a const
10466 be initialized and declared extern. */
10467 if (!(type_quals & TYPE_QUAL_CONST))
10468 warning (0, "%qs initialized and declared %<extern%>", name);
10472 error ("%qs has both %<extern%> and initializer", name);
10473 return error_mark_node;
10477 /* Record `register' declaration for warnings on &
10478 and in case doing stupid register allocation. */
10480 if (storage_class == sc_register)
10481 DECL_REGISTER (decl) = 1;
10482 else if (storage_class == sc_extern)
10483 DECL_THIS_EXTERN (decl) = 1;
10484 else if (storage_class == sc_static)
10485 DECL_THIS_STATIC (decl) = 1;
10487 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10488 if (constexpr_p && TREE_CODE (decl) == VAR_DECL)
10489 DECL_DECLARED_CONSTEXPR_P (decl) = true;
10491 /* Record constancy and volatility on the DECL itself . There's
10492 no need to do this when processing a template; we'll do this
10493 for the instantiated declaration based on the type of DECL. */
10494 if (!processing_template_decl)
10495 cp_apply_type_quals_to_decl (type_quals, decl);
10501 /* Subroutine of start_function. Ensure that each of the parameter
10502 types (as listed in PARMS) is complete, as is required for a
10503 function definition. */
10506 require_complete_types_for_parms (tree parms)
10508 for (; parms; parms = DECL_CHAIN (parms))
10510 if (dependent_type_p (TREE_TYPE (parms)))
10512 if (!VOID_TYPE_P (TREE_TYPE (parms))
10513 && complete_type_or_else (TREE_TYPE (parms), parms))
10515 relayout_decl (parms);
10516 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
10519 /* grokparms or complete_type_or_else will have already issued
10521 TREE_TYPE (parms) = error_mark_node;
10525 /* Returns nonzero if T is a local variable. */
10528 local_variable_p (const_tree t)
10530 if ((TREE_CODE (t) == VAR_DECL
10531 /* A VAR_DECL with a context that is a _TYPE is a static data
10533 && !TYPE_P (CP_DECL_CONTEXT (t))
10534 /* Any other non-local variable must be at namespace scope. */
10535 && !DECL_NAMESPACE_SCOPE_P (t))
10536 || (TREE_CODE (t) == PARM_DECL))
10542 /* Like local_variable_p, but suitable for use as a tree-walking
10546 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
10549 /* Check DECL_NAME to avoid including temporaries. We don't check
10550 DECL_ARTIFICIAL because we do want to complain about 'this'. */
10551 if (local_variable_p (*tp) && DECL_NAME (*tp))
10553 else if (TYPE_P (*tp))
10554 *walk_subtrees = 0;
10559 /* Check that ARG, which is a default-argument expression for a
10560 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10561 something goes wrong. DECL may also be a _TYPE node, rather than a
10562 DECL, if there is no DECL available. */
10565 check_default_argument (tree decl, tree arg)
10570 if (TREE_CODE (arg) == DEFAULT_ARG)
10571 /* We get a DEFAULT_ARG when looking at an in-class declaration
10572 with a default argument. Ignore the argument for now; we'll
10573 deal with it after the class is complete. */
10582 decl_type = TREE_TYPE (decl);
10584 if (arg == error_mark_node
10585 || decl == error_mark_node
10586 || TREE_TYPE (arg) == error_mark_node
10587 || decl_type == error_mark_node)
10588 /* Something already went wrong. There's no need to check
10590 return error_mark_node;
10592 /* [dcl.fct.default]
10594 A default argument expression is implicitly converted to the
10596 ++cp_unevaluated_operand;
10597 perform_implicit_conversion_flags (decl_type, arg, tf_warning_or_error,
10599 --cp_unevaluated_operand;
10601 if (warn_zero_as_null_pointer_constant
10602 && c_inhibit_evaluation_warnings == 0
10603 && TYPE_PTR_OR_PTRMEM_P (decl_type)
10604 && null_ptr_cst_p (arg)
10605 && !NULLPTR_TYPE_P (TREE_TYPE (arg)))
10607 warning (OPT_Wzero_as_null_pointer_constant,
10608 "zero as null pointer constant");
10609 return nullptr_node;
10612 /* [dcl.fct.default]
10614 Local variables shall not be used in default argument
10617 The keyword `this' shall not be used in a default argument of a
10618 member function. */
10619 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
10622 if (DECL_NAME (var) == this_identifier)
10623 permerror (input_location, "default argument %qE uses %qD", arg, var);
10625 error ("default argument %qE uses local variable %qD", arg, var);
10626 return error_mark_node;
10633 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
10636 type_is_deprecated (tree type)
10638 enum tree_code code;
10639 if (TREE_DEPRECATED (type))
10641 if (TYPE_NAME (type)
10642 && TREE_DEPRECATED (TYPE_NAME (type)))
10645 /* Do warn about using typedefs to a deprecated class. */
10646 if (TAGGED_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
10647 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
10649 code = TREE_CODE (type);
10651 if (code == POINTER_TYPE || code == REFERENCE_TYPE
10652 || code == OFFSET_TYPE || code == FUNCTION_TYPE
10653 || code == METHOD_TYPE || code == ARRAY_TYPE)
10654 return type_is_deprecated (TREE_TYPE (type));
10656 if (TYPE_PTRMEMFUNC_P (type))
10657 return type_is_deprecated
10658 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
10663 /* Decode the list of parameter types for a function type.
10664 Given the list of things declared inside the parens,
10665 return a list of types.
10667 If this parameter does not end with an ellipsis, we append
10670 *PARMS is set to the chain of PARM_DECLs created. */
10673 grokparms (tree parmlist, tree *parms)
10675 tree result = NULL_TREE;
10676 tree decls = NULL_TREE;
10680 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
10682 tree type = NULL_TREE;
10683 tree init = TREE_PURPOSE (parm);
10684 tree decl = TREE_VALUE (parm);
10685 const char *errmsg;
10687 if (parm == void_list_node)
10690 if (! decl || TREE_TYPE (decl) == error_mark_node)
10693 type = TREE_TYPE (decl);
10694 if (VOID_TYPE_P (type))
10696 if (same_type_p (type, void_type_node)
10697 && DECL_SELF_REFERENCE_P (type)
10698 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
10699 /* this is a parmlist of `(void)', which is ok. */
10701 cxx_incomplete_type_error (decl, type);
10702 /* It's not a good idea to actually create parameters of
10703 type `void'; other parts of the compiler assume that a
10704 void type terminates the parameter list. */
10705 type = error_mark_node;
10706 TREE_TYPE (decl) = error_mark_node;
10709 if (type != error_mark_node
10710 && TYPE_FOR_JAVA (type)
10711 && MAYBE_CLASS_TYPE_P (type))
10713 error ("parameter %qD has Java class type", decl);
10714 type = error_mark_node;
10715 TREE_TYPE (decl) = error_mark_node;
10719 if (type != error_mark_node
10720 && (errmsg = targetm.invalid_parameter_type (type)))
10723 type = error_mark_node;
10724 TREE_TYPE (decl) = error_mark_node;
10727 if (type != error_mark_node)
10729 if (deprecated_state != DEPRECATED_SUPPRESS)
10731 tree deptype = type_is_deprecated (type);
10733 warn_deprecated_use (deptype, NULL_TREE);
10736 /* Top-level qualifiers on the parameters are
10737 ignored for function types. */
10738 type = cp_build_qualified_type (type, 0);
10739 if (TREE_CODE (type) == METHOD_TYPE)
10741 error ("parameter %qD invalidly declared method type", decl);
10742 type = build_pointer_type (type);
10743 TREE_TYPE (decl) = type;
10745 else if (abstract_virtuals_error (decl, type))
10746 any_error = 1; /* Seems like a good idea. */
10747 else if (POINTER_TYPE_P (type))
10749 /* [dcl.fct]/6, parameter types cannot contain pointers
10750 (references) to arrays of unknown bound. */
10751 tree t = TREE_TYPE (type);
10752 int ptr = TYPE_PTR_P (type);
10756 if (TYPE_PTR_P (t))
10758 else if (TREE_CODE (t) != ARRAY_TYPE)
10760 else if (!TYPE_DOMAIN (t))
10764 if (TREE_CODE (t) == ARRAY_TYPE)
10766 ? G_("parameter %qD includes pointer to array of "
10767 "unknown bound %qT")
10768 : G_("parameter %qD includes reference to array of "
10769 "unknown bound %qT"),
10775 else if (init && !processing_template_decl)
10776 init = check_default_argument (decl, init);
10779 DECL_CHAIN (decl) = decls;
10781 result = tree_cons (init, type, result);
10783 decls = nreverse (decls);
10784 result = nreverse (result);
10786 result = chainon (result, void_list_node);
10793 /* D is a constructor or overloaded `operator='.
10795 Let T be the class in which D is declared. Then, this function
10798 -1 if D's is an ill-formed constructor or copy assignment operator
10799 whose first parameter is of type `T'.
10800 0 if D is not a copy constructor or copy assignment
10802 1 if D is a copy constructor or copy assignment operator whose
10803 first parameter is a reference to non-const qualified T.
10804 2 if D is a copy constructor or copy assignment operator whose
10805 first parameter is a reference to const qualified T.
10807 This function can be used as a predicate. Positive values indicate
10808 a copy constructor and nonzero values indicate a copy assignment
10812 copy_fn_p (const_tree d)
10818 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
10820 if (TREE_CODE (d) == TEMPLATE_DECL
10821 || (DECL_TEMPLATE_INFO (d)
10822 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
10823 /* Instantiations of template member functions are never copy
10824 functions. Note that member functions of templated classes are
10825 represented as template functions internally, and we must
10826 accept those as copy functions. */
10829 args = FUNCTION_FIRST_USER_PARMTYPE (d);
10833 arg_type = TREE_VALUE (args);
10834 if (arg_type == error_mark_node)
10837 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
10839 /* Pass by value copy assignment operator. */
10842 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
10843 && !TYPE_REF_IS_RVALUE (arg_type)
10844 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
10846 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
10852 args = TREE_CHAIN (args);
10854 if (args && args != void_list_node && !TREE_PURPOSE (args))
10855 /* There are more non-optional args. */
10861 /* D is a constructor or overloaded `operator='.
10863 Let T be the class in which D is declared. Then, this function
10864 returns true when D is a move constructor or move assignment
10865 operator, false otherwise. */
10868 move_fn_p (const_tree d)
10870 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
10872 if (cxx_dialect == cxx98)
10873 /* There are no move constructors if we are in C++98 mode. */
10876 if (TREE_CODE (d) == TEMPLATE_DECL
10877 || (DECL_TEMPLATE_INFO (d)
10878 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
10879 /* Instantiations of template member functions are never move
10880 functions. Note that member functions of templated classes are
10881 represented as template functions internally, and we must
10882 accept those as move functions. */
10885 return move_signature_fn_p (d);
10888 /* D is a constructor or overloaded `operator='.
10890 Then, this function returns true when D has the same signature as a move
10891 constructor or move assignment operator (because either it is such a
10892 ctor/op= or it is a template specialization with the same signature),
10893 false otherwise. */
10896 move_signature_fn_p (const_tree d)
10900 bool result = false;
10902 args = FUNCTION_FIRST_USER_PARMTYPE (d);
10906 arg_type = TREE_VALUE (args);
10907 if (arg_type == error_mark_node)
10910 if (TREE_CODE (arg_type) == REFERENCE_TYPE
10911 && TYPE_REF_IS_RVALUE (arg_type)
10912 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
10916 args = TREE_CHAIN (args);
10918 if (args && args != void_list_node && !TREE_PURPOSE (args))
10919 /* There are more non-optional args. */
10925 /* Remember any special properties of member function DECL. */
10928 grok_special_member_properties (tree decl)
10932 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
10935 class_type = DECL_CONTEXT (decl);
10936 if (DECL_CONSTRUCTOR_P (decl))
10938 int ctor = copy_fn_p (decl);
10940 if (!DECL_ARTIFICIAL (decl))
10941 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
10947 A non-template constructor for class X is a copy
10948 constructor if its first parameter is of type X&, const
10949 X&, volatile X& or const volatile X&, and either there
10950 are no other parameters or else all other parameters have
10951 default arguments. */
10952 TYPE_HAS_COPY_CTOR (class_type) = 1;
10953 if (user_provided_p (decl))
10954 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
10956 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
10958 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
10960 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
10961 if (user_provided_p (decl))
10962 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
10964 else if (move_fn_p (decl) && user_provided_p (decl))
10965 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1;
10966 else if (is_list_ctor (decl))
10967 TYPE_HAS_LIST_CTOR (class_type) = 1;
10969 if (DECL_DECLARED_CONSTEXPR_P (decl)
10970 && !copy_fn_p (decl) && !move_fn_p (decl))
10971 TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
10973 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
10977 A non-template assignment operator for class X is a copy
10978 assignment operator if its parameter is of type X, X&, const
10979 X&, volatile X& or const volatile X&. */
10981 int assop = copy_fn_p (decl);
10985 TYPE_HAS_COPY_ASSIGN (class_type) = 1;
10986 if (user_provided_p (decl))
10987 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
10989 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
10991 else if (move_fn_p (decl) && user_provided_p (decl))
10992 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1;
10994 /* Destructors are handled in check_methods. */
10997 /* Check a constructor DECL has the correct form. Complains
10998 if the class has a constructor of the form X(X). */
11001 grok_ctor_properties (const_tree ctype, const_tree decl)
11003 int ctor_parm = copy_fn_p (decl);
11009 A declaration of a constructor for a class X is ill-formed if
11010 its first parameter is of type (optionally cv-qualified) X
11011 and either there are no other parameters or else all other
11012 parameters have default arguments.
11014 We *don't* complain about member template instantiations that
11015 have this form, though; they can occur as we try to decide
11016 what constructor to use during overload resolution. Since
11017 overload resolution will never prefer such a constructor to
11018 the non-template copy constructor (which is either explicitly
11019 or implicitly defined), there's no need to worry about their
11020 existence. Theoretically, they should never even be
11021 instantiated, but that's hard to forestall. */
11022 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11030 /* An operator with this code is unary, but can also be binary. */
11033 ambi_op_p (enum tree_code code)
11035 return (code == INDIRECT_REF
11036 || code == ADDR_EXPR
11037 || code == UNARY_PLUS_EXPR
11038 || code == NEGATE_EXPR
11039 || code == PREINCREMENT_EXPR
11040 || code == PREDECREMENT_EXPR);
11043 /* An operator with this name can only be unary. */
11046 unary_op_p (enum tree_code code)
11048 return (code == TRUTH_NOT_EXPR
11049 || code == BIT_NOT_EXPR
11050 || code == COMPONENT_REF
11051 || code == TYPE_EXPR);
11054 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11055 errors are issued for invalid declarations. */
11058 grok_op_properties (tree decl, bool complain)
11060 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11062 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11063 tree name = DECL_NAME (decl);
11064 enum tree_code operator_code;
11069 /* Count the number of arguments and check for ellipsis. */
11070 for (argtype = argtypes, arity = 0;
11071 argtype && argtype != void_list_node;
11072 argtype = TREE_CHAIN (argtype))
11074 ellipsis_p = !argtype;
11076 class_type = DECL_CONTEXT (decl);
11077 if (class_type && !CLASS_TYPE_P (class_type))
11078 class_type = NULL_TREE;
11080 if (DECL_CONV_FN_P (decl))
11081 operator_code = TYPE_EXPR;
11085 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11086 if (ansi_opname (CODE) == name) \
11088 operator_code = (CODE); \
11091 else if (ansi_assopname (CODE) == name) \
11093 operator_code = (CODE); \
11094 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11098 #include "operators.def"
11099 #undef DEF_OPERATOR
11101 gcc_unreachable ();
11104 gcc_assert (operator_code != MAX_TREE_CODES);
11105 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11108 switch (operator_code)
11111 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
11115 TYPE_GETS_DELETE (class_type) |= 1;
11119 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
11122 case VEC_DELETE_EXPR:
11123 TYPE_GETS_DELETE (class_type) |= 2;
11130 /* [basic.std.dynamic.allocation]/1:
11132 A program is ill-formed if an allocation function is declared
11133 in a namespace scope other than global scope or declared static
11136 The same also holds true for deallocation functions. */
11137 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
11138 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11140 if (DECL_NAMESPACE_SCOPE_P (decl))
11142 if (CP_DECL_CONTEXT (decl) != global_namespace)
11144 error ("%qD may not be declared within a namespace", decl);
11147 else if (!TREE_PUBLIC (decl))
11149 error ("%qD may not be declared as static", decl);
11155 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
11157 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11158 DECL_IS_OPERATOR_NEW (decl) = 1;
11160 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11161 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11164 /* An operator function must either be a non-static member function
11165 or have at least one parameter of a class, a reference to a class,
11166 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11167 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11169 if (operator_code == TYPE_EXPR
11170 || operator_code == CALL_EXPR
11171 || operator_code == COMPONENT_REF
11172 || operator_code == ARRAY_REF
11173 || operator_code == NOP_EXPR)
11175 error ("%qD must be a nonstatic member function", decl);
11182 if (DECL_STATIC_FUNCTION_P (decl))
11184 error ("%qD must be either a non-static member "
11185 "function or a non-member function", decl);
11189 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
11191 tree arg = non_reference (TREE_VALUE (p));
11192 if (arg == error_mark_node)
11195 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11196 because these checks are performed even on
11197 template functions. */
11198 if (MAYBE_CLASS_TYPE_P (arg)
11199 || TREE_CODE (arg) == ENUMERAL_TYPE)
11203 if (!p || p == void_list_node)
11206 error ("%qD must have an argument of class or "
11207 "enumerated type", decl);
11213 /* There are no restrictions on the arguments to an overloaded
11215 if (operator_code == CALL_EXPR)
11218 /* Warn about conversion operators that will never be used. */
11219 if (IDENTIFIER_TYPENAME_P (name)
11220 && ! DECL_TEMPLATE_INFO (decl)
11222 /* Warn only declaring the function; there is no need to
11223 warn again about out-of-class definitions. */
11224 && class_type == current_class_type)
11226 tree t = TREE_TYPE (name);
11227 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11230 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11232 if (TREE_CODE (t) == VOID_TYPE)
11233 warning (OPT_Wconversion,
11235 ? G_("conversion to a reference to void "
11236 "will never use a type conversion operator")
11237 : G_("conversion to void "
11238 "will never use a type conversion operator"));
11239 else if (class_type)
11241 if (t == class_type)
11242 warning (OPT_Wconversion,
11244 ? G_("conversion to a reference to the same type "
11245 "will never use a type conversion operator")
11246 : G_("conversion to the same type "
11247 "will never use a type conversion operator"));
11248 /* Don't force t to be complete here. */
11249 else if (MAYBE_CLASS_TYPE_P (t)
11250 && COMPLETE_TYPE_P (t)
11251 && DERIVED_FROM_P (t, class_type))
11252 warning (OPT_Wconversion,
11254 ? G_("conversion to a reference to a base class "
11255 "will never use a type conversion operator")
11256 : G_("conversion to a base class "
11257 "will never use a type conversion operator"));
11262 if (operator_code == COND_EXPR)
11265 error ("ISO C++ prohibits overloading operator ?:");
11268 else if (ellipsis_p)
11270 error ("%qD must not have variable number of arguments", decl);
11273 else if (ambi_op_p (operator_code))
11276 /* We pick the one-argument operator codes by default, so
11277 we don't have to change anything. */
11279 else if (arity == 2)
11281 /* If we thought this was a unary operator, we now know
11282 it to be a binary operator. */
11283 switch (operator_code)
11286 operator_code = MULT_EXPR;
11290 operator_code = BIT_AND_EXPR;
11293 case UNARY_PLUS_EXPR:
11294 operator_code = PLUS_EXPR;
11298 operator_code = MINUS_EXPR;
11301 case PREINCREMENT_EXPR:
11302 operator_code = POSTINCREMENT_EXPR;
11305 case PREDECREMENT_EXPR:
11306 operator_code = POSTDECREMENT_EXPR;
11310 gcc_unreachable ();
11313 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11315 if ((operator_code == POSTINCREMENT_EXPR
11316 || operator_code == POSTDECREMENT_EXPR)
11317 && ! processing_template_decl
11318 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11321 error ("postfix %qD must take %<int%> as its argument",
11324 error ("postfix %qD must take %<int%> as its second "
11332 error ("%qD must take either zero or one argument", decl);
11334 error ("%qD must take either one or two arguments", decl);
11338 /* More Effective C++ rule 6. */
11340 && (operator_code == POSTINCREMENT_EXPR
11341 || operator_code == POSTDECREMENT_EXPR
11342 || operator_code == PREINCREMENT_EXPR
11343 || operator_code == PREDECREMENT_EXPR))
11345 tree arg = TREE_VALUE (argtypes);
11346 tree ret = TREE_TYPE (TREE_TYPE (decl));
11347 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
11348 arg = TREE_TYPE (arg);
11349 arg = TYPE_MAIN_VARIANT (arg);
11350 if (operator_code == PREINCREMENT_EXPR
11351 || operator_code == PREDECREMENT_EXPR)
11353 if (TREE_CODE (ret) != REFERENCE_TYPE
11354 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
11356 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
11357 build_reference_type (arg));
11361 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
11362 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
11366 else if (unary_op_p (operator_code))
11371 error ("%qD must take %<void%>", decl);
11373 error ("%qD must take exactly one argument", decl);
11377 else /* if (binary_op_p (operator_code)) */
11382 error ("%qD must take exactly one argument", decl);
11384 error ("%qD must take exactly two arguments", decl);
11388 /* More Effective C++ rule 7. */
11390 && (operator_code == TRUTH_ANDIF_EXPR
11391 || operator_code == TRUTH_ORIF_EXPR
11392 || operator_code == COMPOUND_EXPR))
11393 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
11397 /* Effective C++ rule 23. */
11400 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
11401 && (operator_code == PLUS_EXPR
11402 || operator_code == MINUS_EXPR
11403 || operator_code == TRUNC_DIV_EXPR
11404 || operator_code == MULT_EXPR
11405 || operator_code == TRUNC_MOD_EXPR)
11406 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
11407 warning (OPT_Weffc__, "%qD should return by value", decl);
11409 /* [over.oper]/8 */
11410 for (; argtypes && argtypes != void_list_node;
11411 argtypes = TREE_CHAIN (argtypes))
11412 if (TREE_PURPOSE (argtypes))
11414 TREE_PURPOSE (argtypes) = NULL_TREE;
11415 if (operator_code == POSTINCREMENT_EXPR
11416 || operator_code == POSTDECREMENT_EXPR)
11418 pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments",
11423 error ("%qD cannot have default arguments", decl);
11431 /* Return a string giving the keyword associate with CODE. */
11433 static const char *
11434 tag_name (enum tag_types code)
11446 case typename_type:
11449 gcc_unreachable ();
11453 /* Name lookup in an elaborated-type-specifier (after the keyword
11454 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11455 elaborated-type-specifier is invalid, issue a diagnostic and return
11456 error_mark_node; otherwise, return the *_TYPE to which it referred.
11457 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11460 check_elaborated_type_specifier (enum tag_types tag_code,
11462 bool allow_template_p)
11466 if (decl == error_mark_node)
11467 return error_mark_node;
11471 struct S { struct S *p; };
11473 name lookup will find the TYPE_DECL for the implicit "S::S"
11474 typedef. Adjust for that here. */
11475 if (DECL_SELF_REFERENCE_P (decl))
11476 decl = TYPE_NAME (TREE_TYPE (decl));
11478 type = TREE_TYPE (decl);
11480 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11481 is false for this case as well. */
11482 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11484 error ("using template type parameter %qT after %qs",
11485 type, tag_name (tag_code));
11486 return error_mark_node;
11488 /* Accept template template parameters. */
11489 else if (allow_template_p
11490 && (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
11491 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM))
11495 If the identifier resolves to a typedef-name or the
11496 simple-template-id resolves to an alias template
11497 specialization, the elaborated-type-specifier is ill-formed.
11499 In other words, the only legitimate declaration to use in the
11500 elaborated type specifier is the implicit typedef created when
11501 the type is declared. */
11502 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
11503 && !DECL_SELF_REFERENCE_P (decl)
11504 && tag_code != typename_type)
11506 if (alias_template_specialization_p (type))
11507 error ("using alias template specialization %qT after %qs",
11508 type, tag_name (tag_code));
11510 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
11511 inform (DECL_SOURCE_LOCATION (decl),
11512 "%qD has a previous declaration here", decl);
11513 return error_mark_node;
11515 else if (TREE_CODE (type) != RECORD_TYPE
11516 && TREE_CODE (type) != UNION_TYPE
11517 && tag_code != enum_type
11518 && tag_code != typename_type)
11520 error ("%qT referred to as %qs", type, tag_name (tag_code));
11521 error ("%q+T has a previous declaration here", type);
11522 return error_mark_node;
11524 else if (TREE_CODE (type) != ENUMERAL_TYPE
11525 && tag_code == enum_type)
11527 error ("%qT referred to as enum", type);
11528 error ("%q+T has a previous declaration here", type);
11529 return error_mark_node;
11531 else if (!allow_template_p
11532 && TREE_CODE (type) == RECORD_TYPE
11533 && CLASSTYPE_IS_TEMPLATE (type))
11535 /* If a class template appears as elaborated type specifier
11536 without a template header such as:
11538 template <class T> class C {};
11539 void f(class C); // No template header here
11541 then the required template argument is missing. */
11542 error ("template argument required for %<%s %T%>",
11543 tag_name (tag_code),
11544 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
11545 return error_mark_node;
11551 /* Lookup NAME in elaborate type specifier in scope according to
11552 SCOPE and issue diagnostics if necessary.
11553 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11554 found, and ERROR_MARK_NODE for type error. */
11557 lookup_and_check_tag (enum tag_types tag_code, tree name,
11558 tag_scope scope, bool template_header_p)
11562 if (scope == ts_global)
11564 /* First try ordinary name lookup, ignoring hidden class name
11565 injected via friend declaration. */
11566 decl = lookup_name_prefer_type (name, 2);
11567 /* If that fails, the name will be placed in the smallest
11568 non-class, non-function-prototype scope according to 3.3.1/5.
11569 We may already have a hidden name declared as friend in this
11570 scope. So lookup again but not ignoring hidden names.
11571 If we find one, that name will be made visible rather than
11572 creating a new tag. */
11574 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
11577 decl = lookup_type_scope (name, scope);
11580 && (DECL_CLASS_TEMPLATE_P (decl)
11581 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl)))
11582 decl = DECL_TEMPLATE_RESULT (decl);
11584 if (decl && TREE_CODE (decl) == TYPE_DECL)
11586 /* Look for invalid nested type:
11590 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
11592 error ("%qD has the same name as the class in which it is "
11595 return error_mark_node;
11598 /* Two cases we need to consider when deciding if a class
11599 template is allowed as an elaborated type specifier:
11600 1. It is a self reference to its own class.
11601 2. It comes with a template header.
11605 template <class T> class C {
11606 class C *c1; // DECL_SELF_REFERENCE_P is true
11609 template <class U> class C; // template_header_p is true
11610 template <class T> class C<T>::D {
11611 class C *c2; // DECL_SELF_REFERENCE_P is true
11614 t = check_elaborated_type_specifier (tag_code,
11617 | DECL_SELF_REFERENCE_P (decl));
11620 else if (decl && TREE_CODE (decl) == TREE_LIST)
11622 error ("reference to %qD is ambiguous", name);
11623 print_candidates (decl);
11624 return error_mark_node;
11630 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
11631 Define the tag as a forward-reference if it is not defined.
11633 If a declaration is given, process it here, and report an error if
11634 multiple declarations are not identical.
11636 SCOPE is TS_CURRENT when this is also a definition. Only look in
11637 the current frame for the name (since C++ allows new names in any
11638 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
11639 declaration. Only look beginning from the current scope outward up
11640 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
11642 TEMPLATE_HEADER_P is true when this declaration is preceded by
11643 a set of template parameters. */
11646 xref_tag_1 (enum tag_types tag_code, tree name,
11647 tag_scope scope, bool template_header_p)
11649 enum tree_code code;
11651 tree context = NULL_TREE;
11653 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
11659 code = RECORD_TYPE;
11665 code = ENUMERAL_TYPE;
11668 gcc_unreachable ();
11671 /* In case of anonymous name, xref_tag is only called to
11672 make type node and push name. Name lookup is not required. */
11673 if (ANON_AGGRNAME_P (name))
11676 t = lookup_and_check_tag (tag_code, name,
11677 scope, template_header_p);
11679 if (t == error_mark_node)
11680 return error_mark_node;
11682 if (scope != ts_current && t && current_class_type
11683 && template_class_depth (current_class_type)
11684 && template_header_p)
11686 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
11689 /* Since SCOPE is not TS_CURRENT, we are not looking at a
11690 definition of this tag. Since, in addition, we are currently
11691 processing a (member) template declaration of a template
11692 class, we must be very careful; consider:
11699 { template <class V>
11700 friend struct S1; };
11702 Here, the S2::S1 declaration should not be confused with the
11703 outer declaration. In particular, the inner version should
11704 have a template parameter of level 2, not level 1. This
11705 would be particularly important if the member declaration
11708 template <class V = U> friend struct S1;
11710 say, when we should tsubst into `U' when instantiating
11711 S2. On the other hand, when presented with:
11721 we must find the inner binding eventually. We
11722 accomplish this by making sure that the new type we
11723 create to represent this declaration has the right
11725 context = TYPE_CONTEXT (t);
11731 /* If no such tag is yet defined, create a forward-reference node
11732 and record it as the "definition".
11733 When a real declaration of this type is found,
11734 the forward-reference will be altered into a real type. */
11735 if (code == ENUMERAL_TYPE)
11737 error ("use of enum %q#D without previous declaration", name);
11738 return error_mark_node;
11742 t = make_class_type (code);
11743 TYPE_CONTEXT (t) = context;
11744 t = pushtag (name, t, scope);
11749 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
11751 if (!redeclare_class_template (t, current_template_parms))
11752 return error_mark_node;
11754 else if (!processing_template_decl
11755 && CLASS_TYPE_P (t)
11756 && CLASSTYPE_IS_TEMPLATE (t))
11758 error ("redeclaration of %qT as a non-template", t);
11759 error ("previous declaration %q+D", t);
11760 return error_mark_node;
11763 /* Make injected friend class visible. */
11764 if (scope != ts_within_enclosing_non_class
11765 && hidden_name_p (TYPE_NAME (t)))
11767 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
11768 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
11770 if (TYPE_TEMPLATE_INFO (t))
11772 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
11773 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
11781 /* Wrapper for xref_tag_1. */
11784 xref_tag (enum tag_types tag_code, tree name,
11785 tag_scope scope, bool template_header_p)
11789 subtime = timevar_cond_start (TV_NAME_LOOKUP);
11790 ret = xref_tag_1 (tag_code, name, scope, template_header_p);
11791 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
11797 xref_tag_from_type (tree old, tree id, tag_scope scope)
11799 enum tag_types tag_kind;
11801 if (TREE_CODE (old) == RECORD_TYPE)
11802 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
11804 tag_kind = union_type;
11806 if (id == NULL_TREE)
11807 id = TYPE_IDENTIFIER (old);
11809 return xref_tag (tag_kind, id, scope, false);
11812 /* Create the binfo hierarchy for REF with (possibly NULL) base list
11813 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
11814 access_* node, and the TREE_VALUE is the type of the base-class.
11815 Non-NULL TREE_TYPE indicates virtual inheritance.
11817 Returns true if the binfo hierarchy was successfully created,
11818 false if an error was detected. */
11821 xref_basetypes (tree ref, tree base_list)
11824 tree binfo, base_binfo;
11825 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
11826 unsigned max_bases = 0; /* Maximum direct bases. */
11828 tree default_access;
11829 tree igo_prev; /* Track Inheritance Graph Order. */
11831 if (ref == error_mark_node)
11834 /* The base of a derived class is private by default, all others are
11836 default_access = (TREE_CODE (ref) == RECORD_TYPE
11837 && CLASSTYPE_DECLARED_CLASS (ref)
11838 ? access_private_node : access_public_node);
11840 /* First, make sure that any templates in base-classes are
11841 instantiated. This ensures that if we call ourselves recursively
11842 we do not get confused about which classes are marked and which
11844 basep = &base_list;
11847 tree basetype = TREE_VALUE (*basep);
11849 /* The dependent_type_p call below should really be dependent_scope_p
11850 so that we give a hard error about using an incomplete type as a
11851 base, but we allow it with a pedwarn for backward
11853 if (processing_template_decl
11854 && CLASS_TYPE_P (basetype) && TYPE_BEING_DEFINED (basetype))
11855 cxx_incomplete_type_diagnostic (NULL_TREE, basetype, DK_PEDWARN);
11856 if (!dependent_type_p (basetype)
11857 && !complete_type_or_else (basetype, NULL))
11858 /* An incomplete type. Remove it from the list. */
11859 *basep = TREE_CHAIN (*basep);
11863 if (TREE_TYPE (*basep))
11865 if (CLASS_TYPE_P (basetype))
11866 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
11867 basep = &TREE_CHAIN (*basep);
11871 TYPE_MARKED_P (ref) = 1;
11873 /* The binfo slot should be empty, unless this is an (ill-formed)
11875 if (TYPE_BINFO (ref) && !TYPE_SIZE (ref))
11877 error ("redefinition of %q#T", ref);
11881 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
11883 binfo = make_tree_binfo (max_bases);
11885 TYPE_BINFO (ref) = binfo;
11886 BINFO_OFFSET (binfo) = size_zero_node;
11887 BINFO_TYPE (binfo) = ref;
11889 /* Apply base-class info set up to the variants of this type. */
11890 fixup_type_variants (ref);
11894 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
11895 /* An aggregate cannot have baseclasses. */
11896 CLASSTYPE_NON_AGGREGATE (ref) = 1;
11898 if (TREE_CODE (ref) == UNION_TYPE)
11900 error ("derived union %qT invalid", ref);
11907 if (TYPE_FOR_JAVA (ref))
11909 error ("Java class %qT cannot have multiple bases", ref);
11916 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
11918 if (TYPE_FOR_JAVA (ref))
11920 error ("Java class %qT cannot have virtual bases", ref);
11925 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
11927 tree access = TREE_PURPOSE (base_list);
11928 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
11929 tree basetype = TREE_VALUE (base_list);
11931 if (access == access_default_node)
11932 access = default_access;
11934 if (PACK_EXPANSION_P (basetype))
11935 basetype = PACK_EXPANSION_PATTERN (basetype);
11936 if (TREE_CODE (basetype) == TYPE_DECL)
11937 basetype = TREE_TYPE (basetype);
11938 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
11940 error ("base type %qT fails to be a struct or class type",
11945 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
11946 TYPE_FOR_JAVA (ref) = 1;
11948 base_binfo = NULL_TREE;
11949 if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
11951 base_binfo = TYPE_BINFO (basetype);
11952 /* The original basetype could have been a typedef'd type. */
11953 basetype = BINFO_TYPE (base_binfo);
11955 /* Inherit flags from the base. */
11956 TYPE_HAS_NEW_OPERATOR (ref)
11957 |= TYPE_HAS_NEW_OPERATOR (basetype);
11958 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
11959 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
11960 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
11961 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
11962 CLASSTYPE_DIAMOND_SHAPED_P (ref)
11963 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
11964 CLASSTYPE_REPEATED_BASE_P (ref)
11965 |= CLASSTYPE_REPEATED_BASE_P (basetype);
11968 /* We must do this test after we've seen through a typedef
11970 if (TYPE_MARKED_P (basetype))
11972 if (basetype == ref)
11973 error ("recursive type %qT undefined", basetype);
11975 error ("duplicate base type %qT invalid", basetype);
11979 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
11980 /* Regenerate the pack expansion for the bases. */
11981 basetype = make_pack_expansion (basetype);
11983 TYPE_MARKED_P (basetype) = 1;
11985 base_binfo = copy_binfo (base_binfo, basetype, ref,
11986 &igo_prev, via_virtual);
11987 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
11988 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
11990 BINFO_BASE_APPEND (binfo, base_binfo);
11991 BINFO_BASE_ACCESS_APPEND (binfo, access);
11994 if (VEC_length (tree, CLASSTYPE_VBASECLASSES (ref)) < max_vbases)
11995 /* If we didn't get max_vbases vbases, we must have shared at
11996 least one of them, and are therefore diamond shaped. */
11997 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
11999 /* Unmark all the types. */
12000 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12001 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12002 TYPE_MARKED_P (ref) = 0;
12004 /* Now see if we have a repeated base type. */
12005 if (!CLASSTYPE_REPEATED_BASE_P (ref))
12007 for (base_binfo = binfo; base_binfo;
12008 base_binfo = TREE_CHAIN (base_binfo))
12010 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12012 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
12015 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
12017 for (base_binfo = binfo; base_binfo;
12018 base_binfo = TREE_CHAIN (base_binfo))
12019 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12020 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12029 /* Copies the enum-related properties from type SRC to type DST.
12030 Used with the underlying type of an enum and the enum itself. */
12032 copy_type_enum (tree dst, tree src)
12035 for (t = dst; t; t = TYPE_NEXT_VARIANT (t))
12037 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src);
12038 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src);
12039 TYPE_SIZE (t) = TYPE_SIZE (src);
12040 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src);
12041 SET_TYPE_MODE (dst, TYPE_MODE (src));
12042 TYPE_PRECISION (t) = TYPE_PRECISION (src);
12043 TYPE_ALIGN (t) = TYPE_ALIGN (src);
12044 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src);
12045 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src);
12049 /* Begin compiling the definition of an enumeration type.
12052 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12054 UNDERLYING_TYPE is the type that will be used as the storage for
12055 the enumeration type. This should be NULL_TREE if no storage type
12058 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12060 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12062 Returns the type object, as yet incomplete.
12063 Also records info about it so that build_enumerator
12064 may be used to declare the individual values as they are read. */
12067 start_enum (tree name, tree enumtype, tree underlying_type,
12068 bool scoped_enum_p, bool *is_new)
12070 tree prevtype = NULL_TREE;
12071 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
12075 /* [C++0x dcl.enum]p5:
12077 If not explicitly specified, the underlying type of a scoped
12078 enumeration type is int. */
12079 if (!underlying_type && scoped_enum_p)
12080 underlying_type = integer_type_node;
12082 if (underlying_type)
12083 underlying_type = cv_unqualified (underlying_type);
12085 /* If this is the real definition for a previous forward reference,
12086 fill in the contents in the same object that used to be the
12087 forward reference. */
12089 enumtype = lookup_and_check_tag (enum_type, name,
12090 /*tag_scope=*/ts_current,
12091 /*template_header_p=*/false);
12093 /* In case of a template_decl, the only check that should be deferred
12094 to instantiation time is the comparison of underlying types. */
12095 if (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12097 if (scoped_enum_p != SCOPED_ENUM_P (enumtype))
12099 error_at (input_location, "scoped/unscoped mismatch "
12100 "in enum %q#T", enumtype);
12101 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12102 "previous definition here");
12103 enumtype = error_mark_node;
12105 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) != !! underlying_type)
12107 error_at (input_location, "underlying type mismatch "
12108 "in enum %q#T", enumtype);
12109 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12110 "previous definition here");
12111 enumtype = error_mark_node;
12113 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype)
12114 && !dependent_type_p (underlying_type)
12115 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))
12116 && !same_type_p (underlying_type,
12117 ENUM_UNDERLYING_TYPE (enumtype)))
12119 error_at (input_location, "different underlying type "
12120 "in enum %q#T", enumtype);
12121 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12122 "previous definition here");
12123 underlying_type = NULL_TREE;
12127 if (!enumtype || TREE_CODE (enumtype) != ENUMERAL_TYPE
12128 || processing_template_decl)
12130 /* In case of error, make a dummy enum to allow parsing to
12132 if (enumtype == error_mark_node)
12134 name = make_anon_name ();
12135 enumtype = NULL_TREE;
12138 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12139 of an opaque enum, or an opaque enum of an already defined
12140 enumeration (C++0x only).
12141 In any other case, it'll be NULL_TREE. */
12147 prevtype = enumtype;
12149 /* Do not push the decl more than once, unless we need to
12150 compare underlying types at instantiation time */
12152 || TREE_CODE (enumtype) != ENUMERAL_TYPE
12153 || (underlying_type
12154 && dependent_type_p (underlying_type))
12155 || (ENUM_UNDERLYING_TYPE (enumtype)
12156 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))))
12158 enumtype = cxx_make_type (ENUMERAL_TYPE);
12159 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
12162 enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current,
12165 if (enumtype == error_mark_node)
12166 return error_mark_node;
12168 /* The enum is considered opaque until the opening '{' of the
12169 enumerator list. */
12170 SET_OPAQUE_ENUM_P (enumtype, true);
12171 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) = !! underlying_type;
12174 SET_SCOPED_ENUM_P (enumtype, scoped_enum_p);
12176 if (underlying_type)
12178 if (CP_INTEGRAL_TYPE_P (underlying_type))
12180 copy_type_enum (enumtype, underlying_type);
12181 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12183 else if (dependent_type_p (underlying_type))
12184 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12186 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12187 underlying_type, enumtype);
12190 /* If into a template class, the returned enum is always the first
12191 declaration (opaque or not) seen. This way all the references to
12192 this type will be to the same declaration. The following ones are used
12193 only to check for definition errors. */
12194 if (prevtype && processing_template_decl)
12200 /* After processing and defining all the values of an enumeration type,
12201 install their decls in the enumeration type.
12202 ENUMTYPE is the type object. */
12205 finish_enum_value_list (tree enumtype)
12208 tree underlying_type;
12211 tree minnode, maxnode;
12214 bool fixed_underlying_type_p
12215 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
12217 /* We built up the VALUES in reverse order. */
12218 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12220 /* For an enum defined in a template, just set the type of the values;
12221 all further processing is postponed until the template is
12222 instantiated. We need to set the type so that tsubst of a CONST_DECL
12224 if (processing_template_decl)
12226 for (values = TYPE_VALUES (enumtype);
12228 values = TREE_CHAIN (values))
12229 TREE_TYPE (TREE_VALUE (values)) = enumtype;
12233 /* Determine the minimum and maximum values of the enumerators. */
12234 if (TYPE_VALUES (enumtype))
12236 minnode = maxnode = NULL_TREE;
12238 for (values = TYPE_VALUES (enumtype);
12240 values = TREE_CHAIN (values))
12242 decl = TREE_VALUE (values);
12244 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12245 each enumerator has the type of its enumeration. Prior to the
12246 closing brace, the type of each enumerator is the type of its
12247 initializing value. */
12248 TREE_TYPE (decl) = enumtype;
12250 /* Update the minimum and maximum values, if appropriate. */
12251 value = DECL_INITIAL (decl);
12252 if (value == error_mark_node)
12253 value = integer_zero_node;
12254 /* Figure out what the minimum and maximum values of the
12255 enumerators are. */
12257 minnode = maxnode = value;
12258 else if (tree_int_cst_lt (maxnode, value))
12260 else if (tree_int_cst_lt (value, minnode))
12267 If the enumerator-list is empty, the underlying type is as if
12268 the enumeration had a single enumerator with value 0. */
12269 minnode = maxnode = integer_zero_node;
12271 if (!fixed_underlying_type_p)
12273 /* Compute the number of bits require to represent all values of the
12274 enumeration. We must do this before the type of MINNODE and
12275 MAXNODE are transformed, since tree_int_cst_min_precision relies
12276 on the TREE_TYPE of the value it is passed. */
12277 bool unsignedp = tree_int_cst_sgn (minnode) >= 0;
12278 int lowprec = tree_int_cst_min_precision (minnode, unsignedp);
12279 int highprec = tree_int_cst_min_precision (maxnode, unsignedp);
12280 int precision = MAX (lowprec, highprec);
12282 bool use_short_enum;
12284 /* Determine the underlying type of the enumeration.
12288 The underlying type of an enumeration is an integral type that
12289 can represent all the enumerator values defined in the
12290 enumeration. It is implementation-defined which integral type is
12291 used as the underlying type for an enumeration except that the
12292 underlying type shall not be larger than int unless the value of
12293 an enumerator cannot fit in an int or unsigned int.
12295 We use "int" or an "unsigned int" as the underlying type, even if
12296 a smaller integral type would work, unless the user has
12297 explicitly requested that we use the smallest possible type. The
12298 user can request that for all enumerations with a command line
12299 flag, or for just one enumeration with an attribute. */
12301 use_short_enum = flag_short_enums
12302 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
12304 for (itk = (use_short_enum ? itk_char : itk_int);
12308 underlying_type = integer_types[itk];
12309 if (underlying_type != NULL_TREE
12310 && TYPE_PRECISION (underlying_type) >= precision
12311 && TYPE_UNSIGNED (underlying_type) == unsignedp)
12314 if (itk == itk_none)
12318 IF no integral type can represent all the enumerator values, the
12319 enumeration is ill-formed. */
12320 error ("no integral type can represent all of the enumerator values "
12321 "for %qT", enumtype);
12322 precision = TYPE_PRECISION (long_long_integer_type_node);
12323 underlying_type = integer_types[itk_unsigned_long_long];
12328 The value of sizeof() applied to an enumeration type, an object
12329 of an enumeration type, or an enumerator, is the value of sizeof()
12330 applied to the underlying type. */
12331 copy_type_enum (enumtype, underlying_type);
12333 /* Compute the minimum and maximum values for the type.
12337 For an enumeration where emin is the smallest enumerator and emax
12338 is the largest, the values of the enumeration are the values of the
12339 underlying type in the range bmin to bmax, where bmin and bmax are,
12340 respectively, the smallest and largest values of the smallest bit-
12341 field that can store emin and emax. */
12343 /* The middle-end currently assumes that types with TYPE_PRECISION
12344 narrower than their underlying type are suitably zero or sign
12345 extended to fill their mode. Similarly, it assumes that the front
12346 end assures that a value of a particular type must be within
12347 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12349 We used to set these fields based on bmin and bmax, but that led
12350 to invalid assumptions like optimizing away bounds checking. So
12351 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12352 TYPE_MAX_VALUE to the values for the mode above and only restrict
12353 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12354 ENUM_UNDERLYING_TYPE (enumtype)
12355 = build_distinct_type_copy (underlying_type);
12356 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision;
12357 set_min_and_max_values_for_integral_type
12358 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
12360 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12361 if (flag_strict_enums)
12362 set_min_and_max_values_for_integral_type (enumtype, precision,
12366 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
12368 /* Convert each of the enumerators to the type of the underlying
12369 type of the enumeration. */
12370 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12372 location_t saved_location;
12374 decl = TREE_VALUE (values);
12375 saved_location = input_location;
12376 input_location = DECL_SOURCE_LOCATION (decl);
12377 if (fixed_underlying_type_p)
12378 /* If the enumeration type has a fixed underlying type, we
12379 already checked all of the enumerator values. */
12380 value = DECL_INITIAL (decl);
12382 value = perform_implicit_conversion (underlying_type,
12383 DECL_INITIAL (decl),
12384 tf_warning_or_error);
12385 input_location = saved_location;
12387 /* Do not clobber shared ints. */
12388 value = copy_node (value);
12390 TREE_TYPE (value) = enumtype;
12391 DECL_INITIAL (decl) = value;
12394 /* Fix up all variant types of this enum type. */
12395 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
12396 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
12398 if (at_class_scope_p ()
12399 && COMPLETE_TYPE_P (current_class_type)
12400 && UNSCOPED_ENUM_P (enumtype))
12401 insert_late_enum_def_into_classtype_sorted_fields (enumtype,
12402 current_class_type);
12404 /* Finish debugging output for this type. */
12405 rest_of_type_compilation (enumtype, namespace_bindings_p ());
12408 /* Finishes the enum type. This is called only the first time an
12409 enumeration is seen, be it opaque or odinary.
12410 ENUMTYPE is the type object. */
12413 finish_enum (tree enumtype)
12415 if (processing_template_decl)
12417 if (at_function_scope_p ())
12418 add_stmt (build_min (TAG_DEFN, enumtype));
12422 /* If this is a forward declaration, there should not be any variants,
12423 though we can get a variant in the middle of an enum-specifier with
12424 wacky code like 'enum E { e = sizeof(const E*) };' */
12425 gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
12426 && (TYPE_VALUES (enumtype)
12427 || !TYPE_NEXT_VARIANT (enumtype)));
12430 /* Build and install a CONST_DECL for an enumeration constant of the
12431 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12432 LOC is the location of NAME.
12433 Assignment of sequential values by default is handled here. */
12436 build_enumerator (tree name, tree value, tree enumtype, location_t loc)
12442 /* If the VALUE was erroneous, pretend it wasn't there; that will
12443 result in the enum being assigned the next value in sequence. */
12444 if (value == error_mark_node)
12447 /* Remove no-op casts from the value. */
12449 STRIP_TYPE_NOPS (value);
12451 if (! processing_template_decl)
12453 /* Validate and default VALUE. */
12454 if (value != NULL_TREE)
12456 value = cxx_constant_value (value);
12458 if (TREE_CODE (value) != INTEGER_CST
12459 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
12461 error ("enumerator value for %qD is not an integer constant",
12467 /* Default based on previous value. */
12468 if (value == NULL_TREE)
12470 if (TYPE_VALUES (enumtype))
12475 /* C++03 7.2/4: If no initializer is specified for the first
12476 enumerator, the type is an unspecified integral
12477 type. Otherwise the type is the same as the type of the
12478 initializing value of the preceding enumerator unless the
12479 incremented value is not representable in that type, in
12480 which case the type is an unspecified integral type
12481 sufficient to contain the incremented value. */
12482 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12483 if (error_operand_p (prev_value))
12484 value = error_mark_node;
12487 double_int di = TREE_INT_CST (prev_value)
12488 .add_with_sign (double_int_one,
12489 false, &overflowed);
12492 tree type = TREE_TYPE (prev_value);
12493 bool pos = TYPE_UNSIGNED (type) || !di.is_negative ();
12494 if (!double_int_fits_to_tree_p (type, di))
12497 for (itk = itk_int; itk != itk_none; itk++)
12499 type = integer_types[itk];
12500 if (type != NULL_TREE
12501 && (pos || !TYPE_UNSIGNED (type))
12502 && double_int_fits_to_tree_p (type, di))
12505 if (type && cxx_dialect < cxx0x
12506 && itk > itk_unsigned_long)
12507 pedwarn (input_location, OPT_Wlong_long, pos ? "\
12508 incremented enumerator value is too large for %<unsigned long%>" : "\
12509 incremented enumerator value is too large for %<long%>");
12511 if (type == NULL_TREE)
12514 value = double_int_to_tree (type, di);
12519 error ("overflow in enumeration values at %qD", name);
12520 value = error_mark_node;
12525 value = integer_zero_node;
12528 /* Remove no-op casts from the value. */
12529 STRIP_TYPE_NOPS (value);
12531 /* If the underlying type of the enum is fixed, check whether
12532 the enumerator values fits in the underlying type. If it
12533 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12534 if (ENUM_UNDERLYING_TYPE (enumtype)
12536 && TREE_CODE (value) == INTEGER_CST
12537 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
12539 error ("enumerator value %E is too large for underlying type %<%T%>",
12540 value, ENUM_UNDERLYING_TYPE (enumtype));
12542 /* Silently convert the value so that we can continue. */
12543 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
12548 /* C++ associates enums with global, function, or class declarations. */
12549 context = current_scope ();
12551 /* Build the actual enumeration constant. Note that the enumeration
12552 constants have the underlying type of the enum (if it is fixed)
12553 or the type of their initializer (if the underlying type of the
12554 enum is not fixed):
12558 If the underlying type is fixed, the type of each enumerator
12559 prior to the closing brace is the underlying type; if the
12560 initializing value of an enumerator cannot be represented by
12561 the underlying type, the program is ill-formed. If the
12562 underlying type is not fixed, the type of each enumerator is
12563 the type of its initializing value.
12565 If the underlying type is not fixed, it will be computed by
12566 finish_enum and we will reset the type of this enumerator. Of
12567 course, if we're processing a template, there may be no value. */
12568 type = value ? TREE_TYPE (value) : NULL_TREE;
12570 decl = build_decl (loc, CONST_DECL, name, type);
12572 DECL_CONTEXT (decl) = enumtype;
12573 TREE_CONSTANT (decl) = 1;
12574 TREE_READONLY (decl) = 1;
12575 DECL_INITIAL (decl) = value;
12577 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype))
12578 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12579 on the TYPE_FIELDS list for `S'. (That's so that you can say
12580 things like `S::i' later.) */
12581 finish_member_declaration (decl);
12585 /* Add this enumeration constant to the list for this type. */
12586 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12589 /* Look for an enumerator with the given NAME within the enumeration
12590 type ENUMTYPE. This routine is used primarily for qualified name
12591 lookup into an enumerator in C++0x, e.g.,
12593 enum class Color { Red, Green, Blue };
12595 Color color = Color::Red;
12597 Returns the value corresponding to the enumerator, or
12598 NULL_TREE if no such enumerator was found. */
12600 lookup_enumerator (tree enumtype, tree name)
12603 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
12605 e = purpose_member (name, TYPE_VALUES (enumtype));
12606 return e? TREE_VALUE (e) : NULL_TREE;
12610 /* We're defining DECL. Make sure that its type is OK. */
12613 check_function_type (tree decl, tree current_function_parms)
12615 tree fntype = TREE_TYPE (decl);
12616 tree return_type = complete_type (TREE_TYPE (fntype));
12618 /* In a function definition, arg types must be complete. */
12619 require_complete_types_for_parms (current_function_parms);
12621 if (dependent_type_p (return_type)
12622 || type_uses_auto (return_type))
12624 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
12625 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
12627 tree args = TYPE_ARG_TYPES (fntype);
12629 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
12630 error ("return type %q#T is incomplete", return_type);
12632 error ("return type has Java class type %q#T", return_type);
12634 /* Make it return void instead. */
12635 if (TREE_CODE (fntype) == METHOD_TYPE)
12636 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
12638 TREE_CHAIN (args));
12640 fntype = build_function_type (void_type_node, args);
12642 = build_exception_variant (fntype,
12643 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
12644 fntype = (cp_build_type_attribute_variant
12645 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
12646 TREE_TYPE (decl) = fntype;
12649 abstract_virtuals_error (decl, TREE_TYPE (fntype));
12652 /* Create the FUNCTION_DECL for a function definition.
12653 DECLSPECS and DECLARATOR are the parts of the declaration;
12654 they describe the function's name and the type it returns,
12655 but twisted together in a fashion that parallels the syntax of C.
12657 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12658 DECLARATOR is really the DECL for the function we are about to
12659 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12660 indicating that the function is an inline defined in-class.
12662 This function creates a binding context for the function body
12663 as well as setting up the FUNCTION_DECL in current_function_decl.
12665 For C++, we must first check whether that datum makes any sense.
12666 For example, "class A local_a(1,2);" means that variable local_a
12667 is an aggregate of type A, which should have a constructor
12668 applied to it with the argument list [1, 2].
12670 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
12671 or may be a BLOCK if the function has been defined previously
12672 in this translation unit. On exit, DECL_INITIAL (decl1) will be
12673 error_mark_node if the function has never been defined, or
12674 a BLOCK if the function has been defined somewhere. */
12677 start_preparsed_function (tree decl1, tree attrs, int flags)
12679 tree ctype = NULL_TREE;
12682 int doing_friend = 0;
12683 cp_binding_level *bl;
12684 tree current_function_parms;
12685 struct c_fileinfo *finfo
12686 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
12687 bool honor_interface;
12689 /* Sanity check. */
12690 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
12691 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
12693 fntype = TREE_TYPE (decl1);
12694 if (TREE_CODE (fntype) == METHOD_TYPE)
12695 ctype = TYPE_METHOD_BASETYPE (fntype);
12697 /* ISO C++ 11.4/5. A friend function defined in a class is in
12698 the (lexical) scope of the class in which it is defined. */
12699 if (!ctype && DECL_FRIEND_P (decl1))
12701 ctype = DECL_FRIEND_CONTEXT (decl1);
12703 /* CTYPE could be null here if we're dealing with a template;
12704 for example, `inline friend float foo()' inside a template
12705 will have no CTYPE set. */
12706 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
12712 if (DECL_DECLARED_INLINE_P (decl1)
12713 && lookup_attribute ("noinline", attrs))
12714 warning (0, "inline function %q+D given attribute noinline", decl1);
12716 /* Handle gnu_inline attribute. */
12717 if (GNU_INLINE_P (decl1))
12719 DECL_EXTERNAL (decl1) = 1;
12720 DECL_NOT_REALLY_EXTERN (decl1) = 0;
12721 DECL_INTERFACE_KNOWN (decl1) = 1;
12722 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
12725 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
12726 /* This is a constructor, we must ensure that any default args
12727 introduced by this definition are propagated to the clones
12728 now. The clones are used directly in overload resolution. */
12729 adjust_clone_args (decl1);
12731 /* Sometimes we don't notice that a function is a static member, and
12732 build a METHOD_TYPE for it. Fix that up now. */
12733 gcc_assert (!(ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
12734 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE));
12736 /* Set up current_class_type, and enter the scope of the class, if
12739 push_nested_class (ctype);
12740 else if (DECL_STATIC_FUNCTION_P (decl1))
12741 push_nested_class (DECL_CONTEXT (decl1));
12743 /* Now that we have entered the scope of the class, we must restore
12744 the bindings for any template parameters surrounding DECL1, if it
12745 is an inline member template. (Order is important; consider the
12746 case where a template parameter has the same name as a field of
12747 the class.) It is not until after this point that
12748 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
12749 if (flags & SF_INCLASS_INLINE)
12750 maybe_begin_member_template_processing (decl1);
12752 /* Effective C++ rule 15. */
12754 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
12755 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
12756 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
12758 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12759 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12760 if (!DECL_INITIAL (decl1))
12761 DECL_INITIAL (decl1) = error_mark_node;
12763 /* This function exists in static storage.
12764 (This does not mean `static' in the C sense!) */
12765 TREE_STATIC (decl1) = 1;
12767 /* We must call push_template_decl after current_class_type is set
12768 up. (If we are processing inline definitions after exiting a
12769 class scope, current_class_type will be NULL_TREE until set above
12770 by push_nested_class.) */
12771 if (processing_template_decl)
12773 /* FIXME: Handle error_mark_node more gracefully. */
12774 tree newdecl1 = push_template_decl (decl1);
12775 if (newdecl1 != error_mark_node)
12779 /* We are now in the scope of the function being defined. */
12780 current_function_decl = decl1;
12782 /* Save the parm names or decls from this function's declarator
12783 where store_parm_decls will find them. */
12784 current_function_parms = DECL_ARGUMENTS (decl1);
12786 /* Make sure the parameter and return types are reasonable. When
12787 you declare a function, these types can be incomplete, but they
12788 must be complete when you define the function. */
12789 check_function_type (decl1, current_function_parms);
12791 /* Build the return declaration for the function. */
12792 restype = TREE_TYPE (fntype);
12794 if (DECL_RESULT (decl1) == NULL_TREE)
12798 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
12799 DECL_ARTIFICIAL (resdecl) = 1;
12800 DECL_IGNORED_P (resdecl) = 1;
12801 DECL_RESULT (decl1) = resdecl;
12803 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
12806 /* Let the user know we're compiling this function. */
12807 announce_function (decl1);
12809 /* Record the decl so that the function name is defined.
12810 If we already have a decl for this name, and it is a FUNCTION_DECL,
12811 use the old decl. */
12812 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
12814 /* A specialization is not used to guide overload resolution. */
12815 if (!DECL_FUNCTION_MEMBER_P (decl1)
12816 && !(DECL_USE_TEMPLATE (decl1) &&
12817 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
12819 tree olddecl = pushdecl (decl1);
12821 if (olddecl == error_mark_node)
12822 /* If something went wrong when registering the declaration,
12823 use DECL1; we have to have a FUNCTION_DECL to use when
12824 parsing the body of the function. */
12828 /* Otherwise, OLDDECL is either a previous declaration
12829 of the same function or DECL1 itself. */
12831 if (warn_missing_declarations
12832 && olddecl == decl1
12833 && !DECL_MAIN_P (decl1)
12834 && TREE_PUBLIC (decl1)
12835 && !DECL_DECLARED_INLINE_P (decl1))
12839 /* Check whether DECL1 is in an anonymous
12841 for (context = DECL_CONTEXT (decl1);
12843 context = DECL_CONTEXT (context))
12845 if (TREE_CODE (context) == NAMESPACE_DECL
12846 && DECL_NAME (context) == NULL_TREE)
12850 if (context == NULL)
12851 warning (OPT_Wmissing_declarations,
12852 "no previous declaration for %q+D", decl1);
12860 /* We need to set the DECL_CONTEXT. */
12861 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
12862 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
12864 fntype = TREE_TYPE (decl1);
12866 /* If #pragma weak applies, mark the decl appropriately now.
12867 The pragma only applies to global functions. Because
12868 determining whether or not the #pragma applies involves
12869 computing the mangled name for the declaration, we cannot
12870 apply the pragma until after we have merged this declaration
12871 with any previous declarations; if the original declaration
12872 has a linkage specification, that specification applies to
12873 the definition as well, and may affect the mangled name. */
12874 if (DECL_FILE_SCOPE_P (decl1))
12875 maybe_apply_pragma_weak (decl1);
12878 /* Reset this in case the call to pushdecl changed it. */
12879 current_function_decl = decl1;
12881 gcc_assert (DECL_INITIAL (decl1));
12883 /* This function may already have been parsed, in which case just
12884 return; our caller will skip over the body without parsing. */
12885 if (DECL_INITIAL (decl1) != error_mark_node)
12888 /* Initialize RTL machinery. We cannot do this until
12889 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
12890 even when processing a template; this is how we get
12891 CFUN set up, and our per-function variables initialized.
12892 FIXME factor out the non-RTL stuff. */
12893 bl = current_binding_level;
12894 allocate_struct_function (decl1, processing_template_decl);
12896 /* Initialize the language data structures. Whenever we start
12897 a new function, we destroy temporaries in the usual way. */
12898 cfun->language = ggc_alloc_cleared_language_function ();
12899 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12900 current_binding_level = bl;
12902 if (!processing_template_decl && type_uses_auto (restype))
12904 FNDECL_USED_AUTO (decl1) = true;
12905 current_function_auto_return_pattern = restype;
12908 /* Start the statement-tree, start the tree now. */
12909 DECL_SAVED_TREE (decl1) = push_stmt_list ();
12911 /* If we are (erroneously) defining a function that we have already
12912 defined before, wipe out what we knew before. */
12913 if (!DECL_PENDING_INLINE_P (decl1))
12914 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
12916 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
12918 /* We know that this was set up by `grokclassfn'. We do not
12919 wait until `store_parm_decls', since evil parse errors may
12920 never get us to that point. Here we keep the consistency
12921 between `current_class_type' and `current_class_ptr'. */
12922 tree t = DECL_ARGUMENTS (decl1);
12924 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
12925 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
12927 cp_function_chain->x_current_class_ref
12928 = cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
12929 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
12930 cp_function_chain->x_current_class_ptr = t;
12932 /* Constructors and destructors need to know whether they're "in
12933 charge" of initializing virtual base classes. */
12934 t = DECL_CHAIN (t);
12935 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
12937 current_in_charge_parm = t;
12938 t = DECL_CHAIN (t);
12940 if (DECL_HAS_VTT_PARM_P (decl1))
12942 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
12943 current_vtt_parm = t;
12947 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
12948 /* Implicitly-defined methods (like the
12949 destructor for a class in which no destructor
12950 is explicitly declared) must not be defined
12951 until their definition is needed. So, we
12952 ignore interface specifications for
12953 compiler-generated functions. */
12954 && !DECL_ARTIFICIAL (decl1));
12956 if (processing_template_decl)
12957 /* Don't mess with interface flags. */;
12958 else if (DECL_INTERFACE_KNOWN (decl1))
12960 tree ctx = decl_function_context (decl1);
12962 if (DECL_NOT_REALLY_EXTERN (decl1))
12963 DECL_EXTERNAL (decl1) = 0;
12965 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
12966 && TREE_PUBLIC (ctx))
12967 /* This is a function in a local class in an extern inline
12969 comdat_linkage (decl1);
12971 /* If this function belongs to an interface, it is public.
12972 If it belongs to someone else's interface, it is also external.
12973 This only affects inlines and template instantiations. */
12974 else if (!finfo->interface_unknown && honor_interface)
12976 if (DECL_DECLARED_INLINE_P (decl1)
12977 || DECL_TEMPLATE_INSTANTIATION (decl1))
12979 DECL_EXTERNAL (decl1)
12980 = (finfo->interface_only
12981 || (DECL_DECLARED_INLINE_P (decl1)
12982 && ! flag_implement_inlines
12983 && !DECL_VINDEX (decl1)));
12985 /* For WIN32 we also want to put these in linkonce sections. */
12986 maybe_make_one_only (decl1);
12989 DECL_EXTERNAL (decl1) = 0;
12990 DECL_INTERFACE_KNOWN (decl1) = 1;
12991 /* If this function is in an interface implemented in this file,
12992 make sure that the back end knows to emit this function
12994 if (!DECL_EXTERNAL (decl1))
12995 mark_needed (decl1);
12997 else if (finfo->interface_unknown && finfo->interface_only
12998 && honor_interface)
13000 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13001 interface, we will have both finfo->interface_unknown and
13002 finfo->interface_only set. In that case, we don't want to
13003 use the normal heuristics because someone will supply a
13004 #pragma implementation elsewhere, and deducing it here would
13005 produce a conflict. */
13006 comdat_linkage (decl1);
13007 DECL_EXTERNAL (decl1) = 0;
13008 DECL_INTERFACE_KNOWN (decl1) = 1;
13009 DECL_DEFER_OUTPUT (decl1) = 1;
13013 /* This is a definition, not a reference.
13014 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13015 if (!GNU_INLINE_P (decl1))
13016 DECL_EXTERNAL (decl1) = 0;
13018 if ((DECL_DECLARED_INLINE_P (decl1)
13019 || DECL_TEMPLATE_INSTANTIATION (decl1))
13020 && ! DECL_INTERFACE_KNOWN (decl1))
13021 DECL_DEFER_OUTPUT (decl1) = 1;
13023 DECL_INTERFACE_KNOWN (decl1) = 1;
13026 /* Determine the ELF visibility attribute for the function. We must not
13027 do this before calling "pushdecl", as we must allow "duplicate_decls"
13028 to merge any attributes appropriately. We also need to wait until
13030 if (!DECL_CLONED_FUNCTION_P (decl1))
13031 determine_visibility (decl1);
13033 begin_scope (sk_function_parms, decl1);
13037 if (DECL_DESTRUCTOR_P (decl1)
13038 || (DECL_CONSTRUCTOR_P (decl1)
13039 && targetm.cxx.cdtor_returns_this ()))
13041 cdtor_label = build_decl (input_location,
13042 LABEL_DECL, NULL_TREE, NULL_TREE);
13043 DECL_CONTEXT (cdtor_label) = current_function_decl;
13046 start_fname_decls ();
13048 store_parm_decls (current_function_parms);
13052 /* Like start_preparsed_function, except that instead of a
13053 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13055 Returns 1 on success. If the DECLARATOR is not suitable for a function
13056 (it defines a datum instead), we return 0, which tells
13057 yyparse to report a parse error. */
13060 start_function (cp_decl_specifier_seq *declspecs,
13061 const cp_declarator *declarator,
13066 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
13067 if (decl1 == error_mark_node)
13069 /* If the declarator is not suitable for a function definition,
13070 cause a syntax error. */
13071 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13073 error ("invalid function declaration");
13077 if (DECL_MAIN_P (decl1))
13078 /* main must return int. grokfndecl should have corrected it
13079 (and issued a diagnostic) if the user got it wrong. */
13080 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
13081 integer_type_node));
13083 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
13088 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13092 use_eh_spec_block (tree fn)
13094 return (flag_exceptions && flag_enforce_eh_specs
13095 && !processing_template_decl
13096 && !type_throw_all_p (TREE_TYPE (fn))
13097 /* We insert the EH_SPEC_BLOCK only in the original
13098 function; then, it is copied automatically to the
13100 && !DECL_CLONED_FUNCTION_P (fn)
13101 /* Implicitly-generated constructors and destructors have
13102 exception specifications. However, those specifications
13103 are the union of the possible exceptions specified by the
13104 constructors/destructors for bases and members, so no
13105 unallowed exception will ever reach this function. By
13106 not creating the EH_SPEC_BLOCK we save a little memory,
13107 and we avoid spurious warnings about unreachable
13109 && !DECL_DEFAULTED_FN (fn));
13112 /* Store the parameter declarations into the current function declaration.
13113 This is called after parsing the parameter declarations, before
13114 digesting the body of the function.
13116 Also install to binding contour return value identifier, if any. */
13119 store_parm_decls (tree current_function_parms)
13121 tree fndecl = current_function_decl;
13124 /* This is a chain of any other decls that came in among the parm
13125 declarations. If a parm is declared with enum {foo, bar} x;
13126 then CONST_DECLs for foo and bar are put here. */
13127 tree nonparms = NULL_TREE;
13129 if (current_function_parms)
13131 /* This case is when the function was defined with an ANSI prototype.
13132 The parms already have decls, so we need not do anything here
13133 except record them as in effect
13134 and complain if any redundant old-style parm decls were written. */
13136 tree specparms = current_function_parms;
13139 /* Must clear this because it might contain TYPE_DECLs declared
13141 current_binding_level->names = NULL;
13143 /* If we're doing semantic analysis, then we'll call pushdecl
13144 for each of these. We must do them in reverse order so that
13145 they end in the correct forward order. */
13146 specparms = nreverse (specparms);
13148 for (parm = specparms; parm; parm = next)
13150 next = DECL_CHAIN (parm);
13151 if (TREE_CODE (parm) == PARM_DECL)
13153 if (DECL_NAME (parm) == NULL_TREE
13154 || TREE_CODE (parm) != VOID_TYPE)
13157 error ("parameter %qD declared void", parm);
13161 /* If we find an enum constant or a type tag,
13162 put it aside for the moment. */
13163 TREE_CHAIN (parm) = NULL_TREE;
13164 nonparms = chainon (nonparms, parm);
13168 /* Get the decls in their original chain order and record in the
13169 function. This is all and only the PARM_DECLs that were
13170 pushed into scope by the loop above. */
13171 DECL_ARGUMENTS (fndecl) = getdecls ();
13174 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13176 /* Now store the final chain of decls for the arguments
13177 as the decl-chain of the current lexical scope.
13178 Put the enumerators in as well, at the front so that
13179 DECL_ARGUMENTS is not modified. */
13180 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
13182 if (use_eh_spec_block (current_function_decl))
13183 current_eh_spec_block = begin_eh_spec_block ();
13187 /* We have finished doing semantic analysis on DECL, but have not yet
13188 generated RTL for its body. Save away our current state, so that
13189 when we want to generate RTL later we know what to do. */
13192 save_function_data (tree decl)
13194 struct language_function *f;
13196 /* Save the language-specific per-function data so that we can
13197 get it back when we really expand this function. */
13198 gcc_assert (!DECL_PENDING_INLINE_P (decl));
13201 f = ggc_alloc_language_function ();
13202 memcpy (f, cp_function_chain, sizeof (struct language_function));
13203 DECL_SAVED_FUNCTION_DATA (decl) = f;
13205 /* Clear out the bits we don't need. */
13206 f->base.x_stmt_tree.x_cur_stmt_list = NULL;
13207 f->bindings = NULL;
13208 f->x_local_names = NULL;
13209 f->base.local_typedefs = NULL;
13213 /* Set the return value of the constructor (if present). */
13216 finish_constructor_body (void)
13221 if (targetm.cxx.cdtor_returns_this ()
13222 && (! TYPE_FOR_JAVA (current_class_type)))
13224 /* Any return from a constructor will end up here. */
13225 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13227 val = DECL_ARGUMENTS (current_function_decl);
13228 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13229 DECL_RESULT (current_function_decl), val);
13230 /* Return the address of the object. */
13231 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13232 add_stmt (exprstmt);
13236 /* Do all the processing for the beginning of a destructor; set up the
13237 vtable pointers and cleanups for bases and members. */
13240 begin_destructor_body (void)
13242 tree compound_stmt;
13244 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13245 issued an error message. We still want to try to process the
13246 body of the function, but initialize_vtbl_ptrs will crash if
13247 TYPE_BINFO is NULL. */
13248 if (COMPLETE_TYPE_P (current_class_type))
13250 compound_stmt = begin_compound_stmt (0);
13251 /* Make all virtual function table pointers in non-virtual base
13252 classes point to CURRENT_CLASS_TYPE's virtual function
13254 initialize_vtbl_ptrs (current_class_ptr);
13255 finish_compound_stmt (compound_stmt);
13257 /* And insert cleanups for our bases and members so that they
13258 will be properly destroyed if we throw. */
13259 push_base_cleanups ();
13263 /* At the end of every destructor we generate code to delete the object if
13264 necessary. Do that now. */
13267 finish_destructor_body (void)
13271 /* Any return from a destructor will end up here; that way all base
13272 and member cleanups will be run when the function returns. */
13273 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13275 /* In a virtual destructor, we must call delete. */
13276 if (DECL_VIRTUAL_P (current_function_decl))
13279 tree virtual_size = cxx_sizeof (current_class_type);
13283 At the point of definition of a virtual destructor (including
13284 an implicit definition), non-placement operator delete shall
13285 be looked up in the scope of the destructor's class and if
13286 found shall be accessible and unambiguous. */
13287 exprstmt = build_op_delete_call (DELETE_EXPR, current_class_ptr,
13289 /*global_p=*/false,
13290 /*placement=*/NULL_TREE,
13291 /*alloc_fn=*/NULL_TREE,
13292 tf_warning_or_error);
13294 if_stmt = begin_if_stmt ();
13295 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
13296 current_in_charge_parm,
13299 finish_expr_stmt (exprstmt);
13300 finish_then_clause (if_stmt);
13301 finish_if_stmt (if_stmt);
13304 if (targetm.cxx.cdtor_returns_this ())
13308 val = DECL_ARGUMENTS (current_function_decl);
13309 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13310 DECL_RESULT (current_function_decl), val);
13311 /* Return the address of the object. */
13312 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13313 add_stmt (exprstmt);
13317 /* Do the necessary processing for the beginning of a function body, which
13318 in this case includes member-initializers, but not the catch clauses of
13319 a function-try-block. Currently, this means opening a binding level
13320 for the member-initializers (in a ctor), member cleanups (in a dtor),
13321 and capture proxies (in a lambda operator()). */
13324 begin_function_body (void)
13328 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
13331 if (processing_template_decl)
13332 /* Do nothing now. */;
13334 /* Always keep the BLOCK node associated with the outermost pair of
13335 curly braces of a function. These are needed for correct
13336 operation of dwarfout.c. */
13337 keep_next_level (true);
13339 stmt = begin_compound_stmt (BCS_FN_BODY);
13341 if (processing_template_decl)
13342 /* Do nothing now. */;
13343 else if (DECL_DESTRUCTOR_P (current_function_decl))
13344 begin_destructor_body ();
13349 /* Do the processing for the end of a function body. Currently, this means
13350 closing out the cleanups for fully-constructed bases and members, and in
13351 the case of the destructor, deleting the object if desired. Again, this
13352 is only meaningful for [cd]tors, since they are the only functions where
13353 there is a significant distinction between the main body and any
13354 function catch clauses. Handling, say, main() return semantics here
13355 would be wrong, as flowing off the end of a function catch clause for
13356 main() would also need to return 0. */
13359 finish_function_body (tree compstmt)
13361 if (compstmt == NULL_TREE)
13364 /* Close the block. */
13365 finish_compound_stmt (compstmt);
13367 if (processing_template_decl)
13368 /* Do nothing now. */;
13369 else if (DECL_CONSTRUCTOR_P (current_function_decl))
13370 finish_constructor_body ();
13371 else if (DECL_DESTRUCTOR_P (current_function_decl))
13372 finish_destructor_body ();
13375 /* Given a function, returns the BLOCK corresponding to the outermost level
13376 of curly braces, skipping the artificial block created for constructor
13380 outer_curly_brace_block (tree fndecl)
13382 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
13383 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
13384 /* Skip the artificial function body block. */
13385 block = BLOCK_SUBBLOCKS (block);
13389 /* If FNDECL is a class's key method, add the class to the list of
13390 keyed classes that should be emitted. */
13393 record_key_method_defined (tree fndecl)
13395 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
13396 && DECL_VIRTUAL_P (fndecl)
13397 && !processing_template_decl)
13399 tree fnclass = DECL_CONTEXT (fndecl);
13400 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
13401 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
13405 /* Subroutine of finish_function.
13406 Save the body of constexpr functions for possible
13407 future compile time evaluation. */
13410 maybe_save_function_definition (tree fun)
13412 if (!processing_template_decl
13413 && DECL_DECLARED_CONSTEXPR_P (fun)
13414 && !DECL_CLONED_FUNCTION_P (fun))
13415 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
13418 /* Finish up a function declaration and compile that function
13419 all the way to assembler language output. The free the storage
13420 for the function definition.
13422 FLAGS is a bitwise or of the following values:
13424 We just finished processing the body of an in-class inline
13425 function definition. (This processing will have taken place
13426 after the class definition is complete.) */
13429 finish_function (int flags)
13431 tree fndecl = current_function_decl;
13432 tree fntype, ctype = NULL_TREE;
13433 int inclass_inline = (flags & 2) != 0;
13435 /* When we get some parse errors, we can end up without a
13436 current_function_decl, so cope. */
13437 if (fndecl == NULL_TREE)
13438 return error_mark_node;
13440 if (c_dialect_objc ())
13441 objc_finish_function ();
13443 gcc_assert (!defer_mark_used_calls);
13444 defer_mark_used_calls = true;
13446 record_key_method_defined (fndecl);
13448 fntype = TREE_TYPE (fndecl);
13450 /* TREE_READONLY (fndecl) = 1;
13451 This caused &foo to be of type ptr-to-const-function
13452 which then got a warning when stored in a ptr-to-function variable. */
13454 gcc_assert (building_stmt_list_p ());
13455 /* The current function is being defined, so its DECL_INITIAL should
13456 be set, and unless there's a multiple definition, it should be
13457 error_mark_node. */
13458 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
13460 /* For a cloned function, we've already got all the code we need;
13461 there's no need to add any extra bits. */
13462 if (!DECL_CLONED_FUNCTION_P (fndecl))
13464 /* Make it so that `main' always returns 0 by default. */
13465 if (DECL_MAIN_P (current_function_decl))
13466 finish_return_stmt (integer_zero_node);
13468 if (use_eh_spec_block (current_function_decl))
13469 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13470 (TREE_TYPE (current_function_decl)),
13471 current_eh_spec_block);
13474 /* If we're saving up tree structure, tie off the function now. */
13475 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
13477 finish_fname_decls ();
13479 /* If this function can't throw any exceptions, remember that. */
13480 if (!processing_template_decl
13481 && !cp_function_chain->can_throw
13482 && !flag_non_call_exceptions
13483 && !decl_replaceable_p (fndecl))
13484 TREE_NOTHROW (fndecl) = 1;
13486 /* This must come after expand_function_end because cleanups might
13487 have declarations (from inline functions) that need to go into
13488 this function's blocks. */
13490 /* If the current binding level isn't the outermost binding level
13491 for this function, either there is a bug, or we have experienced
13492 syntax errors and the statement tree is malformed. */
13493 if (current_binding_level->kind != sk_function_parms)
13495 /* Make sure we have already experienced errors. */
13496 gcc_assert (errorcount);
13498 /* Throw away the broken statement tree and extra binding
13500 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
13502 while (current_binding_level->kind != sk_function_parms)
13504 if (current_binding_level->kind == sk_class)
13505 pop_nested_class ();
13507 poplevel (0, 0, 0);
13510 poplevel (1, 0, 1);
13512 /* Statements should always be full-expressions at the outermost set
13513 of curly braces for a function. */
13514 gcc_assert (stmts_are_full_exprs_p ());
13516 /* If there are no return statements in a function with auto return type,
13517 the return type is void. But if the declared type is something like
13518 auto*, this is an error. */
13519 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
13520 && TREE_TYPE (fntype) == current_function_auto_return_pattern)
13522 if (!is_auto (current_function_auto_return_pattern)
13523 && !current_function_returns_value && !current_function_returns_null)
13525 error ("no return statements in function returning %qT",
13526 current_function_auto_return_pattern);
13527 inform (input_location, "only plain %<auto%> return type can be "
13528 "deduced to %<void%>");
13530 apply_deduced_return_type (fndecl, void_type_node);
13531 fntype = TREE_TYPE (fndecl);
13534 /* Save constexpr function body before it gets munged by
13535 the NRV transformation. */
13536 maybe_save_function_definition (fndecl);
13538 /* Set up the named return value optimization, if we can. Candidate
13539 variables are selected in check_return_expr. */
13540 if (current_function_return_value)
13542 tree r = current_function_return_value;
13545 if (r != error_mark_node
13546 /* This is only worth doing for fns that return in memory--and
13547 simpler, since we don't have to worry about promoted modes. */
13548 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
13549 /* Only allow this for variables declared in the outer scope of
13550 the function so we know that their lifetime always ends with a
13551 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13552 we were to do this optimization in tree-ssa. */
13553 && (outer = outer_curly_brace_block (fndecl))
13554 && chain_member (r, BLOCK_VARS (outer)))
13555 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
13557 current_function_return_value = NULL_TREE;
13560 /* Remember that we were in class scope. */
13561 if (current_class_name)
13562 ctype = current_class_type;
13564 /* Must mark the RESULT_DECL as being in this function. */
13565 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13567 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13568 to the FUNCTION_DECL node itself. */
13569 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13571 /* Save away current state, if appropriate. */
13572 if (!processing_template_decl)
13573 save_function_data (fndecl);
13575 /* Complain if there's just no return statement. */
13576 if (warn_return_type
13577 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
13578 && !dependent_type_p (TREE_TYPE (fntype))
13579 && !current_function_returns_value && !current_function_returns_null
13580 /* Don't complain if we abort or throw. */
13581 && !current_function_returns_abnormally
13582 /* Don't complain if we are declared noreturn. */
13583 && !TREE_THIS_VOLATILE (fndecl)
13584 && !DECL_NAME (DECL_RESULT (fndecl))
13585 && !TREE_NO_WARNING (fndecl)
13586 /* Structor return values (if any) are set by the compiler. */
13587 && !DECL_CONSTRUCTOR_P (fndecl)
13588 && !DECL_DESTRUCTOR_P (fndecl)
13589 && targetm.warn_func_return (fndecl))
13591 warning (OPT_Wreturn_type,
13592 "no return statement in function returning non-void");
13593 TREE_NO_WARNING (fndecl) = 1;
13596 /* Store the end of the function, so that we get good line number
13597 info for the epilogue. */
13598 cfun->function_end_locus = input_location;
13600 /* Complain about parameters that are only set, but never otherwise used. */
13601 if (warn_unused_but_set_parameter
13602 && !processing_template_decl
13603 && errorcount == unused_but_set_errorcount
13604 && !DECL_CLONED_FUNCTION_P (fndecl))
13608 for (decl = DECL_ARGUMENTS (fndecl);
13610 decl = DECL_CHAIN (decl))
13611 if (TREE_USED (decl)
13612 && TREE_CODE (decl) == PARM_DECL
13613 && !DECL_READ_P (decl)
13614 && DECL_NAME (decl)
13615 && !DECL_ARTIFICIAL (decl)
13616 && !TREE_NO_WARNING (decl)
13617 && !DECL_IN_SYSTEM_HEADER (decl)
13618 && TREE_TYPE (decl) != error_mark_node
13619 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
13620 && (!CLASS_TYPE_P (TREE_TYPE (decl))
13621 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
13622 warning (OPT_Wunused_but_set_parameter,
13623 "parameter %q+D set but not used", decl);
13624 unused_but_set_errorcount = errorcount;
13627 /* Complain about locally defined typedefs that are not used in this
13629 maybe_warn_unused_local_typedefs ();
13631 /* Genericize before inlining. */
13632 if (!processing_template_decl)
13634 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
13635 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
13636 cp_genericize (fndecl);
13637 /* Clear out the bits we don't need. */
13638 f->x_current_class_ptr = NULL;
13639 f->x_current_class_ref = NULL;
13640 f->x_eh_spec_block = NULL;
13641 f->x_in_charge_parm = NULL;
13642 f->x_vtt_parm = NULL;
13643 f->x_return_value = NULL;
13644 f->bindings = NULL;
13645 f->extern_decl_map = NULL;
13647 /* Clear out the bits we don't need. */
13648 local_names = NULL;
13650 /* We're leaving the context of this function, so zap cfun. It's still in
13651 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
13653 current_function_decl = NULL;
13655 /* If this is an in-class inline definition, we may have to pop the
13656 bindings for the template parameters that we added in
13657 maybe_begin_member_template_processing when start_function was
13659 if (inclass_inline)
13660 maybe_end_member_template_processing ();
13662 /* Leave the scope of the class. */
13664 pop_nested_class ();
13669 current_function_decl = NULL_TREE;
13671 defer_mark_used_calls = false;
13672 if (deferred_mark_used_calls)
13677 FOR_EACH_VEC_ELT (tree, deferred_mark_used_calls, i, decl)
13679 VEC_free (tree, gc, deferred_mark_used_calls);
13685 /* Create the FUNCTION_DECL for a function definition.
13686 DECLSPECS and DECLARATOR are the parts of the declaration;
13687 they describe the return type and the name of the function,
13688 but twisted together in a fashion that parallels the syntax of C.
13690 This function creates a binding context for the function body
13691 as well as setting up the FUNCTION_DECL in current_function_decl.
13693 Returns a FUNCTION_DECL on success.
13695 If the DECLARATOR is not suitable for a function (it defines a datum
13696 instead), we return 0, which tells yyparse to report a parse error.
13698 May return void_type_node indicating that this method is actually
13699 a friend. See grokfield for more details.
13701 Came here with a `.pushlevel' .
13703 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13704 CHANGES TO CODE IN `grokfield'. */
13707 grokmethod (cp_decl_specifier_seq *declspecs,
13708 const cp_declarator *declarator, tree attrlist)
13710 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
13713 if (fndecl == error_mark_node)
13714 return error_mark_node;
13716 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
13718 error ("invalid member function declaration");
13719 return error_mark_node;
13723 cplus_decl_attributes (&fndecl, attrlist, 0);
13725 /* Pass friends other than inline friend functions back. */
13726 if (fndecl == void_type_node)
13729 if (DECL_IN_AGGR_P (fndecl))
13731 if (DECL_CLASS_SCOPE_P (fndecl))
13732 error ("%qD is already defined in class %qT", fndecl,
13733 DECL_CONTEXT (fndecl));
13734 return error_mark_node;
13737 check_template_shadow (fndecl);
13739 DECL_DECLARED_INLINE_P (fndecl) = 1;
13740 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
13742 /* We process method specializations in finish_struct_1. */
13743 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
13745 fndecl = push_template_decl (fndecl);
13746 if (fndecl == error_mark_node)
13750 if (! DECL_FRIEND_P (fndecl))
13752 if (DECL_CHAIN (fndecl))
13754 fndecl = copy_node (fndecl);
13755 TREE_CHAIN (fndecl) = NULL_TREE;
13759 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
13761 DECL_IN_AGGR_P (fndecl) = 1;
13766 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
13767 we can lay it out later, when and if its type becomes complete. */
13770 maybe_register_incomplete_var (tree var)
13772 gcc_assert (TREE_CODE (var) == VAR_DECL);
13774 /* Keep track of variables with incomplete types. */
13775 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
13776 && DECL_EXTERNAL (var))
13778 tree inner_type = TREE_TYPE (var);
13780 while (TREE_CODE (inner_type) == ARRAY_TYPE)
13781 inner_type = TREE_TYPE (inner_type);
13782 inner_type = TYPE_MAIN_VARIANT (inner_type);
13784 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
13785 /* RTTI TD entries are created while defining the type_info. */
13786 || (TYPE_LANG_SPECIFIC (inner_type)
13787 && TYPE_BEING_DEFINED (inner_type)))
13789 incomplete_var iv = {var, inner_type};
13790 VEC_safe_push (incomplete_var, gc, incomplete_vars, iv);
13795 /* Called when a class type (given by TYPE) is defined. If there are
13796 any existing VAR_DECLs whose type has been completed by this
13797 declaration, update them now. */
13800 complete_vars (tree type)
13803 incomplete_var *iv;
13805 for (ix = 0; VEC_iterate (incomplete_var, incomplete_vars, ix, iv); )
13807 if (same_type_p (type, iv->incomplete_type))
13809 tree var = iv->decl;
13810 tree type = TREE_TYPE (var);
13811 /* Complete the type of the variable. The VAR_DECL itself
13812 will be laid out in expand_expr. */
13813 complete_type (type);
13814 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
13815 /* Remove this entry from the list. */
13816 VEC_unordered_remove (incomplete_var, incomplete_vars, ix);
13822 /* Check for pending declarations which may have abstract type. */
13823 complete_type_check_abstract (type);
13826 /* If DECL is of a type which needs a cleanup, build and return an
13827 expression to perform that cleanup here. Return NULL_TREE if no
13828 cleanup need be done. */
13831 cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
13837 /* Assume no cleanup is required. */
13838 cleanup = NULL_TREE;
13840 if (error_operand_p (decl))
13843 /* Handle "__attribute__((cleanup))". We run the cleanup function
13844 before the destructor since the destructor is what actually
13845 terminates the lifetime of the object. */
13846 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
13853 /* Get the name specified by the user for the cleanup function. */
13854 id = TREE_VALUE (TREE_VALUE (attr));
13855 /* Look up the name to find the cleanup function to call. It is
13856 important to use lookup_name here because that is what is
13857 used in c-common.c:handle_cleanup_attribute when performing
13858 initial checks on the attribute. Note that those checks
13859 include ensuring that the function found is not an overloaded
13860 function, or an object with an overloaded call operator,
13861 etc.; we can rely on the fact that the function found is an
13862 ordinary FUNCTION_DECL. */
13863 fn = lookup_name (id);
13864 arg = build_address (decl);
13866 cleanup = cp_build_function_call_nary (fn, complain, arg, NULL_TREE);
13867 if (cleanup == error_mark_node)
13868 return error_mark_node;
13870 /* Handle ordinary C++ destructors. */
13871 type = TREE_TYPE (decl);
13872 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
13874 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
13875 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
13876 && CLASSTYPE_VBASECLASSES (type));
13880 if (TREE_CODE (type) == ARRAY_TYPE)
13883 addr = build_address (decl);
13885 /* Optimize for space over speed here. */
13886 if (!has_vbases || flag_expensive_optimizations)
13887 flags |= LOOKUP_NONVIRTUAL;
13889 call = build_delete (TREE_TYPE (addr), addr,
13890 sfk_complete_destructor, flags, 0, complain);
13891 if (call == error_mark_node)
13892 cleanup = error_mark_node;
13894 cleanup = cp_build_compound_expr (cleanup, call, complain);
13899 /* build_delete sets the location of the destructor call to the
13900 current location, even though the destructor is going to be
13901 called later, at the end of the current scope. This can lead to
13902 a "jumpy" behaviour for users of debuggers when they step around
13903 the end of the block. So let's unset the location of the
13904 destructor call instead. */
13905 if (cleanup != NULL && EXPR_P (cleanup))
13906 SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION);
13911 /* When a stmt has been parsed, this function is called. */
13918 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
13919 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
13920 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
13923 static_fn_type (tree memfntype)
13928 if (TYPE_PTRMEMFUNC_P (memfntype))
13929 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
13930 if (POINTER_TYPE_P (memfntype)
13931 || TREE_CODE (memfntype) == FUNCTION_DECL)
13932 memfntype = TREE_TYPE (memfntype);
13933 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
13935 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
13936 args = TYPE_ARG_TYPES (memfntype);
13937 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
13938 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype));
13939 fntype = (cp_build_type_attribute_variant
13940 (fntype, TYPE_ATTRIBUTES (memfntype)));
13941 fntype = (build_exception_variant
13942 (fntype, TYPE_RAISES_EXCEPTIONS (memfntype)));
13946 /* DECL was originally constructed as a non-static member function,
13947 but turned out to be static. Update it accordingly. */
13950 revert_static_member_fn (tree decl)
13952 tree stype = static_fn_type (decl);
13953 cp_cv_quals quals = type_memfn_quals (stype);
13955 if (quals != TYPE_UNQUALIFIED)
13956 stype = apply_memfn_quals (stype, TYPE_UNQUALIFIED);
13958 TREE_TYPE (decl) = stype;
13960 if (DECL_ARGUMENTS (decl))
13961 DECL_ARGUMENTS (decl) = DECL_CHAIN (DECL_ARGUMENTS (decl));
13962 DECL_STATIC_FUNCTION_P (decl) = 1;
13965 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
13966 one of the language-independent trees. */
13968 enum cp_tree_node_structure_enum
13969 cp_tree_node_structure (union lang_tree_node * t)
13971 switch (TREE_CODE (&t->generic))
13973 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
13974 case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT;
13975 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
13976 case OVERLOAD: return TS_CP_OVERLOAD;
13977 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
13978 case PTRMEM_CST: return TS_CP_PTRMEM;
13979 case BASELINK: return TS_CP_BASELINK;
13980 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
13981 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
13982 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
13983 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR;
13984 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO;
13985 case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL;
13986 default: return TS_CP_GENERIC;
13990 /* Build the void_list_node (void_type_node having been created). */
13992 build_void_list_node (void)
13994 tree t = build_tree_list (NULL_TREE, void_type_node);
13999 cp_missing_noreturn_ok_p (tree decl)
14001 /* A missing noreturn is ok for the `main' function. */
14002 return DECL_MAIN_P (decl);
14005 /* Return the COMDAT group into which DECL should be placed. */
14008 cxx_comdat_group (tree decl)
14012 /* Virtual tables, construction virtual tables, and virtual table
14013 tables all go in a single COMDAT group, named after the primary
14015 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
14016 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
14017 /* For all other DECLs, the COMDAT group is the mangled name of the
14018 declaration itself. */
14021 while (DECL_THUNK_P (decl))
14023 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14024 into the same section as the target function. In that case
14025 we must return target's name. */
14026 tree target = THUNK_TARGET (decl);
14027 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
14028 && DECL_SECTION_NAME (target) != NULL
14029 && DECL_ONE_ONLY (target))
14034 name = DECL_ASSEMBLER_NAME (decl);
14040 #include "gt-cp-decl.h"