1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2013 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
36 #include "tree-iterator.h"
37 #include "tree-inline.h"
44 #include "c-family/c-common.h"
45 #include "c-family/c-objc.h"
46 #include "c-family/c-pragma.h"
47 #include "diagnostic.h"
51 #include "pointer-set.h"
52 #include "splay-tree.h"
56 /* Possible cases of bad specifiers type used by bad_specifiers. */
58 BSP_VAR, /* variable */
59 BSP_PARM, /* parameter */
64 static tree grokparms (tree parmlist, tree *);
65 static const char *redeclaration_error_message (tree, tree);
67 static int decl_jump_unsafe (tree);
68 static void require_complete_types_for_parms (tree);
69 static int ambi_op_p (enum tree_code);
70 static int unary_op_p (enum tree_code);
71 static void push_local_name (tree);
72 static tree grok_reference_init (tree, tree, tree, int);
73 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
75 static int check_static_variable_definition (tree, tree);
76 static void record_unknown_type (tree, const char *);
77 static tree builtin_function_1 (tree, tree, bool);
78 static tree build_library_fn_1 (tree, enum tree_code, tree);
79 static int member_function_or_else (tree, tree, enum overload_flags);
80 static void bad_specifiers (tree, enum bad_spec_place, int, int, int, int,
82 static void check_for_uninitialized_const_var (tree);
83 static hashval_t typename_hash (const void *);
84 static int typename_compare (const void *, const void *);
85 static tree local_variable_p_walkfn (tree *, int *, void *);
86 static tree record_builtin_java_type (const char *, int);
87 static const char *tag_name (enum tag_types);
88 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
89 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
90 static void maybe_deduce_size_from_array_init (tree, tree);
91 static void layout_var_decl (tree);
92 static tree check_initializer (tree, tree, int, vec<tree, va_gc> **);
93 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
94 static void save_function_data (tree);
95 static void copy_type_enum (tree , tree);
96 static void check_function_type (tree, tree);
97 static void finish_constructor_body (void);
98 static void begin_destructor_body (void);
99 static void finish_destructor_body (void);
100 static void record_key_method_defined (tree);
101 static tree create_array_type_for_decl (tree, tree, tree);
102 static tree get_atexit_node (void);
103 static tree get_dso_handle_node (void);
104 static tree start_cleanup_fn (void);
105 static void end_cleanup_fn (void);
106 static tree cp_make_fname_decl (location_t, tree, int);
107 static void initialize_predefined_identifiers (void);
108 static tree check_special_function_return_type
109 (special_function_kind, tree, tree);
110 static tree push_cp_library_fn (enum tree_code, tree);
111 static tree build_cp_library_fn (tree, enum tree_code, tree);
112 static void store_parm_decls (tree);
113 static void initialize_local_var (tree, tree);
114 static void expand_static_init (tree, tree);
116 /* The following symbols are subsumed in the cp_global_trees array, and
117 listed here individually for documentation purposes.
120 tree wchar_decl_node;
122 tree vtable_entry_type;
123 tree delta_type_node;
124 tree __t_desc_type_node;
126 tree class_type_node;
127 tree unknown_type_node;
129 Array type `vtable_entry_type[]'
132 tree vtbl_ptr_type_node;
139 A FUNCTION_DECL which can call `abort'. Not necessarily the
140 one that the user will declare, but sufficient to be called
141 by routines that want to abort the program.
145 The FUNCTION_DECL for the default `::operator delete'.
147 tree global_delete_fndecl;
150 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
151 tree tinfo_var_id; */
153 tree cp_global_trees[CPTI_MAX];
155 /* Indicates that there is a type value in some namespace, although
156 that is not necessarily in scope at the moment. */
158 tree global_type_node;
160 /* The node that holds the "name" of the global scope. */
161 tree global_scope_name;
163 #define local_names cp_function_chain->x_local_names
165 /* A list of objects which have constructors or destructors
166 which reside in the global scope. The decl is stored in
167 the TREE_VALUE slot and the initializer is stored
168 in the TREE_PURPOSE slot. */
169 tree static_aggregates;
171 /* Like static_aggregates, but for thread_local variables. */
176 /* A node for the integer constant 2. */
178 tree integer_two_node;
180 /* Used only for jumps to as-yet undefined labels, since jumps to
181 defined labels can have their validity checked immediately. */
183 struct GTY((chain_next ("%h.next"))) named_label_use_entry {
184 struct named_label_use_entry *next;
185 /* The binding level to which this entry is *currently* attached.
186 This is initially the binding level in which the goto appeared,
187 but is modified as scopes are closed. */
188 cp_binding_level *binding_level;
189 /* The head of the names list that was current when the goto appeared,
190 or the inner scope popped. These are the decls that will *not* be
191 skipped when jumping to the label. */
193 /* The location of the goto, for error reporting. */
194 location_t o_goto_locus;
195 /* True if an OpenMP structured block scope has been closed since
196 the goto appeared. This means that the branch from the label will
197 illegally exit an OpenMP scope. */
201 /* A list of all LABEL_DECLs in the function that have names. Here so
202 we can clear out their names' definitions at the end of the
203 function, and so we can check the validity of jumps to these labels. */
205 struct GTY(()) named_label_entry {
206 /* The decl itself. */
209 /* The binding level to which the label is *currently* attached.
210 This is initially set to the binding level in which the label
211 is defined, but is modified as scopes are closed. */
212 cp_binding_level *binding_level;
213 /* The head of the names list that was current when the label was
214 defined, or the inner scope popped. These are the decls that will
215 be skipped when jumping to the label. */
217 /* A vector of all decls from all binding levels that would be
218 crossed by a backward branch to the label. */
219 vec<tree, va_gc> *bad_decls;
221 /* A list of uses of the label, before the label is defined. */
222 struct named_label_use_entry *uses;
224 /* The following bits are set after the label is defined, and are
225 updated as scopes are popped. They indicate that a backward jump
226 to the label will illegally enter a scope of the given flavor. */
232 #define named_labels cp_function_chain->x_named_labels
234 /* The number of function bodies which we are currently processing.
235 (Zero if we are at namespace scope, one inside the body of a
236 function, two inside the body of a function in a local class, etc.) */
239 /* To avoid unwanted recursion, finish_function defers all mark_used calls
240 encountered during its execution until it finishes. */
241 bool defer_mark_used_calls;
242 vec<tree, va_gc> *deferred_mark_used_calls;
244 /* States indicating how grokdeclarator() should handle declspecs marked
245 with __attribute__((deprecated)). An object declared as
246 __attribute__((deprecated)) suppresses warnings of uses of other
248 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
251 /* A list of VAR_DECLs whose type was incomplete at the time the
252 variable was declared. */
254 typedef struct GTY(()) incomplete_var_d {
256 tree incomplete_type;
260 static GTY(()) vec<incomplete_var, va_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 (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_safe_length (current_binding_level->class_shadowed));
568 /* We used to use KEEP == 2 to indicate that the new block should go
569 at the beginning of the list of blocks at this binding level,
570 rather than the end. This hack is no longer used. */
571 gcc_assert (keep == 0 || keep == 1);
573 if (current_binding_level->keep)
576 /* Any uses of undefined labels, and any defined labels, now operate
577 under constraints of next binding contour. */
578 if (cfun && !functionbody && named_labels)
579 htab_traverse (named_labels, poplevel_named_label_1,
580 current_binding_level);
582 /* Get the decls in the order they were written.
583 Usually current_binding_level->names is in reverse order.
584 But parameter decls were previously put in forward order. */
587 current_binding_level->names
588 = decls = nreverse (current_binding_level->names);
590 decls = current_binding_level->names;
592 /* If there were any declarations or structure tags in that level,
593 or if this level is a function body,
594 create a BLOCK to record them for the life of this function. */
596 if (keep == 1 || functionbody)
597 block = make_node (BLOCK);
598 if (block != NULL_TREE)
600 BLOCK_VARS (block) = decls;
601 BLOCK_SUBBLOCKS (block) = subblocks;
604 /* In each subblock, record that this is its superior. */
606 for (link = subblocks; link; link = BLOCK_CHAIN (link))
607 BLOCK_SUPERCONTEXT (link) = block;
609 /* We still support the old for-scope rules, whereby the variables
610 in a for-init statement were in scope after the for-statement
611 ended. We only use the new rules if flag_new_for_scope is
614 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
616 /* Before we remove the declarations first check for unused variables. */
617 if ((warn_unused_variable || warn_unused_but_set_variable)
618 && !processing_template_decl)
619 for (tree d = getdecls (); d; d = TREE_CHAIN (d))
621 /* There are cases where D itself is a TREE_LIST. See in
622 push_local_binding where the list of decls returned by
623 getdecls is built. */
624 decl = TREE_CODE (d) == TREE_LIST ? TREE_VALUE (d) : d;
625 if (TREE_CODE (decl) == VAR_DECL
626 && (! TREE_USED (decl) || !DECL_READ_P (decl))
627 && ! DECL_IN_SYSTEM_HEADER (decl)
628 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)
629 && TREE_TYPE (decl) != error_mark_node
630 && (!CLASS_TYPE_P (TREE_TYPE (decl))
631 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
633 if (! TREE_USED (decl))
634 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
635 else if (DECL_CONTEXT (decl) == current_function_decl
636 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
637 && errorcount == unused_but_set_errorcount)
639 warning (OPT_Wunused_but_set_variable,
640 "variable %q+D set but not used", decl);
641 unused_but_set_errorcount = errorcount;
646 /* Remove declarations for all the DECLs in this level. */
647 for (link = decls; link; link = TREE_CHAIN (link))
649 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
650 /* It's hard to make this ARM compatibility hack play nicely with
651 lambdas, and it really isn't necessary in C++11 mode. */
652 && cxx_dialect < cxx0x
655 tree name = DECL_NAME (link);
659 ob = outer_binding (name,
660 IDENTIFIER_BINDING (name),
663 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
665 ns_binding = NULL_TREE;
667 if (ob && ob->scope == current_binding_level->level_chain)
668 /* We have something like:
673 and we are leaving the `for' scope. There's no reason to
674 keep the binding of the inner `i' in this case. */
675 pop_binding (name, link);
676 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
677 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
678 /* Here, we have something like:
686 We must pop the for-scope binding so we know what's a
687 type and what isn't. */
688 pop_binding (name, link);
691 /* Mark this VAR_DECL as dead so that we can tell we left it
692 there only for backward compatibility. */
693 DECL_DEAD_FOR_LOCAL (link) = 1;
695 /* Keep track of what should have happened when we
696 popped the binding. */
699 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
700 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
703 /* Add it to the list of dead variables in the next
704 outermost binding to that we can remove these when we
705 leave that binding. */
707 current_binding_level->level_chain->dead_vars_from_for,
710 /* Although we don't pop the cxx_binding, we do clear
711 its SCOPE since the scope is going away now. */
712 IDENTIFIER_BINDING (name)->scope
713 = current_binding_level->level_chain;
720 /* Remove the binding. */
723 if (TREE_CODE (decl) == TREE_LIST)
724 decl = TREE_VALUE (decl);
727 if (TREE_CODE (name) == OVERLOAD)
728 name = OVL_FUNCTION (name);
730 gcc_assert (DECL_P (name));
731 pop_binding (DECL_NAME (name), decl);
735 /* Remove declarations for any `for' variables from inner scopes
736 that we kept around. */
737 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->dead_vars_from_for,
739 pop_binding (DECL_NAME (decl), decl);
741 /* Restore the IDENTIFIER_TYPE_VALUEs. */
742 for (link = current_binding_level->type_shadowed;
743 link; link = TREE_CHAIN (link))
744 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
746 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
747 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->shadowed_labels,
749 pop_local_label (label_bind->label, label_bind->prev_value);
751 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
752 list if a `using' declaration put them there. The debugging
753 back ends won't understand OVERLOAD, so we remove them here.
754 Because the BLOCK_VARS are (temporarily) shared with
755 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
756 popped all the bindings. */
761 for (d = &BLOCK_VARS (block); *d; )
763 if (TREE_CODE (*d) == TREE_LIST)
764 *d = TREE_CHAIN (*d);
766 d = &DECL_CHAIN (*d);
770 /* If the level being exited is the top level of a function,
771 check over all the labels. */
774 /* Since this is the top level block of a function, the vars are
775 the function's parameters. Don't leave them in the BLOCK
776 because they are found in the FUNCTION_DECL instead. */
777 BLOCK_VARS (block) = 0;
781 kind = current_binding_level->kind;
782 if (kind == sk_cleanup)
786 /* If this is a temporary binding created for a cleanup, then we'll
787 have pushed a statement list level. Pop that, create a new
788 BIND_EXPR for the block, and insert it into the stream. */
789 stmt = pop_stmt_list (current_binding_level->statement_list);
790 stmt = c_build_bind_expr (input_location, block, stmt);
797 /* The current function is being defined, so its DECL_INITIAL
798 should be error_mark_node. */
799 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
800 DECL_INITIAL (current_function_decl) = block;
803 current_binding_level->blocks
804 = block_chainon (current_binding_level->blocks, block);
806 /* If we did not make a block for the level just exited,
807 any blocks made for inner levels
808 (since they cannot be recorded as subblocks in that level)
809 must be carried forward so they will later become subblocks
810 of something else. */
812 current_binding_level->blocks
813 = block_chainon (current_binding_level->blocks, subblocks);
815 /* Each and every BLOCK node created here in `poplevel' is important
816 (e.g. for proper debugging information) so if we created one
817 earlier, mark it as "used". */
819 TREE_USED (block) = 1;
821 /* All temporary bindings created for cleanups are popped silently. */
822 if (kind == sk_cleanup)
825 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
829 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
830 itself, calling F for each. The DATA is passed to F as well. */
833 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
836 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
838 result |= (*f) (name_space, data);
840 for (; current; current = DECL_CHAIN (current))
841 result |= walk_namespaces_r (current, f, data);
846 /* Walk all the namespaces, calling F for each. The DATA is passed to
850 walk_namespaces (walk_namespaces_fn f, void* data)
852 return walk_namespaces_r (global_namespace, f, data);
855 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
856 DATA is non-NULL, this is the last time we will call
857 wrapup_global_declarations for this NAMESPACE. */
860 wrapup_globals_for_namespace (tree name_space, void* data)
862 cp_binding_level *level = NAMESPACE_LEVEL (name_space);
863 vec<tree, va_gc> *statics = level->static_decls;
864 tree *vec = statics->address ();
865 int len = statics->length ();
866 int last_time = (data != 0);
870 check_global_declarations (vec, len);
871 emit_debug_global_declarations (vec, len);
875 /* Write out any globals that need to be output. */
876 return wrapup_global_declarations (vec, len);
880 /* In C++, you don't have to write `struct S' to refer to `S'; you
881 can just use `S'. We accomplish this by creating a TYPE_DECL as
882 if the user had written `typedef struct S S'. Create and return
883 the TYPE_DECL for TYPE. */
886 create_implicit_typedef (tree name, tree type)
890 decl = build_decl (input_location, TYPE_DECL, name, type);
891 DECL_ARTIFICIAL (decl) = 1;
892 /* There are other implicit type declarations, like the one *within*
893 a class that allows you to write `S::S'. We must distinguish
895 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
896 TYPE_NAME (type) = decl;
897 TYPE_STUB_DECL (type) = decl;
902 /* Remember a local name for name-mangling purposes. */
905 push_local_name (tree decl)
910 timevar_start (TV_NAME_LOOKUP);
912 name = DECL_NAME (decl);
914 nelts = vec_safe_length (local_names);
915 for (i = 0; i < nelts; i++)
917 t = (*local_names)[i];
918 if (DECL_NAME (t) == name)
920 if (!DECL_LANG_SPECIFIC (decl))
921 retrofit_lang_decl (decl);
922 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
923 if (DECL_DISCRIMINATOR_SET_P (t))
924 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
926 DECL_DISCRIMINATOR (decl) = 1;
928 (*local_names)[i] = decl;
929 timevar_stop (TV_NAME_LOOKUP);
934 vec_safe_push (local_names, decl);
935 timevar_stop (TV_NAME_LOOKUP);
938 /* Subroutine of duplicate_decls: return truthvalue of whether
939 or not types of these decls match.
941 For C++, we must compare the parameter list so that `int' can match
942 `int&' in a parameter position, but `int&' is not confused with
946 decls_match (tree newdecl, tree olddecl)
950 if (newdecl == olddecl)
953 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
954 /* If the two DECLs are not even the same kind of thing, we're not
955 interested in their types. */
958 gcc_assert (DECL_P (newdecl));
960 if (TREE_CODE (newdecl) == FUNCTION_DECL)
962 tree f1 = TREE_TYPE (newdecl);
963 tree f2 = TREE_TYPE (olddecl);
964 tree p1 = TYPE_ARG_TYPES (f1);
965 tree p2 = TYPE_ARG_TYPES (f2);
968 /* Specializations of different templates are different functions
969 even if they have the same type. */
970 tree t1 = (DECL_USE_TEMPLATE (newdecl)
971 ? DECL_TI_TEMPLATE (newdecl)
973 tree t2 = (DECL_USE_TEMPLATE (olddecl)
974 ? DECL_TI_TEMPLATE (olddecl)
979 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
980 && ! (DECL_EXTERN_C_P (newdecl)
981 && DECL_EXTERN_C_P (olddecl)))
984 /* A new declaration doesn't match a built-in one unless it
985 is also extern "C". */
986 if (DECL_IS_BUILTIN (olddecl)
987 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
990 if (TREE_CODE (f1) != TREE_CODE (f2))
993 /* A declaration with deduced return type should use its pre-deduction
994 type for declaration matching. */
995 if (FNDECL_USED_AUTO (olddecl))
996 r2 = DECL_STRUCT_FUNCTION (olddecl)->language->x_auto_return_pattern;
1000 if (same_type_p (TREE_TYPE (f1), r2))
1002 if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
1003 && (DECL_BUILT_IN (olddecl)
1004 #ifndef NO_IMPLICIT_EXTERN_C
1005 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
1006 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
1010 types_match = self_promoting_args_p (p1);
1011 if (p1 == void_list_node)
1012 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1014 #ifndef NO_IMPLICIT_EXTERN_C
1015 else if (!prototype_p (f1)
1016 && (DECL_EXTERN_C_P (olddecl)
1017 && DECL_IN_SYSTEM_HEADER (olddecl)
1018 && !DECL_CLASS_SCOPE_P (olddecl))
1019 && (DECL_EXTERN_C_P (newdecl)
1020 && DECL_IN_SYSTEM_HEADER (newdecl)
1021 && !DECL_CLASS_SCOPE_P (newdecl)))
1023 types_match = self_promoting_args_p (p2);
1024 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1030 && type_memfn_rqual (f1) == type_memfn_rqual (f2)
1031 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
1032 || comp_type_attributes (TREE_TYPE (newdecl),
1033 TREE_TYPE (olddecl)) != 0);
1038 /* The decls dont match if they correspond to two different versions
1039 of the same function. Disallow extern "C" functions to be
1040 versions for now. */
1042 && !DECL_EXTERN_C_P (newdecl)
1043 && !DECL_EXTERN_C_P (olddecl)
1044 && targetm.target_option.function_versions (newdecl, olddecl))
1046 /* Mark functions as versions if necessary. Modify the mangled decl
1047 name if necessary. */
1048 if (DECL_FUNCTION_VERSIONED (newdecl)
1049 && DECL_FUNCTION_VERSIONED (olddecl))
1051 if (!DECL_FUNCTION_VERSIONED (newdecl))
1053 DECL_FUNCTION_VERSIONED (newdecl) = 1;
1054 if (DECL_ASSEMBLER_NAME_SET_P (newdecl))
1055 mangle_decl (newdecl);
1057 if (!DECL_FUNCTION_VERSIONED (olddecl))
1059 DECL_FUNCTION_VERSIONED (olddecl) = 1;
1060 if (DECL_ASSEMBLER_NAME_SET_P (olddecl))
1061 mangle_decl (olddecl);
1063 record_function_versions (olddecl, newdecl);
1067 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1069 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1070 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1073 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1074 DECL_TEMPLATE_PARMS (olddecl)))
1077 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1078 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1079 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1081 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1082 DECL_TEMPLATE_RESULT (newdecl));
1086 /* Need to check scope for variable declaration (VAR_DECL).
1087 For typedef (TYPE_DECL), scope is ignored. */
1088 if (TREE_CODE (newdecl) == VAR_DECL
1089 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1091 Two declarations for an object with C language linkage
1092 with the same name (ignoring the namespace that qualify
1093 it) that appear in different namespace scopes refer to
1095 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1098 if (TREE_TYPE (newdecl) == error_mark_node)
1099 types_match = TREE_TYPE (olddecl) == error_mark_node;
1100 else if (TREE_TYPE (olddecl) == NULL_TREE)
1101 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1102 else if (TREE_TYPE (newdecl) == NULL_TREE)
1105 types_match = comptypes (TREE_TYPE (newdecl),
1106 TREE_TYPE (olddecl),
1107 COMPARE_REDECLARATION);
1113 /* If NEWDECL is `static' and an `extern' was seen previously,
1114 warn about it. OLDDECL is the previous declaration.
1116 Note that this does not apply to the C++ case of declaring
1117 a variable `extern const' and then later `const'.
1119 Don't complain about built-in functions, since they are beyond
1120 the user's control. */
1123 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1125 if (TREE_CODE (newdecl) == TYPE_DECL
1126 || TREE_CODE (newdecl) == TEMPLATE_DECL
1127 || TREE_CODE (newdecl) == CONST_DECL
1128 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1131 /* Don't get confused by static member functions; that's a different
1133 if (TREE_CODE (newdecl) == FUNCTION_DECL
1134 && DECL_STATIC_FUNCTION_P (newdecl))
1137 /* If the old declaration was `static', or the new one isn't, then
1138 everything is OK. */
1139 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1142 /* It's OK to declare a builtin function as `static'. */
1143 if (TREE_CODE (olddecl) == FUNCTION_DECL
1144 && DECL_ARTIFICIAL (olddecl))
1147 permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1148 permerror (input_location, "previous declaration of %q+D", olddecl);
1151 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1152 function templates. If their exception specifications do not
1153 match, issue a diagnostic. */
1156 check_redeclaration_exception_specification (tree new_decl,
1161 tree new_exceptions;
1162 tree old_exceptions;
1164 new_type = TREE_TYPE (new_decl);
1165 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1166 old_type = TREE_TYPE (old_decl);
1167 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1171 If any declaration of a function has an exception-specification,
1172 all declarations, including the definition and an explicit
1173 specialization, of that function shall have an
1174 exception-specification with the same set of type-ids. */
1175 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1176 && ! DECL_IS_BUILTIN (old_decl)
1178 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal))
1180 error ("declaration of %qF has a different exception specifier",
1182 error ("from previous declaration %q+F", old_decl);
1186 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1187 Otherwise issue diagnostics. */
1190 validate_constexpr_redeclaration (tree old_decl, tree new_decl)
1192 old_decl = STRIP_TEMPLATE (old_decl);
1193 new_decl = STRIP_TEMPLATE (new_decl);
1194 if (!VAR_OR_FUNCTION_DECL_P (old_decl)
1195 || !VAR_OR_FUNCTION_DECL_P (new_decl))
1197 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
1198 == DECL_DECLARED_CONSTEXPR_P (new_decl))
1200 if (TREE_CODE (old_decl) == FUNCTION_DECL && DECL_BUILT_IN (old_decl))
1202 /* Hide a built-in declaration. */
1203 DECL_DECLARED_CONSTEXPR_P (old_decl)
1204 = DECL_DECLARED_CONSTEXPR_P (new_decl);
1207 error ("redeclaration %qD differs in %<constexpr%>", new_decl);
1208 error ("from previous declaration %q+D", old_decl);
1212 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1213 && lookup_attribute ("gnu_inline", \
1214 DECL_ATTRIBUTES (fn)))
1216 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1217 If the redeclaration is invalid, a diagnostic is issued, and the
1218 error_mark_node is returned. Otherwise, OLDDECL is returned.
1220 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1223 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1226 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1228 unsigned olddecl_uid = DECL_UID (olddecl);
1229 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1230 int new_defines_function = 0;
1231 tree new_template_info;
1233 if (newdecl == olddecl)
1236 types_match = decls_match (newdecl, olddecl);
1238 /* If either the type of the new decl or the type of the old decl is an
1239 error_mark_node, then that implies that we have already issued an
1240 error (earlier) for some bogus type specification, and in that case,
1241 it is rather pointless to harass the user with yet more error message
1242 about the same declaration, so just pretend the types match here. */
1243 if (TREE_TYPE (newdecl) == error_mark_node
1244 || TREE_TYPE (olddecl) == error_mark_node)
1245 return error_mark_node;
1247 if (UDLIT_OPER_P (DECL_NAME (newdecl))
1248 && UDLIT_OPER_P (DECL_NAME (olddecl)))
1250 if (TREE_CODE (newdecl) == TEMPLATE_DECL
1251 && TREE_CODE (olddecl) != TEMPLATE_DECL
1252 && check_raw_literal_operator (olddecl))
1253 error ("literal operator template %q+D conflicts with"
1254 " raw literal operator %qD", newdecl, olddecl);
1255 else if (TREE_CODE (newdecl) != TEMPLATE_DECL
1256 && TREE_CODE (olddecl) == TEMPLATE_DECL
1257 && check_raw_literal_operator (newdecl))
1258 error ("raw literal operator %q+D conflicts with"
1259 " literal operator template %qD", newdecl, olddecl);
1262 if (DECL_P (olddecl)
1263 && TREE_CODE (newdecl) == FUNCTION_DECL
1264 && TREE_CODE (olddecl) == FUNCTION_DECL
1265 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1267 if (DECL_DECLARED_INLINE_P (newdecl)
1268 && DECL_UNINLINABLE (newdecl)
1269 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1270 /* Already warned elsewhere. */;
1271 else if (DECL_DECLARED_INLINE_P (olddecl)
1272 && DECL_UNINLINABLE (olddecl)
1273 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1274 /* Already warned. */;
1275 else if (DECL_DECLARED_INLINE_P (newdecl)
1276 && DECL_UNINLINABLE (olddecl)
1277 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1279 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1281 warning (OPT_Wattributes, "previous declaration of %q+D "
1282 "with attribute noinline", olddecl);
1284 else if (DECL_DECLARED_INLINE_P (olddecl)
1285 && DECL_UNINLINABLE (newdecl)
1286 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1288 warning (OPT_Wattributes, "function %q+D redeclared with "
1289 "attribute noinline", newdecl);
1290 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1295 /* Check for redeclaration and other discrepancies. */
1296 if (TREE_CODE (olddecl) == FUNCTION_DECL
1297 && DECL_ARTIFICIAL (olddecl))
1299 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1300 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1302 /* Avoid warnings redeclaring built-ins which have not been
1303 explicitly declared. */
1304 if (DECL_ANTICIPATED (olddecl))
1307 /* If you declare a built-in or predefined function name as static,
1308 the old definition is overridden, but optionally warn this was a
1309 bad choice of name. */
1310 if (! TREE_PUBLIC (newdecl))
1312 warning (OPT_Wshadow,
1313 DECL_BUILT_IN (olddecl)
1314 ? G_("shadowing built-in function %q#D")
1315 : G_("shadowing library function %q#D"), olddecl);
1316 /* Discard the old built-in function. */
1319 /* If the built-in is not ansi, then programs can override
1320 it even globally without an error. */
1321 else if (! DECL_BUILT_IN (olddecl))
1322 warning (0, "library function %q#D redeclared as non-function %q#D",
1326 error ("declaration of %q#D", newdecl);
1327 error ("conflicts with built-in declaration %q#D",
1332 else if (!types_match)
1334 /* Avoid warnings redeclaring built-ins which have not been
1335 explicitly declared. */
1336 if (DECL_ANTICIPATED (olddecl))
1338 /* Deal with fileptr_type_node. FILE type is not known
1339 at the time we create the builtins. */
1342 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1343 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1345 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1348 else if (TREE_VALUE (t2) == fileptr_type_node)
1350 tree t = TREE_VALUE (t1);
1352 if (TREE_CODE (t) == POINTER_TYPE
1353 && TYPE_NAME (TREE_TYPE (t))
1354 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1355 == get_identifier ("FILE")
1356 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1358 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1360 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1361 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1362 types_match = decls_match (newdecl, olddecl);
1364 return duplicate_decls (newdecl, olddecl,
1366 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1369 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1372 else if ((DECL_EXTERN_C_P (newdecl)
1373 && DECL_EXTERN_C_P (olddecl))
1374 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1375 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1377 /* A near match; override the builtin. */
1379 if (TREE_PUBLIC (newdecl))
1381 warning (0, "new declaration %q#D", newdecl);
1382 warning (0, "ambiguates built-in declaration %q#D",
1386 warning (OPT_Wshadow,
1387 DECL_BUILT_IN (olddecl)
1388 ? G_("shadowing built-in function %q#D")
1389 : G_("shadowing library function %q#D"), olddecl);
1392 /* Discard the old built-in function. */
1395 /* Replace the old RTL to avoid problems with inlining. */
1396 COPY_DECL_RTL (newdecl, olddecl);
1398 /* Even if the types match, prefer the new declarations type for
1399 built-ins which have not been explicitly declared, for
1400 exception lists, etc... */
1401 else if (DECL_IS_BUILTIN (olddecl))
1403 tree type = TREE_TYPE (newdecl);
1404 tree attribs = (*targetm.merge_type_attributes)
1405 (TREE_TYPE (olddecl), type);
1407 type = cp_build_type_attribute_variant (type, attribs);
1408 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1411 /* If a function is explicitly declared "throw ()", propagate that to
1412 the corresponding builtin. */
1413 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1414 && DECL_ANTICIPATED (olddecl)
1415 && TREE_NOTHROW (newdecl)
1416 && !TREE_NOTHROW (olddecl))
1418 enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl);
1419 tree tmpdecl = builtin_decl_explicit (fncode);
1420 if (tmpdecl && tmpdecl != olddecl && types_match)
1421 TREE_NOTHROW (tmpdecl) = 1;
1424 /* Whether or not the builtin can throw exceptions has no
1425 bearing on this declarator. */
1426 TREE_NOTHROW (olddecl) = 0;
1428 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1430 /* If a builtin function is redeclared as `static', merge
1431 the declarations, but make the original one static. */
1432 DECL_THIS_STATIC (olddecl) = 1;
1433 TREE_PUBLIC (olddecl) = 0;
1435 /* Make the old declaration consistent with the new one so
1436 that all remnants of the builtin-ness of this function
1437 will be banished. */
1438 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1439 COPY_DECL_RTL (newdecl, olddecl);
1442 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1444 /* C++ Standard, 3.3, clause 4:
1445 "[Note: a namespace name or a class template name must be unique
1446 in its declarative region (7.3.2, clause 14). ]" */
1447 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1448 && TREE_CODE (newdecl) != NAMESPACE_DECL
1449 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1450 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1451 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1452 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1454 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1455 && TREE_CODE (newdecl) != TYPE_DECL)
1456 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1457 && TREE_CODE (olddecl) != TYPE_DECL))
1459 /* We do nothing special here, because C++ does such nasty
1460 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1461 get shadowed, and know that if we need to find a TYPE_DECL
1462 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1463 slot of the identifier. */
1467 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1468 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1469 || (TREE_CODE (olddecl) == FUNCTION_DECL
1470 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1474 error ("%q#D redeclared as different kind of symbol", newdecl);
1475 if (TREE_CODE (olddecl) == TREE_LIST)
1476 olddecl = TREE_VALUE (olddecl);
1477 error ("previous declaration of %q+#D", olddecl);
1479 return error_mark_node;
1481 else if (!types_match)
1483 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1484 /* These are certainly not duplicate declarations; they're
1485 from different scopes. */
1488 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1490 /* The name of a class template may not be declared to refer to
1491 any other template, class, function, object, namespace, value,
1492 or type in the same scope. */
1493 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1494 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1496 error ("declaration of template %q#D", newdecl);
1497 error ("conflicts with previous declaration %q+#D", olddecl);
1498 return error_mark_node;
1500 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1501 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1502 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1503 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1504 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1505 DECL_TEMPLATE_PARMS (olddecl))
1506 /* Template functions can be disambiguated by
1508 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1509 TREE_TYPE (TREE_TYPE (olddecl))))
1511 error ("new declaration %q#D", newdecl);
1512 error ("ambiguates old declaration %q+#D", olddecl);
1516 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1518 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1520 error ("declaration of C function %q#D conflicts with",
1522 error ("previous declaration %q+#D here", olddecl);
1525 /* For function versions, params and types match, but they
1526 are not ambiguous. */
1527 else if ((!DECL_FUNCTION_VERSIONED (newdecl)
1528 && !DECL_FUNCTION_VERSIONED (olddecl))
1529 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1530 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1532 error ("new declaration %q#D", newdecl);
1533 if (FNDECL_USED_AUTO (olddecl))
1534 error_at (DECL_SOURCE_LOCATION (olddecl), "ambiguates old "
1535 "declaration with deduced return type");
1537 error ("ambiguates old declaration %q+#D", olddecl);
1538 return error_mark_node;
1545 error ("conflicting declaration %q#D", newdecl);
1546 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1547 return error_mark_node;
1550 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1551 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1552 && (!DECL_TEMPLATE_INFO (newdecl)
1553 || (DECL_TI_TEMPLATE (newdecl)
1554 != DECL_TI_TEMPLATE (olddecl))))
1555 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1556 && (!DECL_TEMPLATE_INFO (olddecl)
1557 || (DECL_TI_TEMPLATE (olddecl)
1558 != DECL_TI_TEMPLATE (newdecl))))))
1559 /* It's OK to have a template specialization and a non-template
1560 with the same type, or to have specializations of two
1561 different templates with the same type. Note that if one is a
1562 specialization, and the other is an instantiation of the same
1563 template, that we do not exit at this point. That situation
1564 can occur if we instantiate a template class, and then
1565 specialize one of its methods. This situation is valid, but
1566 the declarations must be merged in the usual way. */
1568 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1569 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1570 && !DECL_USE_TEMPLATE (newdecl))
1571 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1572 && !DECL_USE_TEMPLATE (olddecl))))
1573 /* One of the declarations is a template instantiation, and the
1574 other is not a template at all. That's OK. */
1576 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1578 /* In [namespace.alias] we have:
1580 In a declarative region, a namespace-alias-definition can be
1581 used to redefine a namespace-alias declared in that declarative
1582 region to refer only to the namespace to which it already
1585 Therefore, if we encounter a second alias directive for the same
1586 alias, we can just ignore the second directive. */
1587 if (DECL_NAMESPACE_ALIAS (newdecl)
1588 && (DECL_NAMESPACE_ALIAS (newdecl)
1589 == DECL_NAMESPACE_ALIAS (olddecl)))
1591 /* [namespace.alias]
1593 A namespace-name or namespace-alias shall not be declared as
1594 the name of any other entity in the same declarative region.
1595 A namespace-name defined at global scope shall not be
1596 declared as the name of any other entity in any global scope
1598 error ("declaration of namespace %qD conflicts with", newdecl);
1599 error ("previous declaration of namespace %q+D here", olddecl);
1600 return error_mark_node;
1604 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1607 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1608 if (DECL_NAME (olddecl) != NULL_TREE)
1609 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1610 ? G_("%q+#D previously defined here")
1611 : G_("%q+#D previously declared here"), olddecl);
1612 return error_mark_node;
1614 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1615 && DECL_INITIAL (olddecl) != NULL_TREE
1616 && !prototype_p (TREE_TYPE (olddecl))
1617 && prototype_p (TREE_TYPE (newdecl)))
1619 /* Prototype decl follows defn w/o prototype. */
1620 warning_at (input_location, 0, "prototype for %q+#D", newdecl);
1621 warning_at (DECL_SOURCE_LOCATION (olddecl), 0,
1622 "follows non-prototype definition here");
1624 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1625 || TREE_CODE (olddecl) == VAR_DECL)
1626 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1629 If two declarations of the same function or object
1630 specify different linkage-specifications ..., the program
1631 is ill-formed.... Except for functions with C++ linkage,
1632 a function declaration without a linkage specification
1633 shall not precede the first linkage specification for
1634 that function. A function can be declared without a
1635 linkage specification after an explicit linkage
1636 specification has been seen; the linkage explicitly
1637 specified in the earlier declaration is not affected by
1638 such a function declaration.
1640 DR 563 raises the question why the restrictions on
1641 functions should not also apply to objects. Older
1642 versions of G++ silently ignore the linkage-specification
1650 which is clearly wrong. Therefore, we now treat objects
1652 if (current_lang_depth () == 0)
1654 /* There is no explicit linkage-specification, so we use
1655 the linkage from the previous declaration. */
1656 if (!DECL_LANG_SPECIFIC (newdecl))
1657 retrofit_lang_decl (newdecl);
1658 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1662 error ("previous declaration of %q+#D with %qL linkage",
1663 olddecl, DECL_LANGUAGE (olddecl));
1664 error ("conflicts with new declaration with %qL linkage",
1665 DECL_LANGUAGE (newdecl));
1669 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1671 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1673 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1674 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1677 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1678 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1680 for (; t1 && t1 != void_list_node;
1681 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1682 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1684 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1687 permerror (input_location, "default argument given for parameter %d of %q#D",
1689 permerror (input_location, "after previous specification in %q+#D", olddecl);
1693 error ("default argument given for parameter %d of %q#D",
1695 error ("after previous specification in %q+#D",
1702 /* Do not merge an implicit typedef with an explicit one. In:
1706 typedef class A A __attribute__ ((foo));
1708 the attribute should apply only to the typedef. */
1709 if (TREE_CODE (olddecl) == TYPE_DECL
1710 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1711 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1714 /* If new decl is `static' and an `extern' was seen previously,
1716 warn_extern_redeclared_static (newdecl, olddecl);
1718 if (!validate_constexpr_redeclaration (olddecl, newdecl))
1719 return error_mark_node;
1721 /* We have committed to returning 1 at this point. */
1722 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1724 /* Now that functions must hold information normally held
1725 by field decls, there is extra work to do so that
1726 declaration information does not get destroyed during
1728 if (DECL_VINDEX (olddecl))
1729 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1730 if (DECL_CONTEXT (olddecl))
1731 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1732 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1733 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1734 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1735 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1736 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1737 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1738 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1739 SET_OVERLOADED_OPERATOR_CODE
1740 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1741 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1743 /* Optionally warn about more than one declaration for the same
1744 name, but don't warn about a function declaration followed by a
1746 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1747 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1748 /* Don't warn about extern decl followed by definition. */
1749 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1750 /* Don't warn about friends, let add_friend take care of it. */
1751 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
1752 /* Don't warn about declaration followed by specialization. */
1753 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
1754 || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
1756 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1757 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1760 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl)
1761 && DECL_TEMPLATE_SPECIALIZATION (newdecl)))
1763 if (DECL_DELETED_FN (newdecl))
1765 error ("deleted definition of %qD", newdecl);
1766 error ("after previous declaration %q+D", olddecl);
1768 DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl);
1772 /* Deal with C++: must preserve virtual function table size. */
1773 if (TREE_CODE (olddecl) == TYPE_DECL)
1775 tree newtype = TREE_TYPE (newdecl);
1776 tree oldtype = TREE_TYPE (olddecl);
1778 if (newtype != error_mark_node && oldtype != error_mark_node
1779 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1780 CLASSTYPE_FRIEND_CLASSES (newtype)
1781 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1783 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1786 /* Copy all the DECL_... slots specified in the new decl
1787 except for any that we copy here from the old type. */
1788 DECL_ATTRIBUTES (newdecl)
1789 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1791 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1795 old_result = DECL_TEMPLATE_RESULT (olddecl);
1796 new_result = DECL_TEMPLATE_RESULT (newdecl);
1797 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1798 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1799 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1800 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1802 DECL_ATTRIBUTES (old_result)
1803 = (*targetm.merge_decl_attributes) (old_result, new_result);
1805 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1807 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1808 && DECL_INITIAL (new_result))
1810 if (DECL_INITIAL (old_result))
1811 DECL_UNINLINABLE (old_result) = 1;
1813 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1814 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1815 DECL_NOT_REALLY_EXTERN (old_result)
1816 = DECL_NOT_REALLY_EXTERN (new_result);
1817 DECL_INTERFACE_KNOWN (old_result)
1818 = DECL_INTERFACE_KNOWN (new_result);
1819 DECL_DECLARED_INLINE_P (old_result)
1820 = DECL_DECLARED_INLINE_P (new_result);
1821 DECL_DISREGARD_INLINE_LIMITS (old_result)
1822 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1827 DECL_DECLARED_INLINE_P (old_result)
1828 |= DECL_DECLARED_INLINE_P (new_result);
1829 DECL_DISREGARD_INLINE_LIMITS (old_result)
1830 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1831 check_redeclaration_exception_specification (newdecl, olddecl);
1835 /* If the new declaration is a definition, update the file and
1836 line information on the declaration, and also make
1837 the old declaration the same definition. */
1838 if (DECL_INITIAL (new_result) != NULL_TREE)
1840 DECL_SOURCE_LOCATION (olddecl)
1841 = DECL_SOURCE_LOCATION (old_result)
1842 = DECL_SOURCE_LOCATION (newdecl);
1843 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1844 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1847 DECL_ARGUMENTS (old_result)
1848 = DECL_ARGUMENTS (new_result);
1849 for (parm = DECL_ARGUMENTS (old_result); parm;
1850 parm = DECL_CHAIN (parm))
1851 DECL_CONTEXT (parm) = old_result;
1860 /* Automatically handles default parameters. */
1861 tree oldtype = TREE_TYPE (olddecl);
1864 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1865 maybe_instantiate_noexcept (olddecl);
1867 /* Merge the data types specified in the two decls. */
1868 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1870 /* If merge_types produces a non-typedef type, just use the old type. */
1871 if (TREE_CODE (newdecl) == TYPE_DECL
1872 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1875 if (TREE_CODE (newdecl) == VAR_DECL)
1877 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1878 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1879 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1880 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1881 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1882 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1884 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1885 if (DECL_LANG_SPECIFIC (olddecl)
1886 && CP_DECL_THREADPRIVATE_P (olddecl))
1888 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1889 if (!DECL_LANG_SPECIFIC (newdecl))
1890 retrofit_lang_decl (newdecl);
1892 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1893 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1897 /* Do this after calling `merge_types' so that default
1898 parameters don't confuse us. */
1899 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1900 check_redeclaration_exception_specification (newdecl, olddecl);
1901 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1903 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1904 check_default_args (newdecl);
1906 /* Lay the type out, unless already done. */
1907 if (! same_type_p (newtype, oldtype)
1908 && TREE_TYPE (newdecl) != error_mark_node
1909 && !(processing_template_decl && uses_template_parms (newdecl)))
1910 layout_type (TREE_TYPE (newdecl));
1912 if ((TREE_CODE (newdecl) == VAR_DECL
1913 || TREE_CODE (newdecl) == PARM_DECL
1914 || TREE_CODE (newdecl) == RESULT_DECL
1915 || TREE_CODE (newdecl) == FIELD_DECL
1916 || TREE_CODE (newdecl) == TYPE_DECL)
1917 && !(processing_template_decl && uses_template_parms (newdecl)))
1918 layout_decl (newdecl, 0);
1920 /* Merge the type qualifiers. */
1921 if (TREE_READONLY (newdecl))
1922 TREE_READONLY (olddecl) = 1;
1923 if (TREE_THIS_VOLATILE (newdecl))
1924 TREE_THIS_VOLATILE (olddecl) = 1;
1925 if (TREE_NOTHROW (newdecl))
1926 TREE_NOTHROW (olddecl) = 1;
1928 /* Merge deprecatedness. */
1929 if (TREE_DEPRECATED (newdecl))
1930 TREE_DEPRECATED (olddecl) = 1;
1932 /* Preserve function specific target and optimization options */
1933 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1935 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1936 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1937 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1938 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1940 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1941 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1942 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1943 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1946 /* Merge the initialization information. */
1947 if (DECL_INITIAL (newdecl) == NULL_TREE
1948 && DECL_INITIAL (olddecl) != NULL_TREE)
1950 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1951 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1952 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1954 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1955 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1959 /* Merge the section attribute.
1960 We want to issue an error if the sections conflict but that must be
1961 done later in decl_attributes since we are called before attributes
1963 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1964 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1966 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1968 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1969 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1970 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1971 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1972 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1973 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1974 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1975 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1976 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1977 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1978 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1979 /* Keep the old RTL. */
1980 COPY_DECL_RTL (olddecl, newdecl);
1982 else if (TREE_CODE (newdecl) == VAR_DECL
1983 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1985 /* Keep the old RTL. We cannot keep the old RTL if the old
1986 declaration was for an incomplete object and the new
1987 declaration is not since many attributes of the RTL will
1989 COPY_DECL_RTL (olddecl, newdecl);
1992 /* If cannot merge, then use the new type and qualifiers,
1993 and don't preserve the old rtl. */
1996 /* Clean out any memory we had of the old declaration. */
1997 tree oldstatic = value_member (olddecl, static_aggregates);
1999 TREE_VALUE (oldstatic) = error_mark_node;
2001 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2002 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2003 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2004 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
2007 /* Merge the storage class information. */
2008 merge_weak (newdecl, olddecl);
2010 if (DECL_ONE_ONLY (olddecl))
2011 DECL_COMDAT_GROUP (newdecl) = DECL_COMDAT_GROUP (olddecl);
2013 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
2014 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2015 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
2016 if (! DECL_EXTERNAL (olddecl))
2017 DECL_EXTERNAL (newdecl) = 0;
2019 new_template_info = NULL_TREE;
2020 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
2022 bool new_redefines_gnu_inline = false;
2024 if (new_defines_function
2025 && ((DECL_INTERFACE_KNOWN (olddecl)
2026 && TREE_CODE (olddecl) == FUNCTION_DECL)
2027 || (TREE_CODE (olddecl) == TEMPLATE_DECL
2028 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
2029 == FUNCTION_DECL))))
2033 if (TREE_CODE (fn) == TEMPLATE_DECL)
2034 fn = DECL_TEMPLATE_RESULT (olddecl);
2036 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
2039 if (!new_redefines_gnu_inline)
2041 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
2042 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
2043 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
2045 DECL_TEMPLATE_INSTANTIATED (newdecl)
2046 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
2047 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
2049 /* If the OLDDECL is an instantiation and/or specialization,
2050 then the NEWDECL must be too. But, it may not yet be marked
2051 as such if the caller has created NEWDECL, but has not yet
2052 figured out that it is a redeclaration. */
2053 if (!DECL_USE_TEMPLATE (newdecl))
2054 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
2056 /* Don't really know how much of the language-specific
2057 values we should copy from old to new. */
2058 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2059 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
2060 DECL_INITIALIZED_IN_CLASS_P (newdecl)
2061 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
2063 if (LANG_DECL_HAS_MIN (newdecl))
2065 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
2066 DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
2067 if (DECL_TEMPLATE_INFO (newdecl))
2068 new_template_info = DECL_TEMPLATE_INFO (newdecl);
2069 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2071 /* Only functions have these fields. */
2072 if (TREE_CODE (newdecl) == FUNCTION_DECL
2073 || DECL_FUNCTION_TEMPLATE_P (newdecl))
2075 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
2076 olddecl_friend = DECL_FRIEND_P (olddecl);
2077 hidden_friend = (DECL_ANTICIPATED (olddecl)
2078 && DECL_HIDDEN_FRIEND_P (olddecl)
2079 && newdecl_is_friend);
2080 DECL_BEFRIENDING_CLASSES (newdecl)
2081 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
2082 DECL_BEFRIENDING_CLASSES (olddecl));
2083 /* DECL_THUNKS is only valid for virtual functions,
2084 otherwise it is a DECL_FRIEND_CONTEXT. */
2085 if (DECL_VIRTUAL_P (newdecl))
2086 SET_DECL_THUNKS (newdecl, DECL_THUNKS (olddecl));
2088 /* Only variables have this field. */
2089 else if (TREE_CODE (newdecl) == VAR_DECL
2090 && VAR_HAD_UNKNOWN_BOUND (olddecl))
2091 SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
2094 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2098 /* Merge parameter attributes. */
2099 tree oldarg, newarg;
2100 for (oldarg = DECL_ARGUMENTS(olddecl),
2101 newarg = DECL_ARGUMENTS(newdecl);
2103 oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) {
2104 DECL_ATTRIBUTES (newarg)
2105 = (*targetm.merge_decl_attributes) (oldarg, newarg);
2106 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
2109 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2110 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
2112 /* If newdecl is not a specialization, then it is not a
2113 template-related function at all. And that means that we
2114 should have exited above, returning 0. */
2115 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
2117 if (DECL_ODR_USED (olddecl))
2118 /* From [temp.expl.spec]:
2120 If a template, a member template or the member of a class
2121 template is explicitly specialized then that
2122 specialization shall be declared before the first use of
2123 that specialization that would cause an implicit
2124 instantiation to take place, in every translation unit in
2125 which such a use occurs. */
2126 error ("explicit specialization of %qD after first use",
2129 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
2131 /* Don't propagate visibility from the template to the
2132 specialization here. We'll do that in determine_visibility if
2134 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
2136 /* [temp.expl.spec/14] We don't inline explicit specialization
2137 just because the primary template says so. */
2139 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2140 the always_inline attribute. */
2141 if (DECL_DISREGARD_INLINE_LIMITS (olddecl)
2142 && !DECL_DISREGARD_INLINE_LIMITS (newdecl))
2144 if (DECL_DECLARED_INLINE_P (newdecl))
2145 DECL_DISREGARD_INLINE_LIMITS (newdecl) = true;
2147 DECL_ATTRIBUTES (newdecl)
2148 = remove_attribute ("always_inline",
2149 DECL_ATTRIBUTES (newdecl));
2152 else if (new_defines_function && DECL_INITIAL (olddecl))
2154 /* Never inline re-defined extern inline functions.
2155 FIXME: this could be better handled by keeping both
2156 function as separate declarations. */
2157 DECL_UNINLINABLE (newdecl) = 1;
2161 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
2162 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2164 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
2166 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2167 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2169 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2170 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2171 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2172 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2175 /* Preserve abstractness on cloned [cd]tors. */
2176 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
2178 /* Update newdecl's parms to point at olddecl. */
2179 for (parm = DECL_ARGUMENTS (newdecl); parm;
2180 parm = DECL_CHAIN (parm))
2181 DECL_CONTEXT (parm) = olddecl;
2185 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2186 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2187 COPY_DECL_RTL (newdecl, olddecl);
2189 if (! types_match || new_defines_function)
2191 /* These need to be copied so that the names are available.
2192 Note that if the types do match, we'll preserve inline
2193 info and other bits, but if not, we won't. */
2194 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2195 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2197 /* If redeclaring a builtin function, it stays built in
2198 if newdecl is a gnu_inline definition, or if newdecl is just
2200 if (DECL_BUILT_IN (olddecl)
2201 && (new_defines_function ? GNU_INLINE_P (newdecl) : types_match))
2203 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2204 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2205 /* If we're keeping the built-in definition, keep the rtl,
2206 regardless of declaration matches. */
2207 COPY_DECL_RTL (olddecl, newdecl);
2208 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2210 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2213 /* If a compatible prototype of these builtin functions
2214 is seen, assume the runtime implements it with the
2215 expected semantics. */
2216 case BUILT_IN_STPCPY:
2217 if (builtin_decl_explicit_p (fncode))
2218 set_builtin_decl_implicit_p (fncode, true);
2225 if (new_defines_function)
2226 /* If defining a function declared with other language
2227 linkage, use the previously declared language linkage. */
2228 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2229 else if (types_match)
2231 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2232 /* Don't clear out the arguments if we're just redeclaring a
2234 if (DECL_ARGUMENTS (olddecl))
2235 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2238 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2239 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2241 /* Now preserve various other info from the definition. */
2242 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2243 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2244 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2245 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2247 /* Warn about conflicting visibility specifications. */
2248 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2249 && DECL_VISIBILITY_SPECIFIED (newdecl)
2250 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2252 warning_at (input_location, OPT_Wattributes,
2253 "%q+D: visibility attribute ignored because it", newdecl);
2254 warning_at (DECL_SOURCE_LOCATION (olddecl), OPT_Wattributes,
2255 "conflicts with previous declaration here");
2257 /* Choose the declaration which specified visibility. */
2258 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2260 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2261 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2263 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2264 so keep this behavior. */
2265 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2267 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2268 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2270 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2271 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2273 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2274 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2276 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2277 if (TREE_CODE (newdecl) == FIELD_DECL)
2278 DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
2280 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2281 with that from NEWDECL below. */
2282 if (DECL_LANG_SPECIFIC (olddecl))
2284 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2285 != DECL_LANG_SPECIFIC (newdecl));
2286 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2289 /* Merge the USED information. */
2290 if (TREE_USED (olddecl))
2291 TREE_USED (newdecl) = 1;
2292 else if (TREE_USED (newdecl))
2293 TREE_USED (olddecl) = 1;
2294 if (TREE_CODE (newdecl) == VAR_DECL)
2296 if (DECL_READ_P (olddecl))
2297 DECL_READ_P (newdecl) = 1;
2298 else if (DECL_READ_P (newdecl))
2299 DECL_READ_P (olddecl) = 1;
2301 if (DECL_PRESERVE_P (olddecl))
2302 DECL_PRESERVE_P (newdecl) = 1;
2303 else if (DECL_PRESERVE_P (newdecl))
2304 DECL_PRESERVE_P (olddecl) = 1;
2306 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2307 to olddecl and deleted. */
2308 if (TREE_CODE (newdecl) == FUNCTION_DECL
2309 && DECL_FUNCTION_VERSIONED (olddecl))
2311 /* Set the flag for newdecl so that it gets copied to olddecl. */
2312 DECL_FUNCTION_VERSIONED (newdecl) = 1;
2313 /* newdecl will be purged after copying to olddecl and is no longer
2315 delete_function_version (newdecl);
2318 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2322 function_size = sizeof (struct tree_decl_common);
2324 memcpy ((char *) olddecl + sizeof (struct tree_common),
2325 (char *) newdecl + sizeof (struct tree_common),
2326 function_size - sizeof (struct tree_common));
2328 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2329 (char *) newdecl + sizeof (struct tree_decl_common),
2330 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2331 if (new_template_info)
2332 /* If newdecl is a template instantiation, it is possible that
2333 the following sequence of events has occurred:
2335 o A friend function was declared in a class template. The
2336 class template was instantiated.
2338 o The instantiation of the friend declaration was
2339 recorded on the instantiation list, and is newdecl.
2341 o Later, however, instantiate_class_template called pushdecl
2342 on the newdecl to perform name injection. But, pushdecl in
2343 turn called duplicate_decls when it discovered that another
2344 declaration of a global function with the same name already
2347 o Here, in duplicate_decls, we decided to clobber newdecl.
2349 If we're going to do that, we'd better make sure that
2350 olddecl, and not newdecl, is on the list of
2351 instantiations so that if we try to do the instantiation
2352 again we won't get the clobbered declaration. */
2353 reregister_specialization (newdecl,
2359 size_t size = tree_code_size (TREE_CODE (olddecl));
2360 memcpy ((char *) olddecl + sizeof (struct tree_common),
2361 (char *) newdecl + sizeof (struct tree_common),
2362 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2363 switch (TREE_CODE (olddecl))
2373 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2374 (char *) newdecl + sizeof (struct tree_decl_common),
2375 size - sizeof (struct tree_decl_common)
2376 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2380 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2381 (char *) newdecl + sizeof (struct tree_decl_common),
2382 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2383 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2387 DECL_UID (olddecl) = olddecl_uid;
2389 DECL_FRIEND_P (olddecl) = 1;
2392 DECL_ANTICIPATED (olddecl) = 1;
2393 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2396 /* NEWDECL contains the merged attribute lists.
2397 Update OLDDECL to be the same. */
2398 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2400 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2401 so that encode_section_info has a chance to look at the new decl
2402 flags and attributes. */
2403 if (DECL_RTL_SET_P (olddecl)
2404 && (TREE_CODE (olddecl) == FUNCTION_DECL
2405 || (TREE_CODE (olddecl) == VAR_DECL
2406 && TREE_STATIC (olddecl))))
2407 make_decl_rtl (olddecl);
2409 /* The NEWDECL will no longer be needed. Because every out-of-class
2410 declaration of a member results in a call to duplicate_decls,
2411 freeing these nodes represents in a significant savings. */
2417 /* Return zero if the declaration NEWDECL is valid
2418 when the declaration OLDDECL (assumed to be for the same name)
2419 has already been seen.
2420 Otherwise return an error message format string with a %s
2421 where the identifier should go. */
2424 redeclaration_error_message (tree newdecl, tree olddecl)
2426 if (TREE_CODE (newdecl) == TYPE_DECL)
2428 /* Because C++ can put things into name space for free,
2429 constructs like "typedef struct foo { ... } foo"
2430 would look like an erroneous redeclaration. */
2431 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2434 return G_("redefinition of %q#D");
2436 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2438 /* If this is a pure function, its olddecl will actually be
2439 the original initialization to `0' (which we force to call
2440 abort()). Don't complain about redefinition in this case. */
2441 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2442 && DECL_INITIAL (olddecl) == NULL_TREE)
2445 /* If both functions come from different namespaces, this is not
2446 a redeclaration - this is a conflict with a used function. */
2447 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2448 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2449 && ! decls_match (olddecl, newdecl))
2450 return G_("%qD conflicts with used function");
2452 /* We'll complain about linkage mismatches in
2453 warn_extern_redeclared_static. */
2455 /* Defining the same name twice is no good. */
2456 if (DECL_INITIAL (olddecl) != NULL_TREE
2457 && DECL_INITIAL (newdecl) != NULL_TREE)
2459 if (DECL_NAME (olddecl) == NULL_TREE)
2460 return G_("%q#D not declared in class");
2461 else if (!GNU_INLINE_P (olddecl)
2462 || GNU_INLINE_P (newdecl))
2463 return G_("redefinition of %q#D");
2466 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2468 bool olda = GNU_INLINE_P (olddecl);
2469 bool newa = GNU_INLINE_P (newdecl);
2474 return G_("%q+D redeclared inline with "
2475 "%<gnu_inline%> attribute");
2477 return G_("%q+D redeclared inline without "
2478 "%<gnu_inline%> attribute");
2482 check_abi_tag_redeclaration
2483 (olddecl, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl)),
2484 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl)));
2488 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2492 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2494 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2495 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2496 return G_("redefinition of %q#D");
2500 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2501 || (DECL_TEMPLATE_RESULT (newdecl)
2502 == DECL_TEMPLATE_RESULT (olddecl)))
2505 nt = DECL_TEMPLATE_RESULT (newdecl);
2506 if (DECL_TEMPLATE_INFO (nt))
2507 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2508 ot = DECL_TEMPLATE_RESULT (olddecl);
2509 if (DECL_TEMPLATE_INFO (ot))
2510 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2511 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2512 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2513 return G_("redefinition of %q#D");
2515 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2517 bool olda = GNU_INLINE_P (ot);
2518 bool newa = GNU_INLINE_P (nt);
2523 return G_("%q+D redeclared inline with "
2524 "%<gnu_inline%> attribute");
2526 return G_("%q+D redeclared inline without "
2527 "%<gnu_inline%> attribute");
2531 /* Core issue #226 (C++0x):
2533 If a friend function template declaration specifies a
2534 default template-argument, that declaration shall be a
2535 definition and shall be the only declaration of the
2536 function template in the translation unit. */
2537 if ((cxx_dialect != cxx98)
2538 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2539 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2540 /*is_primary=*/true,
2541 /*is_partial=*/false,
2542 /*is_friend_decl=*/2))
2543 return G_("redeclaration of friend %q#D "
2544 "may not have default template arguments");
2548 else if (TREE_CODE (newdecl) == VAR_DECL
2549 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2550 && (! DECL_LANG_SPECIFIC (olddecl)
2551 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2552 || DECL_THREAD_LOCAL_P (newdecl)))
2554 /* Only variables can be thread-local, and all declarations must
2555 agree on this property. */
2556 if (DECL_THREAD_LOCAL_P (newdecl))
2557 return G_("thread-local declaration of %q#D follows "
2558 "non-thread-local declaration");
2560 return G_("non-thread-local declaration of %q#D follows "
2561 "thread-local declaration");
2563 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2565 /* The objects have been declared at namespace scope. If either
2566 is a member of an anonymous union, then this is an invalid
2567 redeclaration. For example:
2573 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2574 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2575 return G_("redeclaration of %q#D");
2576 /* If at least one declaration is a reference, there is no
2577 conflict. For example:
2583 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2585 /* Reject two definitions. */
2586 return G_("redefinition of %q#D");
2590 /* Objects declared with block scope: */
2591 /* Reject two definitions, and reject a definition
2592 together with an external reference. */
2593 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2594 return G_("redeclaration of %q#D");
2599 /* Hash and equality functions for the named_label table. */
2602 named_label_entry_hash (const void *data)
2604 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2605 return DECL_UID (ent->label_decl);
2609 named_label_entry_eq (const void *a, const void *b)
2611 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2612 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2613 return ent_a->label_decl == ent_b->label_decl;
2616 /* Create a new label, named ID. */
2619 make_label_decl (tree id, int local_p)
2621 struct named_label_entry *ent;
2625 decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2627 DECL_CONTEXT (decl) = current_function_decl;
2628 DECL_MODE (decl) = VOIDmode;
2629 C_DECLARED_LABEL_FLAG (decl) = local_p;
2631 /* Say where one reference is to the label, for the sake of the
2632 error if it is not defined. */
2633 DECL_SOURCE_LOCATION (decl) = input_location;
2635 /* Record the fact that this identifier is bound to this label. */
2636 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2638 /* Create the label htab for the function on demand. */
2640 named_labels = htab_create_ggc (13, named_label_entry_hash,
2641 named_label_entry_eq, NULL);
2643 /* Record this label on the list of labels used in this function.
2644 We do this before calling make_label_decl so that we get the
2645 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2646 ent = ggc_alloc_cleared_named_label_entry ();
2647 ent->label_decl = decl;
2649 slot = htab_find_slot (named_labels, ent, INSERT);
2650 gcc_assert (*slot == NULL);
2656 /* Look for a label named ID in the current function. If one cannot
2657 be found, create one. (We keep track of used, but undefined,
2658 labels, and complain about them at the end of a function.) */
2661 lookup_label_1 (tree id)
2665 /* You can't use labels at global scope. */
2666 if (current_function_decl == NULL_TREE)
2668 error ("label %qE referenced outside of any function", id);
2672 /* See if we've already got this label. */
2673 decl = IDENTIFIER_LABEL_VALUE (id);
2674 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2677 decl = make_label_decl (id, /*local_p=*/0);
2681 /* Wrapper for lookup_label_1. */
2684 lookup_label (tree id)
2687 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2688 ret = lookup_label_1 (id);
2689 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2693 /* Declare a local label named ID. */
2696 declare_local_label (tree id)
2699 cp_label_binding bind;
2701 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2702 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2703 bind.prev_value = IDENTIFIER_LABEL_VALUE (id);
2705 decl = make_label_decl (id, /*local_p=*/1);
2707 vec_safe_push (current_binding_level->shadowed_labels, bind);
2712 /* Returns nonzero if it is ill-formed to jump past the declaration of
2713 DECL. Returns 2 if it's also a real problem. */
2716 decl_jump_unsafe (tree decl)
2718 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2719 with automatic storage duration is not in scope to a point where it is
2720 in scope is ill-formed unless the variable has scalar type, class type
2721 with a trivial default constructor and a trivial destructor, a
2722 cv-qualified version of one of these types, or an array of one of the
2723 preceding types and is declared without an initializer (8.5). */
2724 tree type = TREE_TYPE (decl);
2726 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2727 || type == error_mark_node)
2730 type = strip_array_types (type);
2732 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2735 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
2741 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2744 identify_goto (tree decl, const location_t *locus)
2747 permerror (input_location, "jump to label %qD", decl);
2749 permerror (input_location, "jump to case label");
2751 permerror (*locus, " from here");
2754 /* Check that a single previously seen jump to a newly defined label
2755 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2756 the jump context; NAMES are the names in scope in LEVEL at the jump
2757 context; LOCUS is the source position of the jump or 0. Returns
2758 true if all is well. */
2761 check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
2762 bool exited_omp, const location_t *locus)
2764 cp_binding_level *b;
2765 bool identified = false, saw_eh = false, saw_omp = false;
2769 identify_goto (decl, locus);
2770 error (" exits OpenMP structured block");
2771 identified = saw_omp = true;
2774 for (b = current_binding_level; b ; b = b->level_chain)
2776 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2778 for (new_decls = b->names; new_decls != old_decls;
2779 new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls)
2780 : TREE_CHAIN (new_decls)))
2782 int problem = decl_jump_unsafe (new_decls);
2788 identify_goto (decl, locus);
2792 error (" crosses initialization of %q+#D", new_decls);
2794 permerror (input_location, " enters scope of %q+#D which has "
2795 "non-trivial destructor", new_decls);
2800 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2804 identify_goto (decl, locus);
2807 if (b->kind == sk_try)
2808 error (" enters try block");
2810 error (" enters catch block");
2813 if (b->kind == sk_omp && !saw_omp)
2817 identify_goto (decl, locus);
2820 error (" enters OpenMP structured block");
2829 check_previous_goto (tree decl, struct named_label_use_entry *use)
2831 check_previous_goto_1 (decl, use->binding_level,
2832 use->names_in_scope, use->in_omp_scope,
2833 &use->o_goto_locus);
2837 check_switch_goto (cp_binding_level* level)
2839 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2842 /* Check that a new jump to a label DECL is OK. Called by
2843 finish_goto_stmt. */
2846 check_goto (tree decl)
2848 struct named_label_entry *ent, dummy;
2849 bool saw_catch = false, identified = false;
2853 /* We can't know where a computed goto is jumping.
2854 So we assume that it's OK. */
2855 if (TREE_CODE (decl) != LABEL_DECL)
2858 /* We didn't record any information about this label when we created it,
2859 and there's not much point since it's trivial to analyze as a return. */
2860 if (decl == cdtor_label)
2863 dummy.label_decl = decl;
2864 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2865 gcc_assert (ent != NULL);
2867 /* If the label hasn't been defined yet, defer checking. */
2868 if (! DECL_INITIAL (decl))
2870 struct named_label_use_entry *new_use;
2872 /* Don't bother creating another use if the last goto had the
2873 same data, and will therefore create the same set of errors. */
2875 && ent->uses->names_in_scope == current_binding_level->names)
2878 new_use = ggc_alloc_named_label_use_entry ();
2879 new_use->binding_level = current_binding_level;
2880 new_use->names_in_scope = current_binding_level->names;
2881 new_use->o_goto_locus = input_location;
2882 new_use->in_omp_scope = false;
2884 new_use->next = ent->uses;
2885 ent->uses = new_use;
2889 if (ent->in_try_scope || ent->in_catch_scope
2890 || ent->in_omp_scope || !vec_safe_is_empty (ent->bad_decls))
2892 permerror (input_location, "jump to label %q+D", decl);
2893 permerror (input_location, " from here");
2897 FOR_EACH_VEC_SAFE_ELT (ent->bad_decls, ix, bad)
2899 int u = decl_jump_unsafe (bad);
2901 if (u > 1 && DECL_ARTIFICIAL (bad))
2903 /* Can't skip init of __exception_info. */
2904 error_at (DECL_SOURCE_LOCATION (bad), " enters catch block");
2908 error (" skips initialization of %q+#D", bad);
2910 permerror (input_location, " enters scope of %q+#D which has "
2911 "non-trivial destructor", bad);
2914 if (ent->in_try_scope)
2915 error (" enters try block");
2916 else if (ent->in_catch_scope && !saw_catch)
2917 error (" enters catch block");
2919 if (ent->in_omp_scope)
2920 error (" enters OpenMP structured block");
2921 else if (flag_openmp)
2923 cp_binding_level *b;
2924 for (b = current_binding_level; b ; b = b->level_chain)
2926 if (b == ent->binding_level)
2928 if (b->kind == sk_omp)
2932 permerror (input_location, "jump to label %q+D", decl);
2933 permerror (input_location, " from here");
2936 error (" exits OpenMP structured block");
2943 /* Check that a return is ok wrt OpenMP structured blocks.
2944 Called by finish_return_stmt. Returns true if all is well. */
2947 check_omp_return (void)
2949 cp_binding_level *b;
2950 for (b = current_binding_level; b ; b = b->level_chain)
2951 if (b->kind == sk_omp)
2953 error ("invalid exit from OpenMP structured block");
2956 else if (b->kind == sk_function_parms)
2961 /* Define a label, specifying the location in the source file.
2962 Return the LABEL_DECL node for the label. */
2965 define_label_1 (location_t location, tree name)
2967 struct named_label_entry *ent, dummy;
2968 cp_binding_level *p;
2971 decl = lookup_label (name);
2973 dummy.label_decl = decl;
2974 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2975 gcc_assert (ent != NULL);
2977 /* After labels, make any new cleanups in the function go into their
2978 own new (temporary) binding contour. */
2979 for (p = current_binding_level;
2980 p->kind != sk_function_parms;
2982 p->more_cleanups_ok = 0;
2984 if (name == get_identifier ("wchar_t"))
2985 permerror (input_location, "label named wchar_t");
2987 if (DECL_INITIAL (decl) != NULL_TREE)
2989 error ("duplicate label %qD", decl);
2990 return error_mark_node;
2994 struct named_label_use_entry *use;
2996 /* Mark label as having been defined. */
2997 DECL_INITIAL (decl) = error_mark_node;
2998 /* Say where in the source. */
2999 DECL_SOURCE_LOCATION (decl) = location;
3001 ent->binding_level = current_binding_level;
3002 ent->names_in_scope = current_binding_level->names;
3004 for (use = ent->uses; use ; use = use->next)
3005 check_previous_goto (decl, use);
3012 /* Wrapper for define_label_1. */
3015 define_label (location_t location, tree name)
3018 bool running = timevar_cond_start (TV_NAME_LOOKUP);
3019 ret = define_label_1 (location, name);
3020 timevar_cond_stop (TV_NAME_LOOKUP, running);
3027 cp_binding_level *level;
3028 struct cp_switch *next;
3029 /* The SWITCH_STMT being built. */
3031 /* A splay-tree mapping the low element of a case range to the high
3032 element, or NULL_TREE if there is no high element. Used to
3033 determine whether or not a new case label duplicates an old case
3034 label. We need a tree, rather than simply a hash table, because
3035 of the GNU case range extension. */
3039 /* A stack of the currently active switch statements. The innermost
3040 switch statement is on the top of the stack. There is no need to
3041 mark the stack for garbage collection because it is only active
3042 during the processing of the body of a function, and we never
3043 collect at that point. */
3045 static struct cp_switch *switch_stack;
3047 /* Called right after a switch-statement condition is parsed.
3048 SWITCH_STMT is the switch statement being parsed. */
3051 push_switch (tree switch_stmt)
3053 struct cp_switch *p = XNEW (struct cp_switch);
3054 p->level = current_binding_level;
3055 p->next = switch_stack;
3056 p->switch_stmt = switch_stmt;
3057 p->cases = splay_tree_new (case_compare, NULL, NULL);
3064 struct cp_switch *cs = switch_stack;
3065 location_t switch_location;
3067 /* Emit warnings as needed. */
3068 switch_location = EXPR_LOC_OR_HERE (cs->switch_stmt);
3069 if (!processing_template_decl)
3070 c_do_switch_warnings (cs->cases, switch_location,
3071 SWITCH_STMT_TYPE (cs->switch_stmt),
3072 SWITCH_STMT_COND (cs->switch_stmt));
3074 splay_tree_delete (cs->cases);
3075 switch_stack = switch_stack->next;
3079 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3080 condition. Note that if TYPE and VALUE are already integral we don't
3081 really do the conversion because the language-independent
3082 warning/optimization code will work better that way. */
3085 case_conversion (tree type, tree value)
3087 if (value == NULL_TREE)
3090 if (cxx_dialect >= cxx0x
3091 && (SCOPED_ENUM_P (type)
3092 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
3094 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
3095 type = type_promotes_to (type);
3096 value = perform_implicit_conversion (type, value, tf_warning_or_error);
3098 return cxx_constant_value (value);
3101 /* Note that we've seen a definition of a case label, and complain if this
3102 is a bad place for one. */
3105 finish_case_label (location_t loc, tree low_value, tree high_value)
3108 cp_binding_level *p;
3111 if (processing_template_decl)
3115 /* For templates, just add the case label; we'll do semantic
3116 analysis at instantiation-time. */
3117 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
3118 return add_stmt (build_case_label (low_value, high_value, label));
3121 /* Find the condition on which this switch statement depends. */
3122 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
3123 if (cond && TREE_CODE (cond) == TREE_LIST)
3124 cond = TREE_VALUE (cond);
3126 if (!check_switch_goto (switch_stack->level))
3127 return error_mark_node;
3129 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt);
3131 low_value = case_conversion (type, low_value);
3132 high_value = case_conversion (type, high_value);
3134 r = c_add_case_label (loc, switch_stack->cases, cond, type,
3135 low_value, high_value);
3137 /* After labels, make any new cleanups in the function go into their
3138 own new (temporary) binding contour. */
3139 for (p = current_binding_level;
3140 p->kind != sk_function_parms;
3142 p->more_cleanups_ok = 0;
3147 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3150 typename_hash (const void* k)
3153 const_tree const t = (const_tree) k;
3155 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
3156 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
3161 typedef struct typename_info {
3169 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3170 really of type `typename_info*' */
3173 typename_compare (const void * k1, const void * k2)
3175 const_tree const t1 = (const_tree) k1;
3176 const typename_info *const t2 = (const typename_info *) k2;
3178 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
3179 && TYPE_CONTEXT (t1) == t2->scope
3180 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
3181 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
3182 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
3185 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3186 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3188 Returns the new TYPENAME_TYPE. */
3190 static GTY ((param_is (union tree_node))) htab_t typename_htab;
3193 build_typename_type (tree context, tree name, tree fullname,
3194 enum tag_types tag_type)
3202 if (typename_htab == NULL)
3203 typename_htab = htab_create_ggc (61, &typename_hash,
3204 &typename_compare, NULL);
3206 ti.scope = FROB_CONTEXT (context);
3208 ti.template_id = fullname;
3209 ti.enum_p = tag_type == enum_type;
3210 ti.class_p = (tag_type == class_type
3211 || tag_type == record_type
3212 || tag_type == union_type);
3213 hash = (htab_hash_pointer (ti.scope)
3214 ^ htab_hash_pointer (ti.name));
3216 /* See if we already have this type. */
3217 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
3222 /* Build the TYPENAME_TYPE. */
3223 t = cxx_make_type (TYPENAME_TYPE);
3224 TYPE_CONTEXT (t) = ti.scope;
3225 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
3226 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
3227 TYPENAME_IS_CLASS_P (t) = ti.class_p;
3229 /* Build the corresponding TYPE_DECL. */
3230 d = build_decl (input_location, TYPE_DECL, name, t);
3231 TYPE_NAME (TREE_TYPE (d)) = d;
3232 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3233 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3234 DECL_ARTIFICIAL (d) = 1;
3236 /* Store it in the hash table. */
3239 /* TYPENAME_TYPEs must always be compared structurally, because
3240 they may or may not resolve down to another type depending on
3241 the currently open classes. */
3242 SET_TYPE_STRUCTURAL_EQUALITY (t);
3248 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3249 provided to name the type. Returns an appropriate type, unless an
3250 error occurs, in which case error_mark_node is returned. If we
3251 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3252 return that, rather than the _TYPE it corresponds to, in other
3253 cases we look through the type decl. If TF_ERROR is set, complain
3254 about errors, otherwise be quiet. */
3257 make_typename_type (tree context, tree name, enum tag_types tag_type,
3258 tsubst_flags_t complain)
3264 if (name == error_mark_node
3265 || context == NULL_TREE
3266 || context == error_mark_node)
3267 return error_mark_node;
3271 if (!(TYPE_LANG_SPECIFIC (name)
3272 && (CLASSTYPE_IS_TEMPLATE (name)
3273 || CLASSTYPE_USE_TEMPLATE (name))))
3274 name = TYPE_IDENTIFIER (name);
3276 /* Create a TEMPLATE_ID_EXPR for the type. */
3277 name = build_nt (TEMPLATE_ID_EXPR,
3278 CLASSTYPE_TI_TEMPLATE (name),
3279 CLASSTYPE_TI_ARGS (name));
3281 else if (TREE_CODE (name) == TYPE_DECL)
3282 name = DECL_NAME (name);
3286 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3288 name = TREE_OPERAND (name, 0);
3289 if (TREE_CODE (name) == TEMPLATE_DECL)
3290 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3291 else if (TREE_CODE (name) == OVERLOAD)
3293 if (complain & tf_error)
3294 error ("%qD is not a type", name);
3295 return error_mark_node;
3298 if (TREE_CODE (name) == TEMPLATE_DECL)
3300 if (complain & tf_error)
3301 error ("%qD used without template parameters", name);
3302 return error_mark_node;
3304 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3305 gcc_assert (TYPE_P (context));
3307 if (!MAYBE_CLASS_TYPE_P (context))
3309 if (complain & tf_error)
3310 error ("%q#T is not a class", context);
3311 return error_mark_node;
3314 /* When the CONTEXT is a dependent type, NAME could refer to a
3315 dependent base class of CONTEXT. But look inside it anyway
3316 if CONTEXT is a currently open scope, in case it refers to a
3317 member of the current instantiation or a non-dependent base;
3318 lookup will stop when we hit a dependent base. */
3319 if (!dependent_scope_p (context))
3320 /* We should only set WANT_TYPE when we're a nested typename type.
3321 Then we can give better diagnostics if we find a non-type. */
3322 t = lookup_field (context, name, 2, /*want_type=*/true);
3326 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3327 return build_typename_type (context, name, fullname, tag_type);
3329 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3333 if (complain & tf_error)
3334 error (want_template ? G_("no class template named %q#T in %q#T")
3335 : G_("no type named %q#T in %q#T"), name, context);
3336 return error_mark_node;
3339 /* Pull out the template from an injected-class-name (or multiple). */
3341 t = maybe_get_template_decl_from_type_decl (t);
3343 if (TREE_CODE (t) == TREE_LIST)
3345 if (complain & tf_error)
3347 error ("lookup of %qT in %qT is ambiguous", name, context);
3348 print_candidates (t);
3350 return error_mark_node;
3353 if (want_template && !DECL_TYPE_TEMPLATE_P (t))
3355 if (complain & tf_error)
3356 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3358 return error_mark_node;
3360 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3362 if (complain & tf_error)
3363 error ("%<typename %T::%D%> names %q#T, which is not a type",
3365 return error_mark_node;
3368 if (!perform_or_defer_access_check (TYPE_BINFO (context), t, t, complain))
3369 return error_mark_node;
3371 /* If we are currently parsing a template and if T is a typedef accessed
3372 through CONTEXT then we need to remember and check access of T at
3373 template instantiation time. */
3374 add_typedef_to_current_template_for_access_check (t, context, input_location);
3377 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3379 /*entering_scope=*/0,
3380 tf_warning_or_error | tf_user);
3382 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3385 maybe_record_typedef_use (t);
3390 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3391 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3392 in which case error_mark_node is returned.
3394 If PARM_LIST is non-NULL, also make sure that the template parameter
3395 list of TEMPLATE_DECL matches.
3397 If COMPLAIN zero, don't complain about any errors that occur. */
3400 make_unbound_class_template (tree context, tree name, tree parm_list,
3401 tsubst_flags_t complain)
3407 name = TYPE_IDENTIFIER (name);
3408 else if (DECL_P (name))
3409 name = DECL_NAME (name);
3410 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3412 if (!dependent_type_p (context)
3413 || currently_open_class (context))
3415 tree tmpl = NULL_TREE;
3417 if (MAYBE_CLASS_TYPE_P (context))
3418 tmpl = lookup_field (context, name, 0, false);
3420 if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
3421 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
3423 if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl))
3425 if (complain & tf_error)
3426 error ("no class template named %q#T in %q#T", name, context);
3427 return error_mark_node;
3431 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3433 if (complain & tf_error)
3435 error ("template parameters do not match template");
3436 error ("%q+D declared here", tmpl);
3438 return error_mark_node;
3441 if (!perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl,
3443 return error_mark_node;
3448 /* Build the UNBOUND_CLASS_TEMPLATE. */
3449 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3450 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3451 TREE_TYPE (t) = NULL_TREE;
3452 SET_TYPE_STRUCTURAL_EQUALITY (t);
3454 /* Build the corresponding TEMPLATE_DECL. */
3455 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3456 TYPE_NAME (TREE_TYPE (d)) = d;
3457 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3458 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3459 DECL_ARTIFICIAL (d) = 1;
3460 DECL_TEMPLATE_PARMS (d) = parm_list;
3467 /* Push the declarations of builtin types into the namespace.
3468 RID_INDEX is the index of the builtin type in the array
3469 RID_POINTERS. NAME is the name used when looking up the builtin
3470 type. TYPE is the _TYPE node for the builtin type. */
3473 record_builtin_type (enum rid rid_index,
3477 tree rname = NULL_TREE, tname = NULL_TREE;
3478 tree tdecl = NULL_TREE;
3480 if ((int) rid_index < (int) RID_MAX)
3481 rname = ridpointers[(int) rid_index];
3483 tname = get_identifier (name);
3485 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3486 eliminated. Built-in types should not be looked up name; their
3487 names are keywords that the parser can recognize. However, there
3488 is code in c-common.c that uses identifier_global_value to look
3489 up built-in types by name. */
3492 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3493 DECL_ARTIFICIAL (tdecl) = 1;
3494 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3500 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3501 DECL_ARTIFICIAL (tdecl) = 1;
3503 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3506 if (!TYPE_NAME (type))
3507 TYPE_NAME (type) = tdecl;
3510 debug_hooks->type_decl (tdecl, 0);
3513 /* Record one of the standard Java types.
3514 * Declare it as having the given NAME.
3515 * If SIZE > 0, it is the size of one of the integral types;
3516 * otherwise it is the negative of the size of one of the other types. */
3519 record_builtin_java_type (const char* name, int size)
3524 type = build_nonstandard_integer_type (size, 0);
3525 type = build_distinct_type_copy (type);
3527 else if (size > -32)
3530 /* "__java_char" or ""__java_boolean". */
3531 type = build_nonstandard_integer_type (-size, 1);
3532 type = build_distinct_type_copy (type);
3533 /* Get the signed type cached and attached to the unsigned type,
3534 so it doesn't get garbage-collected at "random" times,
3535 causing potential codegen differences out of different UIDs
3536 and different alias set numbers. */
3537 stype = build_nonstandard_integer_type (-size, 0);
3538 stype = build_distinct_type_copy (stype);
3539 TREE_CHAIN (type) = stype;
3540 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3543 { /* "__java_float" or ""__java_double". */
3544 type = make_node (REAL_TYPE);
3545 TYPE_PRECISION (type) = - size;
3548 record_builtin_type (RID_MAX, name, type);
3549 decl = TYPE_NAME (type);
3551 /* Suppress generate debug symbol entries for these types,
3552 since for normal C++ they are just clutter.
3553 However, push_lang_context undoes this if extern "Java" is seen. */
3554 DECL_IGNORED_P (decl) = 1;
3556 TYPE_FOR_JAVA (type) = 1;
3560 /* Push a type into the namespace so that the back ends ignore it. */
3563 record_unknown_type (tree type, const char* name)
3565 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3566 TYPE_DECL, get_identifier (name), type));
3567 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3568 DECL_IGNORED_P (decl) = 1;
3569 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3570 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3571 TYPE_ALIGN (type) = 1;
3572 TYPE_USER_ALIGN (type) = 0;
3573 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3576 /* A string for which we should create an IDENTIFIER_NODE at
3579 typedef struct predefined_identifier
3581 /* The name of the identifier. */
3582 const char *const name;
3583 /* The place where the IDENTIFIER_NODE should be stored. */
3585 /* Nonzero if this is the name of a constructor or destructor. */
3586 const int ctor_or_dtor_p;
3587 } predefined_identifier;
3589 /* Create all the predefined identifiers. */
3592 initialize_predefined_identifiers (void)
3594 const predefined_identifier *pid;
3596 /* A table of identifiers to create at startup. */
3597 static const predefined_identifier predefined_identifiers[] = {
3598 { "C++", &lang_name_cplusplus, 0 },
3599 { "C", &lang_name_c, 0 },
3600 { "Java", &lang_name_java, 0 },
3601 /* Some of these names have a trailing space so that it is
3602 impossible for them to conflict with names written by users. */
3603 { "__ct ", &ctor_identifier, 1 },
3604 { "__base_ctor ", &base_ctor_identifier, 1 },
3605 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3606 { "__dt ", &dtor_identifier, 1 },
3607 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3608 { "__base_dtor ", &base_dtor_identifier, 1 },
3609 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3610 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3611 { "nelts", &nelts_identifier, 0 },
3612 { THIS_NAME, &this_identifier, 0 },
3613 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3614 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3615 { "_vptr", &vptr_identifier, 0 },
3616 { "__vtt_parm", &vtt_parm_identifier, 0 },
3617 { "::", &global_scope_name, 0 },
3618 { "std", &std_identifier, 0 },
3622 for (pid = predefined_identifiers; pid->name; ++pid)
3624 *pid->node = get_identifier (pid->name);
3625 if (pid->ctor_or_dtor_p)
3626 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3630 /* Create the predefined scalar types of C,
3631 and some nodes representing standard constants (0, 1, (void *)0).
3632 Initialize the global binding level.
3633 Make definitions for built-in primitive functions. */
3636 cxx_init_decl_processing (void)
3639 tree void_ftype_ptr;
3641 /* Create all the identifiers we need. */
3642 initialize_predefined_identifiers ();
3644 /* Create the global variables. */
3645 push_to_top_level ();
3647 current_function_decl = NULL_TREE;
3648 current_binding_level = NULL;
3649 /* Enter the global namespace. */
3650 gcc_assert (global_namespace == NULL_TREE);
3651 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3653 DECL_CONTEXT (global_namespace) = build_translation_unit_decl (NULL_TREE);
3654 TREE_PUBLIC (global_namespace) = 1;
3655 begin_scope (sk_namespace, global_namespace);
3657 if (flag_visibility_ms_compat)
3658 default_visibility = VISIBILITY_HIDDEN;
3661 current_lang_name = lang_name_c;
3663 /* Create the `std' namespace. */
3664 push_namespace (std_identifier);
3665 std_node = current_namespace;
3668 c_common_nodes_and_builtins ();
3670 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3671 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3672 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3673 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3674 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3675 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3676 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3677 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3679 integer_two_node = build_int_cst (NULL_TREE, 2);
3681 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3682 truthvalue_type_node = boolean_type_node;
3683 truthvalue_false_node = boolean_false_node;
3684 truthvalue_true_node = boolean_true_node;
3686 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3687 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE);
3688 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE);
3691 record_builtin_type (RID_MAX, NULL, string_type_node);
3694 delta_type_node = ptrdiff_type_node;
3695 vtable_index_type = ptrdiff_type_node;
3697 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3698 void_ftype = build_function_type_list (void_type_node, NULL_TREE);
3699 void_ftype_ptr = build_function_type_list (void_type_node,
3700 ptr_type_node, NULL_TREE);
3702 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3704 /* C++ extensions */
3706 unknown_type_node = make_node (LANG_TYPE);
3707 record_unknown_type (unknown_type_node, "unknown type");
3709 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3710 TREE_TYPE (unknown_type_node) = unknown_type_node;
3712 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3714 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3715 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3717 init_list_type_node = make_node (LANG_TYPE);
3718 record_unknown_type (init_list_type_node, "init list");
3721 /* Make sure we get a unique function type, so we can give
3722 its pointer type a name. (This wins for gdb.) */
3723 tree vfunc_type = make_node (FUNCTION_TYPE);
3724 TREE_TYPE (vfunc_type) = integer_type_node;
3725 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3726 layout_type (vfunc_type);
3728 vtable_entry_type = build_pointer_type (vfunc_type);
3730 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3733 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3734 layout_type (vtbl_type_node);
3735 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3736 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3737 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3738 layout_type (vtbl_ptr_type_node);
3739 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3741 push_namespace (get_identifier ("__cxxabiv1"));
3742 abi_node = current_namespace;
3745 global_type_node = make_node (LANG_TYPE);
3746 record_unknown_type (global_type_node, "global type");
3749 current_lang_name = lang_name_cplusplus;
3752 tree newattrs, extvisattr;
3753 tree newtype, deltype;
3754 tree ptr_ftype_sizetype;
3758 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE);
3759 if (cxx_dialect == cxx98)
3762 tree bad_alloc_type_node;
3763 tree bad_alloc_decl;
3765 push_namespace (std_identifier);
3766 bad_alloc_id = get_identifier ("bad_alloc");
3767 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3768 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3770 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3771 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3775 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
3778 new_eh_spec = noexcept_false_spec;
3780 /* Ensure attribs.c is initialized. */
3782 extvisattr = build_tree_list (get_identifier ("externally_visible"),
3784 newattrs = tree_cons (get_identifier ("alloc_size"),
3785 build_tree_list (NULL_TREE, integer_one_node),
3787 newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs);
3788 newtype = build_exception_variant (newtype, new_eh_spec);
3789 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
3790 deltype = build_exception_variant (deltype, empty_except_spec);
3791 push_cp_library_fn (NEW_EXPR, newtype);
3792 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3793 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3794 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3796 nullptr_type_node = make_node (NULLPTR_TYPE);
3797 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
3798 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode));
3799 TYPE_UNSIGNED (nullptr_type_node) = 1;
3800 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode);
3801 SET_TYPE_MODE (nullptr_type_node, ptr_mode);
3802 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node);
3803 nullptr_node = build_int_cst (nullptr_type_node, 0);
3807 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3809 /* Perform other language dependent initializations. */
3810 init_class_processing ();
3811 init_rtti_processing ();
3812 init_template_processing ();
3814 if (flag_exceptions)
3815 init_exception_processing ();
3817 if (! supports_one_only ())
3820 make_fname_decl = cp_make_fname_decl;
3821 start_fname_decls ();
3823 /* Show we use EH for cleanups. */
3824 if (flag_exceptions)
3825 using_eh_for_cleanups ();
3828 /* Generate an initializer for a function naming variable from
3829 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3830 filled in with the type of the init. */
3833 cp_fname_init (const char* name, tree *type_p)
3835 tree domain = NULL_TREE;
3837 tree init = NULL_TREE;
3842 length = strlen (name);
3843 domain = build_index_type (size_int (length));
3844 init = build_string (length + 1, name);
3847 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3848 type = build_cplus_array_type (type, domain);
3853 TREE_TYPE (init) = type;
3855 init = error_mark_node;
3860 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3861 the decl, LOC is the location to give the decl, NAME is the
3862 initialization string and TYPE_DEP indicates whether NAME depended
3863 on the type of the function. We make use of that to detect
3864 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3865 at the point of first use, so we mustn't push the decl now. */
3868 cp_make_fname_decl (location_t loc, tree id, int type_dep)
3870 const char *const name = (type_dep && processing_template_decl
3871 ? NULL : fname_as_string (type_dep));
3873 tree init = cp_fname_init (name, &type);
3874 tree decl = build_decl (loc, VAR_DECL, id, type);
3877 free (CONST_CAST (char *, name));
3879 /* As we're using pushdecl_with_scope, we must set the context. */
3880 DECL_CONTEXT (decl) = current_function_decl;
3882 TREE_STATIC (decl) = 1;
3883 TREE_READONLY (decl) = 1;
3884 DECL_ARTIFICIAL (decl) = 1;
3886 TREE_USED (decl) = 1;
3888 if (current_function_decl)
3890 cp_binding_level *b = current_binding_level;
3891 if (b->kind == sk_function_parms)
3892 return error_mark_node;
3893 while (b->level_chain->kind != sk_function_parms)
3895 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3896 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3897 LOOKUP_ONLYCONVERTING);
3901 DECL_THIS_STATIC (decl) = true;
3902 pushdecl_top_level_and_finish (decl, init);
3909 builtin_function_1 (tree decl, tree context, bool is_global)
3911 tree id = DECL_NAME (decl);
3912 const char *name = IDENTIFIER_POINTER (id);
3914 retrofit_lang_decl (decl);
3916 DECL_ARTIFICIAL (decl) = 1;
3917 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3918 SET_DECL_LANGUAGE (decl, lang_c);
3919 /* Runtime library routines are, by definition, available in an
3920 external shared object. */
3921 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3922 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3924 DECL_CONTEXT (decl) = context;
3927 pushdecl_top_level (decl);
3931 /* A function in the user's namespace should have an explicit
3932 declaration before it is used. Mark the built-in function as
3933 anticipated but not actually declared. */
3934 if (name[0] != '_' || name[1] != '_')
3935 DECL_ANTICIPATED (decl) = 1;
3936 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3938 size_t len = strlen (name);
3940 /* Treat __*_chk fortification functions as anticipated as well,
3941 unless they are __builtin_*. */
3942 if (len > strlen ("___chk")
3943 && memcmp (name + len - strlen ("_chk"),
3944 "_chk", strlen ("_chk") + 1) == 0)
3945 DECL_ANTICIPATED (decl) = 1;
3952 cxx_builtin_function (tree decl)
3954 tree id = DECL_NAME (decl);
3955 const char *name = IDENTIFIER_POINTER (id);
3956 /* All builtins that don't begin with an '_' should additionally
3957 go in the 'std' namespace. */
3960 tree decl2 = copy_node(decl);
3961 push_namespace (std_identifier);
3962 builtin_function_1 (decl2, std_node, false);
3966 return builtin_function_1 (decl, NULL_TREE, false);
3969 /* Like cxx_builtin_function, but guarantee the function is added to the global
3970 scope. This is to allow function specific options to add new machine
3971 dependent builtins when the target ISA changes via attribute((target(...)))
3972 which saves space on program startup if the program does not use non-generic
3976 cxx_builtin_function_ext_scope (tree decl)
3979 tree id = DECL_NAME (decl);
3980 const char *name = IDENTIFIER_POINTER (id);
3981 /* All builtins that don't begin with an '_' should additionally
3982 go in the 'std' namespace. */
3985 tree decl2 = copy_node(decl);
3986 push_namespace (std_identifier);
3987 builtin_function_1 (decl2, std_node, true);
3991 return builtin_function_1 (decl, NULL_TREE, true);
3994 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3995 function. Not called directly. */
3998 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
4000 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
4001 DECL_EXTERNAL (fn) = 1;
4002 TREE_PUBLIC (fn) = 1;
4003 DECL_ARTIFICIAL (fn) = 1;
4004 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
4005 SET_DECL_LANGUAGE (fn, lang_c);
4006 /* Runtime library routines are, by definition, available in an
4007 external shared object. */
4008 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
4009 DECL_VISIBILITY_SPECIFIED (fn) = 1;
4013 /* Returns the _DECL for a library function with C linkage.
4014 We assume that such functions never throw; if this is incorrect,
4015 callers should unset TREE_NOTHROW. */
4018 build_library_fn (tree name, tree type)
4020 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
4021 TREE_NOTHROW (fn) = 1;
4025 /* Returns the _DECL for a library function with C++ linkage. */
4028 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
4030 tree fn = build_library_fn_1 (name, operator_code, type);
4031 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
4032 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
4033 SET_DECL_LANGUAGE (fn, lang_cplusplus);
4037 /* Like build_library_fn, but takes a C string instead of an
4041 build_library_fn_ptr (const char* name, tree type)
4043 return build_library_fn (get_identifier (name), type);
4046 /* Like build_cp_library_fn, but takes a C string instead of an
4050 build_cp_library_fn_ptr (const char* name, tree type)
4052 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
4055 /* Like build_library_fn, but also pushes the function so that we will
4056 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4057 may throw exceptions listed in RAISES. */
4060 push_library_fn (tree name, tree type, tree raises)
4065 type = build_exception_variant (type, raises);
4067 fn = build_library_fn (name, type);
4068 pushdecl_top_level (fn);
4072 /* Like build_cp_library_fn, but also pushes the function so that it
4073 will be found by normal lookup. */
4076 push_cp_library_fn (enum tree_code operator_code, tree type)
4078 tree fn = build_cp_library_fn (ansi_opname (operator_code),
4083 apply_tm_attr (fn, get_identifier ("transaction_safe"));
4087 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4091 push_void_library_fn (tree name, tree parmtypes)
4093 tree type = build_function_type (void_type_node, parmtypes);
4094 return push_library_fn (name, type, NULL_TREE);
4097 /* Like push_library_fn, but also note that this function throws
4098 and does not return. Used for __throw_foo and the like. */
4101 push_throw_library_fn (tree name, tree type)
4103 tree fn = push_library_fn (name, type, NULL_TREE);
4104 TREE_THIS_VOLATILE (fn) = 1;
4105 TREE_NOTHROW (fn) = 0;
4109 /* When we call finish_struct for an anonymous union, we create
4110 default copy constructors and such. But, an anonymous union
4111 shouldn't have such things; this function undoes the damage to the
4112 anonymous union type T.
4114 (The reason that we create the synthesized methods is that we don't
4115 distinguish `union { int i; }' from `typedef union { int i; } U'.
4116 The first is an anonymous union; the second is just an ordinary
4120 fixup_anonymous_aggr (tree t)
4124 /* Wipe out memory of synthesized methods. */
4125 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
4126 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
4127 TYPE_HAS_COPY_CTOR (t) = 0;
4128 TYPE_HAS_CONST_COPY_CTOR (t) = 0;
4129 TYPE_HAS_COPY_ASSIGN (t) = 0;
4130 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0;
4132 /* Splice the implicitly generated functions out of the TYPE_METHODS
4134 q = &TYPE_METHODS (t);
4137 if (DECL_ARTIFICIAL (*q))
4138 *q = TREE_CHAIN (*q);
4140 q = &DECL_CHAIN (*q);
4143 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4144 if (TYPE_METHODS (t))
4146 tree decl = TYPE_MAIN_DECL (t);
4148 if (TREE_CODE (t) != UNION_TYPE)
4149 error_at (DECL_SOURCE_LOCATION (decl),
4150 "an anonymous struct cannot have function members");
4152 error_at (DECL_SOURCE_LOCATION (decl),
4153 "an anonymous union cannot have function members");
4156 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4157 assignment operators (because they cannot have these methods themselves).
4158 For anonymous unions this is already checked because they are not allowed
4159 in any union, otherwise we have to check it. */
4160 if (TREE_CODE (t) != UNION_TYPE)
4164 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4165 if (TREE_CODE (field) == FIELD_DECL)
4167 type = TREE_TYPE (field);
4168 if (CLASS_TYPE_P (type))
4170 if (TYPE_NEEDS_CONSTRUCTING (type))
4171 error ("member %q+#D with constructor not allowed "
4172 "in anonymous aggregate", field);
4173 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4174 error ("member %q+#D with destructor not allowed "
4175 "in anonymous aggregate", field);
4176 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
4177 error ("member %q+#D with copy assignment operator "
4178 "not allowed in anonymous aggregate", field);
4184 /* Warn for an attribute located at LOCATION that appertains to the
4185 class type CLASS_TYPE that has not been properly placed after its
4186 class-key, in it class-specifier. */
4189 warn_misplaced_attr_for_class_type (source_location location,
4192 gcc_assert (TAGGED_TYPE_P (class_type));
4194 warning_at (location, OPT_Wattributes,
4195 "attribute ignored in declaration "
4196 "of %q#T", class_type);
4198 "attribute for %q#T must follow the %qs keyword",
4199 class_type, class_key_or_enum_as_string (class_type));
4202 /* Make sure that a declaration with no declarator is well-formed, i.e.
4203 just declares a tagged type or anonymous union.
4205 Returns the type declared; or NULL_TREE if none. */
4208 check_tag_decl (cp_decl_specifier_seq *declspecs,
4209 bool explicit_type_instantiation_p)
4211 int saw_friend = decl_spec_seq_has_spec_p (declspecs, ds_friend);
4212 int saw_typedef = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
4213 /* If a class, struct, or enum type is declared by the DECLSPECS
4214 (i.e, if a class-specifier, enum-specifier, or non-typename
4215 elaborated-type-specifier appears in the DECLSPECS),
4216 DECLARED_TYPE is set to the corresponding type. */
4217 tree declared_type = NULL_TREE;
4218 bool error_p = false;
4220 if (declspecs->multiple_types_p)
4221 error ("multiple types in one declaration");
4222 else if (declspecs->redefined_builtin_type)
4224 if (!in_system_header)
4225 permerror (declspecs->locations[ds_redefined_builtin_type_spec],
4226 "redeclaration of C++ built-in type %qT",
4227 declspecs->redefined_builtin_type);
4232 && TYPE_P (declspecs->type)
4233 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
4234 && MAYBE_CLASS_TYPE_P (declspecs->type))
4235 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
4236 declared_type = declspecs->type;
4237 else if (declspecs->type == error_mark_node)
4239 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
4240 permerror (input_location, "declaration does not declare anything");
4241 else if (declared_type != NULL_TREE && type_uses_auto (declared_type))
4243 error ("%<auto%> can only be specified for variables "
4244 "or function declarations");
4245 return error_mark_node;
4247 /* Check for an anonymous union. */
4248 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
4249 && TYPE_ANONYMOUS_P (declared_type))
4251 /* 7/3 In a simple-declaration, the optional init-declarator-list
4252 can be omitted only when declaring a class (clause 9) or
4253 enumeration (7.2), that is, when the decl-specifier-seq contains
4254 either a class-specifier, an elaborated-type-specifier with
4255 a class-key (9.1), or an enum-specifier. In these cases and
4256 whenever a class-specifier or enum-specifier is present in the
4257 decl-specifier-seq, the identifiers in these specifiers are among
4258 the names being declared by the declaration (as class-name,
4259 enum-names, or enumerators, depending on the syntax). In such
4260 cases, and except for the declaration of an unnamed bit-field (9.6),
4261 the decl-specifier-seq shall introduce one or more names into the
4262 program, or shall redeclare a name introduced by a previous
4263 declaration. [Example:
4264 enum { }; // ill-formed
4265 typedef class { }; // ill-formed
4269 error ("missing type-name in typedef-declaration");
4272 /* Anonymous unions are objects, so they can have specifiers. */;
4273 SET_ANON_AGGR_TYPE_P (declared_type);
4275 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
4276 pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
4281 if (decl_spec_seq_has_spec_p (declspecs, ds_inline)
4282 || decl_spec_seq_has_spec_p (declspecs, ds_virtual))
4283 error ("%qs can only be specified for functions",
4284 decl_spec_seq_has_spec_p (declspecs, ds_inline)
4285 ? "inline" : "virtual");
4287 && (!current_class_type
4288 || current_scope () != current_class_type))
4289 error ("%<friend%> can only be specified inside a class");
4290 else if (decl_spec_seq_has_spec_p (declspecs, ds_explicit))
4291 error ("%<explicit%> can only be specified for constructors");
4292 else if (declspecs->storage_class)
4293 error ("a storage class can only be specified for objects "
4295 else if (decl_spec_seq_has_spec_p (declspecs, ds_const)
4296 || decl_spec_seq_has_spec_p (declspecs, ds_volatile)
4297 || decl_spec_seq_has_spec_p (declspecs, ds_restrict)
4298 || decl_spec_seq_has_spec_p (declspecs, ds_thread))
4299 error ("qualifiers can only be specified for objects "
4301 else if (saw_typedef)
4302 warning (0, "%<typedef%> was ignored in this declaration");
4303 else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr))
4304 error ("%<constexpr%> cannot be used for type declarations");
4307 if (declspecs->attributes && warn_attributes && declared_type)
4310 if (!CLASS_TYPE_P (declared_type)
4311 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type))
4312 /* For a non-template class, use the name location. */
4313 loc = location_of (declared_type);
4315 /* For a template class (an explicit instantiation), use the
4316 current location. */
4317 loc = input_location;
4319 if (explicit_type_instantiation_p)
4320 /* [dcl.attr.grammar]/4:
4322 No attribute-specifier-seq shall appertain to an explicit
4325 warning_at (loc, OPT_Wattributes,
4326 "attribute ignored in explicit instantiation %q#T",
4329 "no attribute can be applied to "
4330 "an explicit instantiation");
4333 warn_misplaced_attr_for_class_type (loc, declared_type);
4336 return declared_type;
4339 /* Called when a declaration is seen that contains no names to declare.
4340 If its type is a reference to a structure, union or enum inherited
4341 from a containing scope, shadow that tag name for the current scope
4342 with a forward reference.
4343 If its type defines a new named structure or union
4344 or defines an enum, it is valid but we need not do anything here.
4345 Otherwise, it is an error.
4347 C++: may have to grok the declspecs to learn about static,
4348 complain for anonymous unions.
4350 Returns the TYPE declared -- or NULL_TREE if none. */
4353 shadow_tag (cp_decl_specifier_seq *declspecs)
4355 tree t = check_tag_decl (declspecs,
4356 /*explicit_type_instantiation_p=*/false);
4361 if (maybe_process_partial_specialization (t) == error_mark_node)
4364 /* This is where the variables in an anonymous union are
4365 declared. An anonymous union declaration looks like:
4367 because there is no declarator after the union, the parser
4368 sends that declaration here. */
4369 if (ANON_AGGR_TYPE_P (t))
4371 fixup_anonymous_aggr (t);
4373 if (TYPE_FIELDS (t))
4375 tree decl = grokdeclarator (/*declarator=*/NULL,
4376 declspecs, NORMAL, 0, NULL);
4377 finish_anon_union (decl);
4384 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4387 groktypename (cp_decl_specifier_seq *type_specifiers,
4388 const cp_declarator *declarator,
4389 bool is_template_arg)
4393 enum decl_context context
4394 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
4395 attrs = type_specifiers->attributes;
4396 type_specifiers->attributes = NULL_TREE;
4397 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
4398 if (attrs && type != error_mark_node)
4400 if (CLASS_TYPE_P (type))
4401 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
4402 "outside of definition", type);
4403 else if (MAYBE_CLASS_TYPE_P (type))
4404 /* A template type parameter or other dependent type. */
4405 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
4406 "type %qT without an associated declaration", type);
4408 cplus_decl_attributes (&type, attrs, 0);
4413 /* Process a DECLARATOR for a function-scope variable declaration,
4414 namespace-scope variable declaration, or function declaration.
4415 (Function definitions go through start_function; class member
4416 declarations appearing in the body of the class go through
4417 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4418 If an error occurs, the error_mark_node is returned instead.
4420 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4421 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4422 for an explicitly defaulted function, or SD_DELETED for an explicitly
4423 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4424 implicitly initialized via a default constructor. ATTRIBUTES and
4425 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4427 The scope represented by the context of the returned DECL is pushed
4428 (if it is not the global namespace) and is assigned to
4429 *PUSHED_SCOPE_P. The caller is then responsible for calling
4430 pop_scope on *PUSHED_SCOPE_P if it is set. */
4433 start_decl (const cp_declarator *declarator,
4434 cp_decl_specifier_seq *declspecs,
4437 tree prefix_attributes,
4438 tree *pushed_scope_p)
4446 *pushed_scope_p = NULL_TREE;
4448 /* An object declared as __attribute__((deprecated)) suppresses
4449 warnings of uses of other deprecated items. */
4450 if (lookup_attribute ("deprecated", attributes))
4451 deprecated_state = DEPRECATED_SUPPRESS;
4453 attributes = chainon (attributes, prefix_attributes);
4455 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4458 deprecated_state = DEPRECATED_NORMAL;
4460 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
4461 || decl == error_mark_node)
4462 return error_mark_node;
4464 context = CP_DECL_CONTEXT (decl);
4465 if (context != global_namespace)
4466 *pushed_scope_p = push_scope (context);
4469 /* Is it valid for this decl to have an initializer at all?
4470 If not, set INITIALIZED to zero, which will indirectly
4471 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4472 switch (TREE_CODE (decl))
4475 error ("typedef %qD is initialized (use decltype instead)", decl);
4476 return error_mark_node;
4479 if (initialized == SD_DELETED)
4480 /* We'll handle the rest of the semantics later, but we need to
4481 set this now so it's visible to duplicate_decls. */
4482 DECL_DELETED_FN (decl) = 1;
4491 if (! toplevel_bindings_p ()
4492 && DECL_EXTERNAL (decl))
4493 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4495 DECL_EXTERNAL (decl) = 0;
4496 if (toplevel_bindings_p ())
4497 TREE_STATIC (decl) = 1;
4499 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0;
4501 if (alias && TREE_CODE (decl) == FUNCTION_DECL)
4502 record_key_method_defined (decl);
4504 /* If this is a typedef that names the class for linkage purposes
4505 (7.1.3p8), apply any attributes directly to the type. */
4506 if (TREE_CODE (decl) == TYPE_DECL
4507 && TAGGED_TYPE_P (TREE_TYPE (decl))
4508 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4509 flags = ATTR_FLAG_TYPE_IN_PLACE;
4513 /* Set attributes here so if duplicate decl, will have proper attributes. */
4514 cplus_decl_attributes (&decl, attributes, flags);
4516 /* Dllimported symbols cannot be defined. Static data members (which
4517 can be initialized in-class and dllimported) go through grokfield,
4518 not here, so we don't need to exclude those decls when checking for
4520 if (initialized && DECL_DLLIMPORT_P (decl))
4522 error ("definition of %q#D is marked %<dllimport%>", decl);
4523 DECL_DLLIMPORT_P (decl) = 0;
4526 /* If #pragma weak was used, mark the decl weak now. */
4527 if (!processing_template_decl)
4528 maybe_apply_pragma_weak (decl);
4530 if (TREE_CODE (decl) == FUNCTION_DECL
4531 && DECL_DECLARED_INLINE_P (decl)
4532 && DECL_UNINLINABLE (decl)
4533 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4534 warning (0, "inline function %q+D given attribute noinline", decl);
4536 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context)))
4538 if (TREE_CODE (decl) == VAR_DECL)
4540 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4541 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4542 error ("%q#D is not a static member of %q#T", decl, context);
4545 if (DECL_CONTEXT (field) != context)
4547 if (!same_type_p (DECL_CONTEXT (field), context))
4548 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4549 "to be defined as %<%T::%D%>",
4550 DECL_CONTEXT (field), DECL_NAME (decl),
4551 context, DECL_NAME (decl));
4552 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4554 /* Static data member are tricky; an in-class initialization
4555 still doesn't provide a definition, so the in-class
4556 declaration will have DECL_EXTERNAL set, but will have an
4557 initialization. Thus, duplicate_decls won't warn
4558 about this situation, and so we check here. */
4559 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4560 error ("duplicate initialization of %qD", decl);
4561 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4563 if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr)
4564 && !DECL_DECLARED_CONSTEXPR_P (field))
4565 error ("%qD declared %<constexpr%> outside its class", field);
4570 tree field = check_classfn (context, decl,
4571 (processing_template_decl
4572 > template_class_depth (context))
4573 ? current_template_parms
4575 if (field && field != error_mark_node
4576 && duplicate_decls (decl, field,
4577 /*newdecl_is_friend=*/false))
4581 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4582 DECL_IN_AGGR_P (decl) = 0;
4583 /* Do not mark DECL as an explicit specialization if it was not
4584 already marked as an instantiation; a declaration should
4585 never be marked as a specialization unless we know what
4586 template is being specialized. */
4587 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4589 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4591 /* [temp.expl.spec] An explicit specialization of a static data
4592 member of a template is a definition if the declaration
4593 includes an initializer; otherwise, it is a declaration.
4595 We check for processing_specialization so this only applies
4596 to the new specialization syntax. */
4597 if (!initialized && processing_specialization)
4598 DECL_EXTERNAL (decl) = 1;
4601 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
4602 /* Aliases are definitions. */
4604 permerror (input_location, "declaration of %q#D outside of class is not definition",
4608 was_public = TREE_PUBLIC (decl);
4610 /* Enter this declaration into the symbol table. */
4611 decl = maybe_push_decl (decl);
4613 if (processing_template_decl)
4614 decl = push_template_decl (decl);
4615 if (decl == error_mark_node)
4616 return error_mark_node;
4618 if (TREE_CODE (decl) == VAR_DECL
4619 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4620 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4622 /* This is a const variable with implicit 'static'. Set
4623 DECL_THIS_STATIC so we can tell it from variables that are
4624 !TREE_PUBLIC because of the anonymous namespace. */
4625 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)) || errorcount);
4626 DECL_THIS_STATIC (decl) = 1;
4629 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4630 start_decl_1 (decl, initialized);
4635 /* Process the declaration of a variable DECL. INITIALIZED is true
4636 iff DECL is explicitly initialized. (INITIALIZED is false if the
4637 variable is initialized via an implicitly-called constructor.)
4638 This function must be called for ordinary variables (including, for
4639 example, implicit instantiations of templates), but must not be
4640 called for template declarations. */
4643 start_decl_1 (tree decl, bool initialized)
4647 bool aggregate_definition_p;
4649 gcc_assert (!processing_template_decl);
4651 if (error_operand_p (decl))
4654 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4656 type = TREE_TYPE (decl);
4657 complete_p = COMPLETE_TYPE_P (type);
4658 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4660 /* If an explicit initializer is present, or if this is a definition
4661 of an aggregate, then we need a complete type at this point.
4662 (Scalars are always complete types, so there is nothing to
4663 check.) This code just sets COMPLETE_P; errors (if necessary)
4664 are issued below. */
4665 if ((initialized || aggregate_definition_p)
4667 && COMPLETE_TYPE_P (complete_type (type)))
4670 /* We will not yet have set TREE_READONLY on DECL if the type
4671 was "const", but incomplete, before this point. But, now, we
4672 have a complete type, so we can try again. */
4673 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4677 /* Is it valid for this decl to have an initializer at all? */
4679 /* Don't allow initializations for incomplete types except for
4680 arrays which might be completed by the initialization. */
4682 ; /* A complete type is ok. */
4683 else if (type_uses_auto (type))
4684 ; /* An auto type is ok. */
4685 else if (TREE_CODE (type) != ARRAY_TYPE)
4687 error ("variable %q#D has initializer but incomplete type", decl);
4688 type = TREE_TYPE (decl) = error_mark_node;
4690 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4692 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4693 error ("elements of array %q#D have incomplete type", decl);
4694 /* else we already gave an error in start_decl. */
4697 else if (aggregate_definition_p && !complete_p)
4699 if (type_uses_auto (type))
4700 error ("declaration of %q#D has no initializer", decl);
4702 error ("aggregate %q#D has incomplete type and cannot be defined",
4704 /* Change the type so that assemble_variable will give
4705 DECL an rtl we can live with: (mem (const_int 0)). */
4706 type = TREE_TYPE (decl) = error_mark_node;
4709 /* Create a new scope to hold this declaration if necessary.
4710 Whether or not a new scope is necessary cannot be determined
4711 until after the type has been completed; if the type is a
4712 specialization of a class template it is not until after
4713 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4714 will be set correctly. */
4715 maybe_push_cleanup_level (type);
4718 /* Handle initialization of references. DECL, TYPE, and INIT have the
4719 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4720 but will be set to a new CLEANUP_STMT if a temporary is created
4721 that must be destroyed subsequently.
4723 Returns an initializer expression to use to initialize DECL, or
4724 NULL if the initialization can be performed statically.
4726 Quotes on semantics can be found in ARM 8.4.3. */
4729 grok_reference_init (tree decl, tree type, tree init, int flags)
4731 if (init == NULL_TREE)
4733 if ((DECL_LANG_SPECIFIC (decl) == 0
4734 || DECL_IN_AGGR_P (decl) == 0)
4735 && ! DECL_THIS_EXTERN (decl))
4736 error ("%qD declared as reference but not initialized", decl);
4740 if (TREE_CODE (init) == TREE_LIST)
4741 init = build_x_compound_expr_from_list (init, ELK_INIT,
4742 tf_warning_or_error);
4744 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4745 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4746 /* Note: default conversion is only called in very special cases. */
4747 init = decay_conversion (init, tf_warning_or_error);
4749 /* Convert INIT to the reference type TYPE. This may involve the
4750 creation of a temporary, whose lifetime must be the same as that
4751 of the reference. If so, a DECL_EXPR for the temporary will be
4752 added just after the DECL_EXPR for DECL. That's why we don't set
4753 DECL_INITIAL for local references (instead assigning to them
4754 explicitly); we need to allow the temporary to be initialized
4756 return initialize_reference (type, init, flags,
4757 tf_warning_or_error);
4760 /* Designated initializers in arrays are not supported in GNU C++.
4761 The parser cannot detect this error since it does not know whether
4762 a given brace-enclosed initializer is for a class type or for an
4763 array. This function checks that CE does not use a designated
4764 initializer. If it does, an error is issued. Returns true if CE
4765 is valid, i.e., does not have a designated initializer. */
4768 check_array_designated_initializer (constructor_elt *ce,
4769 unsigned HOST_WIDE_INT index)
4771 /* Designated initializers for array elements are not supported. */
4774 /* The parser only allows identifiers as designated
4776 if (ce->index == error_mark_node)
4778 error ("name used in a GNU-style designated "
4779 "initializer for an array");
4782 else if (TREE_CODE (ce->index) == IDENTIFIER_NODE)
4784 error ("name %qD used in a GNU-style designated "
4785 "initializer for an array", ce->index);
4789 ce->index = cxx_constant_value (ce->index);
4791 if (TREE_CODE (ce->index) == INTEGER_CST)
4793 /* A C99 designator is OK if it matches the current index. */
4794 if (TREE_INT_CST_LOW (ce->index) == index)
4797 sorry ("non-trivial designated initializers not supported");
4808 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4809 array until we finish parsing the initializer. If that's the
4810 situation we're in, update DECL accordingly. */
4813 maybe_deduce_size_from_array_init (tree decl, tree init)
4815 tree type = TREE_TYPE (decl);
4817 if (TREE_CODE (type) == ARRAY_TYPE
4818 && TYPE_DOMAIN (type) == NULL_TREE
4819 && TREE_CODE (decl) != TYPE_DECL)
4821 /* do_default is really a C-ism to deal with tentative definitions.
4822 But let's leave it here to ease the eventual merge. */
4823 int do_default = !DECL_EXTERNAL (decl);
4824 tree initializer = init ? init : DECL_INITIAL (decl);
4827 /* Check that there are no designated initializers in INIT, as
4828 those are not supported in GNU C++, and as the middle-end
4829 will crash if presented with a non-numeric designated
4831 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4833 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initializer);
4834 constructor_elt *ce;
4836 FOR_EACH_VEC_SAFE_ELT (v, i, ce)
4837 if (!check_array_designated_initializer (ce, i))
4843 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4847 error ("initializer fails to determine size of %qD", decl);
4849 else if (failure == 2)
4853 error ("array size missing in %qD", decl);
4855 /* If a `static' var's size isn't known, make it extern as
4856 well as static, so it does not get allocated. If it's not
4857 `static', then don't mark it extern; finish_incomplete_decl
4858 will give it a default size and it will get allocated. */
4859 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4860 DECL_EXTERNAL (decl) = 1;
4862 else if (failure == 3)
4864 error ("zero-size array %qD", decl);
4868 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4870 relayout_decl (decl);
4874 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4875 any appropriate error messages regarding the layout. */
4878 layout_var_decl (tree decl)
4882 type = TREE_TYPE (decl);
4883 if (type == error_mark_node)
4886 /* If we haven't already layed out this declaration, do so now.
4887 Note that we must not call complete type for an external object
4888 because it's type might involve templates that we are not
4889 supposed to instantiate yet. (And it's perfectly valid to say
4890 `extern X x' for some incomplete type `X'.) */
4891 if (!DECL_EXTERNAL (decl))
4892 complete_type (type);
4893 if (!DECL_SIZE (decl)
4894 && TREE_TYPE (decl) != error_mark_node
4895 && (COMPLETE_TYPE_P (type)
4896 || (TREE_CODE (type) == ARRAY_TYPE
4897 && !TYPE_DOMAIN (type)
4898 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4899 layout_decl (decl, 0);
4901 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4903 /* An automatic variable with an incomplete type: that is an error.
4904 Don't talk about array types here, since we took care of that
4905 message in grokdeclarator. */
4906 error ("storage size of %qD isn%'t known", decl);
4907 TREE_TYPE (decl) = error_mark_node;
4910 /* Keep this code around in case we later want to control debug info
4911 based on whether a type is "used". (jason 1999-11-11) */
4913 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
4914 /* Let debugger know it should output info for this type. */
4915 note_debug_info_needed (ttype);
4917 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4918 note_debug_info_needed (DECL_CONTEXT (decl));
4921 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4922 && DECL_SIZE (decl) != NULL_TREE
4923 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4925 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4926 constant_expression_warning (DECL_SIZE (decl));
4929 error ("storage size of %qD isn%'t constant", decl);
4930 TREE_TYPE (decl) = error_mark_node;
4935 /* If a local static variable is declared in an inline function, or if
4936 we have a weak definition, we must endeavor to create only one
4937 instance of the variable at link-time. */
4940 maybe_commonize_var (tree decl)
4942 /* Static data in a function with comdat linkage also has comdat
4944 if (TREE_STATIC (decl)
4945 /* Don't mess with __FUNCTION__. */
4946 && ! DECL_ARTIFICIAL (decl)
4947 && DECL_FUNCTION_SCOPE_P (decl)
4948 && vague_linkage_p (DECL_CONTEXT (decl)))
4952 /* With weak symbols, we simply make the variable COMDAT;
4953 that will cause copies in multiple translations units to
4955 comdat_linkage (decl);
4959 if (DECL_INITIAL (decl) == NULL_TREE
4960 || DECL_INITIAL (decl) == error_mark_node)
4962 /* Without weak symbols, we can use COMMON to merge
4963 uninitialized variables. */
4964 TREE_PUBLIC (decl) = 1;
4965 DECL_COMMON (decl) = 1;
4969 /* While for initialized variables, we must use internal
4970 linkage -- which means that multiple copies will not
4972 TREE_PUBLIC (decl) = 0;
4973 DECL_COMMON (decl) = 0;
4974 warning_at (input_location, 0,
4975 "sorry: semantics of inline function static "
4976 "data %q+#D are wrong (you%'ll wind up "
4977 "with multiple copies)", decl);
4978 warning_at (DECL_SOURCE_LOCATION (decl), 0,
4979 " you can work around this by removing "
4984 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4985 /* Set it up again; we might have set DECL_INITIAL since the last
4987 comdat_linkage (decl);
4990 /* Issue an error message if DECL is an uninitialized const variable. */
4993 check_for_uninitialized_const_var (tree decl)
4995 tree type = strip_array_types (TREE_TYPE (decl));
4997 /* ``Unless explicitly declared extern, a const object does not have
4998 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5000 if (TREE_CODE (decl) == VAR_DECL
5001 && TREE_CODE (type) != REFERENCE_TYPE
5002 && CP_TYPE_CONST_P (type)
5003 && !DECL_INITIAL (decl))
5005 tree field = default_init_uninitialized_part (type);
5009 permerror (DECL_SOURCE_LOCATION (decl),
5010 "uninitialized const %qD", decl);
5012 if (CLASS_TYPE_P (type))
5014 tree defaulted_ctor;
5016 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
5017 "%q#T has no user-provided default constructor", type);
5018 defaulted_ctor = in_class_defaulted_default_constructor (type);
5020 inform (DECL_SOURCE_LOCATION (defaulted_ctor),
5021 "constructor is not user-provided because it is "
5022 "explicitly defaulted in the class body");
5023 inform (0, "and the implicitly-defined constructor does not "
5024 "initialize %q+#D", field);
5029 /* Structure holding the current initializer being processed by reshape_init.
5030 CUR is a pointer to the current element being processed, END is a pointer
5031 after the last element present in the initializer. */
5032 typedef struct reshape_iterator_t
5034 constructor_elt *cur;
5035 constructor_elt *end;
5038 static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t);
5040 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5041 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5042 initialized. If there are no more such fields, the return value
5046 next_initializable_field (tree field)
5049 && (TREE_CODE (field) != FIELD_DECL
5050 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
5051 || DECL_ARTIFICIAL (field)))
5052 field = DECL_CHAIN (field);
5057 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5058 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5059 INTEGER_CST representing the size of the array minus one (the maximum index),
5060 or NULL_TREE if the array was declared without specifying the size. D is
5061 the iterator within the constructor. */
5064 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d,
5065 tsubst_flags_t complain)
5068 bool sized_array_p = (max_index != NULL_TREE);
5069 unsigned HOST_WIDE_INT max_index_cst = 0;
5070 unsigned HOST_WIDE_INT index;
5072 /* The initializer for an array is always a CONSTRUCTOR. */
5073 new_init = build_constructor (init_list_type_node, NULL);
5077 /* Minus 1 is used for zero sized arrays. */
5078 if (integer_all_onesp (max_index))
5081 if (host_integerp (max_index, 1))
5082 max_index_cst = tree_low_cst (max_index, 1);
5083 /* sizetype is sign extended, not zero extended. */
5085 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
5089 /* Loop until there are no more initializers. */
5091 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
5095 constructor_elt *old_cur = d->cur;
5097 check_array_designated_initializer (d->cur, index);
5098 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false,
5100 if (elt_init == error_mark_node)
5101 return error_mark_node;
5102 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
5103 size_int (index), elt_init);
5104 if (!TREE_CONSTANT (elt_init))
5105 TREE_CONSTANT (new_init) = false;
5107 /* This can happen with an invalid initializer (c++/54501). */
5108 if (d->cur == old_cur && !sized_array_p)
5115 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5116 Parameters are the same of reshape_init_r. */
5119 reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain)
5121 tree max_index = NULL_TREE;
5123 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
5125 if (TYPE_DOMAIN (type))
5126 max_index = array_type_nelts (type);
5128 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5131 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5132 Parameters are the same of reshape_init_r. */
5135 reshape_init_vector (tree type, reshape_iter *d, tsubst_flags_t complain)
5137 tree max_index = NULL_TREE;
5139 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
5141 if (COMPOUND_LITERAL_P (d->cur->value))
5143 tree value = d->cur->value;
5144 if (!same_type_p (TREE_TYPE (value), type))
5146 if (complain & tf_error)
5147 error ("invalid type %qT as initializer for a vector of type %qT",
5148 TREE_TYPE (d->cur->value), type);
5149 value = error_mark_node;
5155 /* For a vector, we initialize it as an array of the appropriate size. */
5156 if (TREE_CODE (type) == VECTOR_TYPE)
5157 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1);
5159 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5162 /* Subroutine of reshape_init_r, processes the initializers for classes
5163 or union. Parameters are the same of reshape_init_r. */
5166 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
5167 tsubst_flags_t complain)
5172 gcc_assert (CLASS_TYPE_P (type));
5174 /* The initializer for a class is always a CONSTRUCTOR. */
5175 new_init = build_constructor (init_list_type_node, NULL);
5176 field = next_initializable_field (TYPE_FIELDS (type));
5182 An initializer for an aggregate member that is an
5183 empty class shall have the form of an empty
5184 initializer-list {}. */
5185 if (!first_initializer_p)
5187 if (complain & tf_error)
5188 error ("initializer for %qT must be brace-enclosed", type);
5189 return error_mark_node;
5194 /* Loop through the initializable fields, gathering initializers. */
5195 while (d->cur != d->end)
5198 constructor_elt *old_cur = d->cur;
5200 /* Handle designated initializers, as an extension. */
5203 if (d->cur->index == error_mark_node)
5204 return error_mark_node;
5206 if (TREE_CODE (d->cur->index) == INTEGER_CST)
5208 if (complain & tf_error)
5209 error ("%<[%E] =%> used in a GNU-style designated initializer"
5210 " for class %qT", d->cur->index, type);
5211 return error_mark_node;
5214 if (TREE_CODE (d->cur->index) == FIELD_DECL)
5215 /* We already reshaped this. */
5216 gcc_assert (d->cur->index == field);
5218 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
5220 if (!field || TREE_CODE (field) != FIELD_DECL)
5222 if (complain & tf_error)
5223 error ("%qT has no non-static data member named %qD", type,
5225 return error_mark_node;
5229 /* If we processed all the member of the class, we are done. */
5233 field_init = reshape_init_r (TREE_TYPE (field), d,
5234 /*first_initializer_p=*/false, complain);
5235 if (field_init == error_mark_node)
5236 return error_mark_node;
5238 if (d->cur == old_cur && d->cur->index)
5240 /* This can happen with an invalid initializer for a flexible
5241 array member (c++/54441). */
5242 if (complain & tf_error)
5243 error ("invalid initializer for %q#D", field);
5244 return error_mark_node;
5247 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
5251 When a union is initialized with a brace-enclosed
5252 initializer, the braces shall only contain an
5253 initializer for the first member of the union. */
5254 if (TREE_CODE (type) == UNION_TYPE)
5257 field = next_initializable_field (DECL_CHAIN (field));
5263 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5264 designators are not valid; either complain or return true to indicate
5265 that reshape_init_r should return error_mark_node. */
5268 has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
5272 if (complain & tf_error)
5273 error ("C99 designator %qE outside aggregate initializer",
5281 /* Subroutine of reshape_init, which processes a single initializer (part of
5282 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5283 iterator within the CONSTRUCTOR which points to the initializer to process.
5284 FIRST_INITIALIZER_P is true if this is the first initializer of the
5285 outermost CONSTRUCTOR node. */
5288 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
5289 tsubst_flags_t complain)
5291 tree init = d->cur->value;
5293 if (error_operand_p (init))
5294 return error_mark_node;
5296 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
5297 && has_designator_problem (d, complain))
5298 return error_mark_node;
5300 if (TREE_CODE (type) == COMPLEX_TYPE)
5302 /* A complex type can be initialized from one or two initializers,
5303 but braces are not elided. */
5305 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5307 if (CONSTRUCTOR_NELTS (init) > 2)
5309 if (complain & tf_error)
5310 error ("too many initializers for %qT", type);
5312 return error_mark_node;
5315 else if (first_initializer_p && d->cur != d->end)
5317 vec<constructor_elt, va_gc> *v = 0;
5318 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
5319 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
5320 if (has_designator_problem (d, complain))
5321 return error_mark_node;
5323 init = build_constructor (init_list_type_node, v);
5328 /* A non-aggregate type is always initialized with a single
5330 if (!CP_AGGREGATE_TYPE_P (type))
5332 /* It is invalid to initialize a non-aggregate type with a
5333 brace-enclosed initializer before C++0x.
5334 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5335 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5336 a CONSTRUCTOR (with a record type). */
5337 if (TREE_CODE (init) == CONSTRUCTOR
5338 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
5340 if (SCALAR_TYPE_P (type))
5342 if (complain & tf_error)
5343 error ("braces around scalar initializer for type %qT", type);
5344 init = error_mark_node;
5347 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5356 All implicit type conversions (clause _conv_) are considered when
5357 initializing the aggregate member with an initializer from an
5358 initializer-list. If the initializer can initialize a member,
5359 the member is initialized. Otherwise, if the member is itself a
5360 non-empty subaggregate, brace elision is assumed and the
5361 initializer is considered for the initialization of the first
5362 member of the subaggregate. */
5363 if (TREE_CODE (init) != CONSTRUCTOR
5364 /* But don't try this for the first initializer, since that would be
5365 looking through the outermost braces; A a2 = { a1 }; is not a
5366 valid aggregate initialization. */
5367 && !first_initializer_p
5368 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
5369 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL,
5376 /* [dcl.init.string]
5378 A char array (whether plain char, signed char, or unsigned char)
5379 can be initialized by a string-literal (optionally enclosed in
5380 braces); a wchar_t array can be initialized by a wide
5381 string-literal (optionally enclosed in braces). */
5382 if (TREE_CODE (type) == ARRAY_TYPE
5383 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
5385 tree str_init = init;
5387 /* Strip one level of braces if and only if they enclose a single
5388 element (as allowed by [dcl.init.string]). */
5389 if (!first_initializer_p
5390 && TREE_CODE (str_init) == CONSTRUCTOR
5391 && vec_safe_length (CONSTRUCTOR_ELTS (str_init)) == 1)
5393 str_init = (*CONSTRUCTOR_ELTS (str_init))[0].value;
5396 /* If it's a string literal, then it's the initializer for the array
5397 as a whole. Otherwise, continue with normal initialization for
5398 array types (one value per array element). */
5399 if (TREE_CODE (str_init) == STRING_CST)
5401 if (has_designator_problem (d, complain))
5402 return error_mark_node;
5408 /* The following cases are about aggregates. If we are not within a full
5409 initializer already, and there is not a CONSTRUCTOR, it means that there
5410 is a missing set of braces (that is, we are processing the case for
5411 which reshape_init exists). */
5412 if (!first_initializer_p)
5414 if (TREE_CODE (init) == CONSTRUCTOR)
5416 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
5417 /* There is no need to reshape pointer-to-member function
5418 initializers, as they are always constructed correctly
5419 by the front end. */
5421 else if (COMPOUND_LITERAL_P (init))
5422 /* For a nested compound literal, there is no need to reshape since
5423 brace elision is not allowed. Even if we decided to allow it,
5424 we should add a call to reshape_init in finish_compound_literal,
5425 before calling digest_init, so changing this code would still
5426 not be necessary. */
5427 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
5431 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5432 return reshape_init (type, init, complain);
5436 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
5440 /* Dispatch to specialized routines. */
5441 if (CLASS_TYPE_P (type))
5442 return reshape_init_class (type, d, first_initializer_p, complain);
5443 else if (TREE_CODE (type) == ARRAY_TYPE)
5444 return reshape_init_array (type, d, complain);
5445 else if (TREE_CODE (type) == VECTOR_TYPE)
5446 return reshape_init_vector (type, d, complain);
5451 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5452 brace-enclosed aggregate initializer.
5454 INIT is the CONSTRUCTOR containing the list of initializers describing
5455 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5456 It may not presently match the shape of the TYPE; for example:
5458 struct S { int a; int b; };
5459 struct S a[] = { 1, 2, 3, 4 };
5461 Here INIT will hold a vector of four elements, rather than a
5462 vector of two elements, each itself a vector of two elements. This
5463 routine transforms INIT from the former form into the latter. The
5464 revised CONSTRUCTOR node is returned. */
5467 reshape_init (tree type, tree init, tsubst_flags_t complain)
5469 vec<constructor_elt, va_gc> *v;
5473 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5475 v = CONSTRUCTOR_ELTS (init);
5477 /* An empty constructor does not need reshaping, and it is always a valid
5479 if (vec_safe_is_empty (v))
5482 /* Recurse on this CONSTRUCTOR. */
5484 d.end = d.cur + v->length ();
5486 new_init = reshape_init_r (type, &d, true, complain);
5487 if (new_init == error_mark_node)
5488 return error_mark_node;
5490 /* Make sure all the element of the constructor were used. Otherwise,
5491 issue an error about exceeding initializers. */
5494 if (complain & tf_error)
5495 error ("too many initializers for %qT", type);
5497 return error_mark_node;
5503 /* Verify array initializer. Returns true if errors have been reported. */
5506 check_array_initializer (tree decl, tree type, tree init)
5508 tree element_type = TREE_TYPE (type);
5510 /* The array type itself need not be complete, because the
5511 initializer may tell us how many elements are in the array.
5512 But, the elements of the array must be complete. */
5513 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5516 error ("elements of array %q#D have incomplete type", decl);
5518 error ("elements of array %q#T have incomplete type", type);
5521 /* It is not valid to initialize a VLA. */
5523 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5524 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5527 error ("variable-sized object %qD may not be initialized", decl);
5529 error ("variable-sized compound literal");
5535 /* Subroutine of check_initializer; args are passed down from that function.
5536 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5539 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5542 gcc_assert (stmts_are_full_exprs_p ());
5543 return build_aggr_init (decl, init, flags, tf_warning_or_error);
5546 /* Verify INIT (the initializer for DECL), and record the
5547 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5548 grok_reference_init.
5550 If the return value is non-NULL, it is an expression that must be
5551 evaluated dynamically to initialize DECL. */
5554 check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups)
5556 tree type = TREE_TYPE (decl);
5557 tree init_code = NULL;
5558 tree extra_init = NULL_TREE;
5561 /* Things that are going to be initialized need to have complete
5563 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5565 if (DECL_HAS_VALUE_EXPR_P (decl))
5567 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5568 it doesn't have storage to be initialized. */
5569 gcc_assert (init == NULL_TREE);
5573 if (type == error_mark_node)
5574 /* We will have already complained. */
5577 if (TREE_CODE (type) == ARRAY_TYPE)
5579 if (check_array_initializer (decl, type, init))
5582 else if (!COMPLETE_TYPE_P (type))
5584 error ("%q#D has incomplete type", decl);
5585 TREE_TYPE (decl) = error_mark_node;
5589 /* There is no way to make a variable-sized class type in GNU C++. */
5590 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5592 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5594 int init_len = vec_safe_length (CONSTRUCTOR_ELTS (init));
5595 if (SCALAR_TYPE_P (type))
5599 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5600 init = build_zero_init (type, NULL_TREE, false);
5602 else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
5604 error ("scalar object %qD requires one element in initializer",
5606 TREE_TYPE (decl) = error_mark_node;
5612 if (TREE_CODE (decl) == CONST_DECL)
5614 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5616 DECL_INITIAL (decl) = init;
5618 gcc_assert (init != NULL_TREE);
5621 else if (!init && DECL_REALLY_EXTERN (decl))
5623 else if (init || type_build_ctor_call (type)
5624 || TREE_CODE (type) == REFERENCE_TYPE)
5626 if (TREE_CODE (type) == REFERENCE_TYPE)
5628 init = grok_reference_init (decl, type, init, flags);
5629 flags |= LOOKUP_ALREADY_DIGESTED;
5632 check_for_uninitialized_const_var (decl);
5633 /* Do not reshape constructors of vectors (they don't need to be
5635 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
5637 if (is_std_init_list (type))
5639 init = perform_implicit_conversion (type, init,
5640 tf_warning_or_error);
5641 flags |= LOOKUP_ALREADY_DIGESTED;
5643 else if (TYPE_NON_AGGREGATE_CLASS (type))
5645 /* Don't reshape if the class has constructors. */
5646 if (cxx_dialect == cxx98)
5647 error ("in C++98 %qD must be initialized by constructor, "
5651 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5653 error ("opaque vector types cannot be initialized");
5654 init = error_mark_node;
5658 init = reshape_init (type, init, tf_warning_or_error);
5659 if (SCALAR_TYPE_P (type))
5660 check_narrowing (type, init);
5664 /* If DECL has an array type without a specific bound, deduce the
5665 array size from the initializer. */
5666 maybe_deduce_size_from_array_init (decl, init);
5667 type = TREE_TYPE (decl);
5668 if (type == error_mark_node)
5671 if ((type_build_ctor_call (type) || CLASS_TYPE_P (type))
5672 && !(flags & LOOKUP_ALREADY_DIGESTED)
5673 && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
5674 && CP_AGGREGATE_TYPE_P (type)
5675 && (CLASS_TYPE_P (type)
5676 || type_has_extended_temps (type))))
5678 init_code = build_aggr_init_full_exprs (decl, init, flags);
5680 /* A constructor call is a non-trivial initializer even if
5681 it isn't explicitly written. */
5682 if (TREE_SIDE_EFFECTS (init_code))
5683 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = true;
5685 /* If this is a constexpr initializer, expand_default_init will
5686 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5687 case, pull the initializer back out and pass it down into
5688 store_init_value. */
5689 while (TREE_CODE (init_code) == EXPR_STMT
5690 || TREE_CODE (init_code) == CONVERT_EXPR)
5691 init_code = TREE_OPERAND (init_code, 0);
5692 if (TREE_CODE (init_code) == INIT_EXPR)
5694 init = TREE_OPERAND (init_code, 1);
5695 init_code = NULL_TREE;
5696 /* Don't call digest_init; it's unnecessary and will complain
5697 about aggregate initialization of non-aggregate classes. */
5698 flags |= LOOKUP_ALREADY_DIGESTED;
5700 else if (DECL_DECLARED_CONSTEXPR_P (decl))
5702 /* Declared constexpr, but no suitable initializer; massage
5703 init appropriately so we can pass it into store_init_value
5705 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5706 init = finish_compound_literal (type, init,
5707 tf_warning_or_error);
5708 else if (CLASS_TYPE_P (type)
5709 && (!init || TREE_CODE (init) == TREE_LIST))
5711 init = build_functional_cast (type, init, tf_none);
5712 if (TREE_CODE (init) == TARGET_EXPR)
5713 TARGET_EXPR_DIRECT_INIT_P (init) = true;
5715 init_code = NULL_TREE;
5721 if (init && TREE_CODE (init) != TREE_VEC)
5723 /* In aggregate initialization of a variable, each element
5724 initialization is a full-expression because there is no
5725 enclosing expression. */
5726 gcc_assert (stmts_are_full_exprs_p ());
5728 init_code = store_init_value (decl, init, cleanups, flags);
5730 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5731 && DECL_INITIAL (decl)
5732 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5733 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5734 warning (0, "array %qD initialized by parenthesized string literal %qE",
5735 decl, DECL_INITIAL (decl));
5741 if (CLASS_TYPE_P (core_type = strip_array_types (type))
5742 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
5743 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
5744 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
5747 check_for_uninitialized_const_var (decl);
5750 if (init && init != error_mark_node)
5751 init_code = build2 (INIT_EXPR, type, decl, init);
5754 init_code = add_stmt_to_compound (extra_init, init_code);
5756 if (init_code && DECL_IN_AGGR_P (decl))
5758 static int explained = 0;
5760 if (cxx_dialect < cxx0x)
5761 error ("initializer invalid for static member with constructor");
5763 error ("non-constant in-class initialization invalid for static "
5764 "member %qD", decl);
5767 error ("(an out of class initialization is required)");
5775 /* If DECL is not a local variable, give it RTL. */
5778 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5780 int toplev = toplevel_bindings_p ();
5782 const char *filename;
5784 /* Set the DECL_ASSEMBLER_NAME for the object. */
5787 /* The `register' keyword, when used together with an
5788 asm-specification, indicates that the variable should be
5789 placed in a particular register. */
5790 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5792 set_user_assembler_name (decl, asmspec);
5793 DECL_HARD_REGISTER (decl) = 1;
5797 if (TREE_CODE (decl) == FUNCTION_DECL
5798 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5799 set_builtin_user_assembler_name (decl, asmspec);
5800 set_user_assembler_name (decl, asmspec);
5804 /* Handle non-variables up front. */
5805 if (TREE_CODE (decl) != VAR_DECL)
5807 rest_of_decl_compilation (decl, toplev, at_eof);
5811 /* If we see a class member here, it should be a static data
5813 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5815 gcc_assert (TREE_STATIC (decl));
5816 /* An in-class declaration of a static data member should be
5817 external; it is only a declaration, and not a definition. */
5818 if (init == NULL_TREE)
5819 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5822 /* We don't create any RTL for local variables. */
5823 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5826 /* We defer emission of local statics until the corresponding
5827 DECL_EXPR is expanded. */
5828 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5830 /* We try to defer namespace-scope static constants so that they are
5831 not emitted into the object file unnecessarily. */
5832 filename = input_filename;
5833 if (!DECL_VIRTUAL_P (decl)
5834 && TREE_READONLY (decl)
5835 && DECL_INITIAL (decl) != NULL_TREE
5836 && DECL_INITIAL (decl) != error_mark_node
5838 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5840 && !TREE_PUBLIC (decl))
5842 /* Fool with the linkage of static consts according to #pragma
5844 struct c_fileinfo *finfo = get_fileinfo (filename);
5845 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5847 TREE_PUBLIC (decl) = 1;
5848 DECL_EXTERNAL (decl) = finfo->interface_only;
5853 /* Likewise for template instantiations. */
5854 else if (DECL_LANG_SPECIFIC (decl)
5855 && DECL_IMPLICIT_INSTANTIATION (decl))
5858 /* If we're not deferring, go ahead and assemble the variable. */
5860 rest_of_decl_compilation (decl, toplev, at_eof);
5863 /* walk_tree helper for wrap_temporary_cleanups, below. */
5866 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5868 /* Stop at types or full-expression boundaries. */
5869 if (TYPE_P (*stmt_p)
5870 || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR)
5876 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5878 tree guard = (tree)data;
5879 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5881 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5882 /* Tell honor_protect_cleanup_actions to handle this as a separate
5884 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5886 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5892 /* We're initializing a local variable which has a cleanup GUARD. If there
5893 are any temporaries used in the initializer INIT of this variable, we
5894 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5895 variable will be cleaned up properly if one of them throws.
5897 Unfortunately, there's no way to express this properly in terms of
5898 nesting, as the regions for the temporaries overlap the region for the
5899 variable itself; if there are two temporaries, the variable needs to be
5900 the first thing destroyed if either of them throws. However, we only
5901 want to run the variable's cleanup if it actually got constructed. So
5902 we need to guard the temporary cleanups with the variable's cleanup if
5903 they are run on the normal path, but not if they are run on the
5904 exceptional path. We implement this by telling
5905 honor_protect_cleanup_actions to strip the variable cleanup from the
5906 exceptional path. */
5909 wrap_temporary_cleanups (tree init, tree guard)
5911 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5914 /* Generate code to initialize DECL (a local variable). */
5917 initialize_local_var (tree decl, tree init)
5919 tree type = TREE_TYPE (decl);
5923 gcc_assert (TREE_CODE (decl) == VAR_DECL
5924 || TREE_CODE (decl) == RESULT_DECL);
5925 gcc_assert (!TREE_STATIC (decl));
5927 if (DECL_SIZE (decl) == NULL_TREE)
5929 /* If we used it already as memory, it must stay in memory. */
5930 DECL_INITIAL (decl) = NULL_TREE;
5931 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5935 if (type == error_mark_node)
5938 /* Compute and store the initial value. */
5939 already_used = TREE_USED (decl) || TREE_USED (type);
5940 if (TREE_USED (type))
5941 DECL_READ_P (decl) = 1;
5943 /* Generate a cleanup, if necessary. */
5944 cleanup = cxx_maybe_build_cleanup (decl, tf_warning_or_error);
5946 /* Perform the initialization. */
5949 if (TREE_CODE (init) == INIT_EXPR
5950 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init, 1)))
5952 /* Stick simple initializers in DECL_INITIAL so that
5953 -Wno-init-self works (c++/34772). */
5954 gcc_assert (TREE_OPERAND (init, 0) == decl);
5955 DECL_INITIAL (decl) = TREE_OPERAND (init, 1);
5959 int saved_stmts_are_full_exprs_p;
5961 /* If we're only initializing a single object, guard the
5962 destructors of any temporaries used in its initializer with
5963 its destructor. This isn't right for arrays because each
5964 element initialization is a full-expression. */
5965 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5966 wrap_temporary_cleanups (init, cleanup);
5968 gcc_assert (building_stmt_list_p ());
5969 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5970 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5971 finish_expr_stmt (init);
5972 current_stmt_tree ()->stmts_are_full_exprs_p =
5973 saved_stmts_are_full_exprs_p;
5977 /* Set this to 0 so we can tell whether an aggregate which was
5978 initialized was ever used. Don't do this if it has a
5979 destructor, so we don't complain about the 'resource
5980 allocation is initialization' idiom. Now set
5981 attribute((unused)) on types so decls of that type will be
5982 marked used. (see TREE_USED, above.) */
5983 if (TYPE_NEEDS_CONSTRUCTING (type)
5985 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5986 && DECL_NAME (decl))
5987 TREE_USED (decl) = 0;
5988 else if (already_used)
5989 TREE_USED (decl) = 1;
5992 finish_decl_cleanup (decl, cleanup);
5995 /* DECL is a VAR_DECL for a compiler-generated variable with static
5996 storage duration (like a virtual table) whose initializer is a
5997 compile-time constant. Initialize the variable and provide it to the
6001 initialize_artificial_var (tree decl, vec<constructor_elt, va_gc> *v)
6004 gcc_assert (DECL_ARTIFICIAL (decl));
6005 init = build_constructor (TREE_TYPE (decl), v);
6006 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
6007 DECL_INITIAL (decl) = init;
6008 DECL_INITIALIZED_P (decl) = 1;
6009 determine_visibility (decl);
6010 layout_var_decl (decl);
6011 maybe_commonize_var (decl);
6012 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
6015 /* INIT is the initializer for a variable, as represented by the
6016 parser. Returns true iff INIT is type-dependent. */
6019 type_dependent_init_p (tree init)
6021 if (TREE_CODE (init) == TREE_LIST)
6022 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6023 return any_type_dependent_elements_p (init);
6024 else if (TREE_CODE (init) == CONSTRUCTOR)
6025 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6027 vec<constructor_elt, va_gc> *elts;
6031 elts = CONSTRUCTOR_ELTS (init);
6032 nelts = vec_safe_length (elts);
6033 for (i = 0; i < nelts; ++i)
6034 if (type_dependent_init_p ((*elts)[i].value))
6038 /* It must be a simple expression, e.g., int i = 3; */
6039 return type_dependent_expression_p (init);
6044 /* INIT is the initializer for a variable, as represented by the
6045 parser. Returns true iff INIT is value-dependent. */
6048 value_dependent_init_p (tree init)
6050 if (TREE_CODE (init) == TREE_LIST)
6051 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6052 return any_value_dependent_elements_p (init);
6053 else if (TREE_CODE (init) == CONSTRUCTOR)
6054 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6056 vec<constructor_elt, va_gc> *elts;
6060 elts = CONSTRUCTOR_ELTS (init);
6061 nelts = vec_safe_length (elts);
6062 for (i = 0; i < nelts; ++i)
6063 if (value_dependent_init_p ((*elts)[i].value))
6067 /* It must be a simple expression, e.g., int i = 3; */
6068 return value_dependent_expression_p (init);
6073 /* Finish processing of a declaration;
6074 install its line number and initial value.
6075 If the length of an array type is not known before,
6076 it must be determined now, from the initial value, or it is an error.
6078 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6079 true, then INIT is an integral constant expression.
6081 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6082 if the (init) syntax was used. */
6085 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
6086 tree asmspec_tree, int flags)
6089 vec<tree, va_gc> *cleanups = NULL;
6090 const char *asmspec = NULL;
6091 int was_readonly = 0;
6092 bool var_definition_p = false;
6095 if (decl == error_mark_node)
6100 error ("assignment (not initialization) in declaration");
6104 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
6105 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6106 gcc_assert (TREE_CODE (decl) != PARM_DECL);
6108 type = TREE_TYPE (decl);
6109 if (type == error_mark_node)
6112 /* If a name was specified, get the string. */
6113 if (at_namespace_scope_p ())
6114 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
6115 if (asmspec_tree && asmspec_tree != error_mark_node)
6116 asmspec = TREE_STRING_POINTER (asmspec_tree);
6118 if (current_class_type
6119 && CP_DECL_CONTEXT (decl) == current_class_type
6120 && TYPE_BEING_DEFINED (current_class_type)
6121 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type)
6122 && (DECL_INITIAL (decl) || init))
6123 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
6125 if (TREE_CODE (decl) != FUNCTION_DECL
6126 && (auto_node = type_uses_auto (type)))
6129 if (init == NULL_TREE)
6131 if (DECL_LANG_SPECIFIC (decl)
6132 && DECL_TEMPLATE_INSTANTIATION (decl)
6133 && !DECL_TEMPLATE_INSTANTIATED (decl))
6135 /* init is null because we're deferring instantiating the
6136 initializer until we need it. Well, we need it now. */
6137 instantiate_decl (decl, /*defer_ok*/true, /*expl*/false);
6141 error ("declaration of %q#D has no initializer", decl);
6142 TREE_TYPE (decl) = error_mark_node;
6146 if (TREE_CODE (d_init) == TREE_LIST)
6147 d_init = build_x_compound_expr_from_list (d_init, ELK_INIT,
6148 tf_warning_or_error);
6149 d_init = resolve_nondeduced_context (d_init);
6150 type = TREE_TYPE (decl) = do_auto_deduction (type, d_init,
6152 if (type == error_mark_node)
6154 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
6157 if (!ensure_literal_type_for_constexpr_object (decl))
6158 DECL_DECLARED_CONSTEXPR_P (decl) = 0;
6160 if (TREE_CODE (decl) == VAR_DECL
6161 && DECL_CLASS_SCOPE_P (decl)
6162 && DECL_INITIALIZED_IN_CLASS_P (decl))
6163 check_static_variable_definition (decl, type);
6165 if (init && TREE_CODE (decl) == FUNCTION_DECL)
6168 if (init == ridpointers[(int)RID_DELETE])
6170 /* FIXME check this is 1st decl. */
6171 DECL_DELETED_FN (decl) = 1;
6172 DECL_DECLARED_INLINE_P (decl) = 1;
6173 DECL_INITIAL (decl) = error_mark_node;
6174 FOR_EACH_CLONE (clone, decl)
6176 DECL_DELETED_FN (clone) = 1;
6177 DECL_DECLARED_INLINE_P (clone) = 1;
6178 DECL_INITIAL (clone) = error_mark_node;
6182 else if (init == ridpointers[(int)RID_DEFAULT])
6184 if (defaultable_fn_check (decl))
6185 DECL_DEFAULTED_FN (decl) = 1;
6187 DECL_INITIAL (decl) = NULL_TREE;
6191 if (init && TREE_CODE (decl) == VAR_DECL)
6193 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
6194 /* If DECL is a reference, then we want to know whether init is a
6195 reference constant; init_const_expr_p as passed tells us whether
6196 it's an rvalue constant. */
6197 if (TREE_CODE (type) == REFERENCE_TYPE)
6198 init_const_expr_p = potential_constant_expression (init);
6199 if (init_const_expr_p)
6201 /* Set these flags now for templates. We'll update the flags in
6202 store_init_value for instantiations. */
6203 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
6204 if (decl_maybe_constant_var_p (decl))
6205 TREE_CONSTANT (decl) = 1;
6209 if (processing_template_decl)
6211 bool type_dependent_p;
6213 /* Add this declaration to the statement-tree. */
6214 if (at_function_scope_p ())
6215 add_decl_expr (decl);
6217 type_dependent_p = dependent_type_p (type);
6219 if (check_for_bare_parameter_packs (init))
6222 DECL_INITIAL (decl) = NULL_TREE;
6225 /* Generally, initializers in templates are expanded when the
6226 template is instantiated. But, if DECL is a variable constant
6227 then it can be used in future constant expressions, so its value
6228 must be available. */
6230 if (TREE_CODE (decl) != VAR_DECL || dependent_type_p (type))
6231 /* We can't do anything if the decl has dependent type. */;
6233 && init_const_expr_p
6234 && !type_dependent_p
6235 && decl_maybe_constant_var_p (decl)
6236 && !type_dependent_init_p (init)
6237 && !value_dependent_init_p (init))
6239 /* This variable seems to be a non-dependent constant, so process
6240 its initializer. If check_initializer returns non-null the
6241 initialization wasn't constant after all. */
6243 cleanups = make_tree_vector ();
6244 init_code = check_initializer (decl, init, flags, &cleanups);
6245 if (init_code == NULL_TREE)
6247 release_tree_vector (cleanups);
6249 else if (!DECL_PRETTY_FUNCTION_P (decl))
6251 /* Deduce array size even if the initializer is dependent. */
6252 maybe_deduce_size_from_array_init (decl, init);
6253 /* And complain about multiple initializers. */
6254 if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init)
6255 && !MAYBE_CLASS_TYPE_P (type))
6256 init = build_x_compound_expr_from_list (init, ELK_INIT,
6257 tf_warning_or_error);
6261 DECL_INITIAL (decl) = init;
6265 /* Just store non-static data member initializers for later. */
6266 if (init && TREE_CODE (decl) == FIELD_DECL)
6267 DECL_INITIAL (decl) = init;
6269 /* Take care of TYPE_DECLs up front. */
6270 if (TREE_CODE (decl) == TYPE_DECL)
6272 if (type != error_mark_node
6273 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
6275 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6276 warning (0, "shadowing previous type declaration of %q#D", decl);
6277 set_identifier_type_value (DECL_NAME (decl), decl);
6280 /* If we have installed this as the canonical typedef for this
6281 type, and that type has not been defined yet, delay emitting
6282 the debug information for it, as we will emit it later. */
6283 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
6284 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
6285 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6287 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl),
6292 /* A reference will be modified here, as it is initialized. */
6293 if (! DECL_EXTERNAL (decl)
6294 && TREE_READONLY (decl)
6295 && TREE_CODE (type) == REFERENCE_TYPE)
6298 TREE_READONLY (decl) = 0;
6301 if (TREE_CODE (decl) == VAR_DECL)
6303 /* If this is a local variable that will need a mangled name,
6304 register it now. We must do this before processing the
6305 initializer for the variable, since the initialization might
6306 require a guard variable, and since the mangled name of the
6307 guard variable will depend on the mangled name of this
6309 if (DECL_FUNCTION_SCOPE_P (decl)
6310 && TREE_STATIC (decl)
6311 && !DECL_ARTIFICIAL (decl))
6313 push_local_name (decl);
6314 if (DECL_CONSTRUCTOR_P (current_function_decl)
6315 || DECL_DESTRUCTOR_P (current_function_decl))
6316 /* Normally local_decls is populated during GIMPLE lowering,
6317 but [cd]tors are never actually compiled directly. We need
6318 to put statics on the list so we can deal with the label
6319 address extension. FIXME. */
6320 add_local_decl (cfun, decl);
6323 /* Convert the initializer to the type of DECL, if we have not
6324 already initialized DECL. */
6325 if (!DECL_INITIALIZED_P (decl)
6326 /* If !DECL_EXTERNAL then DECL is being defined. In the
6327 case of a static data member initialized inside the
6328 class-specifier, there can be an initializer even if DECL
6329 is *not* defined. */
6330 && (!DECL_EXTERNAL (decl) || init))
6332 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6335 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6336 /* Allow libjava/prims.cc define primitive classes. */
6337 if (init != NULL_TREE
6338 || jclass == NULL_TREE
6339 || TREE_CODE (jclass) != TYPE_DECL
6340 || !POINTER_TYPE_P (TREE_TYPE (jclass))
6341 || !same_type_ignoring_top_level_qualifiers_p
6342 (type, TREE_TYPE (TREE_TYPE (jclass))))
6343 error ("Java object %qD not allocated with %<new%>", decl);
6346 cleanups = make_tree_vector ();
6347 init = check_initializer (decl, init, flags, &cleanups);
6349 /* Check that the initializer for a static data member was a
6350 constant. Although we check in the parser that the
6351 initializer is an integral constant expression, we do not
6352 simplify division-by-zero at the point at which it
6353 occurs. Therefore, in:
6355 struct S { static const int i = 7 / 0; };
6357 we issue an error at this point. It would
6358 probably be better to forbid division by zero in
6359 integral constant expressions. */
6360 if (DECL_EXTERNAL (decl) && init)
6362 error ("%qD cannot be initialized by a non-constant expression"
6363 " when being declared", decl);
6364 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
6372 The memory occupied by any object of static storage
6373 duration is zero-initialized at program startup before
6374 any other initialization takes place.
6376 We cannot create an appropriate initializer until after
6377 the type of DECL is finalized. If DECL_INITIAL is set,
6378 then the DECL is statically initialized, and any
6379 necessary zero-initialization has already been performed. */
6380 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
6381 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
6382 /*nelts=*/NULL_TREE,
6383 /*static_storage_p=*/true);
6384 /* Remember that the initialization for this variable has
6386 DECL_INITIALIZED_P (decl) = 1;
6387 /* This declaration is the definition of this variable,
6388 unless we are initializing a static data member within
6389 the class specifier. */
6390 if (!DECL_EXTERNAL (decl))
6391 var_definition_p = true;
6393 /* If the variable has an array type, lay out the type, even if
6394 there is no initializer. It is valid to index through the
6395 array, and we must get TYPE_ALIGN set correctly on the array
6397 else if (TREE_CODE (type) == ARRAY_TYPE)
6400 if (TREE_STATIC (decl)
6401 && !at_function_scope_p ()
6402 && current_function_decl == NULL)
6403 /* So decl is a global variable or a static member of a
6404 non local class. Record the types it uses
6405 so that we can decide later to emit debug info for them. */
6406 record_types_used_by_current_var_decl (decl);
6408 else if (TREE_CODE (decl) == FIELD_DECL
6409 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6410 error ("non-static data member %qD has Java class type", decl);
6412 /* Add this declaration to the statement-tree. This needs to happen
6413 after the call to check_initializer so that the DECL_EXPR for a
6414 reference temp is added before the DECL_EXPR for the reference itself. */
6415 if (DECL_FUNCTION_SCOPE_P (decl))
6416 add_decl_expr (decl);
6418 /* Let the middle end know about variables and functions -- but not
6419 static data members in uninstantiated class templates. */
6420 if (TREE_CODE (decl) == VAR_DECL
6421 || TREE_CODE (decl) == FUNCTION_DECL)
6423 if (TREE_CODE (decl) == VAR_DECL)
6425 layout_var_decl (decl);
6426 maybe_commonize_var (decl);
6429 /* This needs to happen after the linkage is set. */
6430 determine_visibility (decl);
6432 if (var_definition_p && TREE_STATIC (decl))
6434 /* If a TREE_READONLY variable needs initialization
6435 at runtime, it is no longer readonly and we need to
6436 avoid MEM_READONLY_P being set on RTL created for it. */
6439 if (TREE_READONLY (decl))
6440 TREE_READONLY (decl) = 0;
6443 else if (was_readonly)
6444 TREE_READONLY (decl) = 1;
6446 /* Likewise if it needs destruction. */
6447 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6448 TREE_READONLY (decl) = 0;
6451 make_rtl_for_nonlocal_decl (decl, init, asmspec);
6453 /* Check for abstractness of the type. Notice that there is no
6454 need to strip array types here since the check for those types
6455 is already done within create_array_type_for_decl. */
6456 if (TREE_CODE (type) == FUNCTION_TYPE
6457 || TREE_CODE (type) == METHOD_TYPE)
6458 abstract_virtuals_error (decl, TREE_TYPE (type));
6460 abstract_virtuals_error (decl, type);
6462 if (TREE_TYPE (decl) == error_mark_node)
6463 /* No initialization required. */
6465 else if (TREE_CODE (decl) == FUNCTION_DECL)
6469 if (init == ridpointers[(int)RID_DEFAULT])
6471 /* An out-of-class default definition is defined at
6472 the point where it is explicitly defaulted. */
6473 if (DECL_DELETED_FN (decl))
6474 maybe_explain_implicit_delete (decl);
6475 else if (DECL_INITIAL (decl) == error_mark_node)
6476 synthesize_method (decl);
6479 error ("function %q#D is initialized like a variable", decl);
6481 /* else no initialization required. */
6483 else if (DECL_EXTERNAL (decl)
6484 && ! (DECL_LANG_SPECIFIC (decl)
6485 && DECL_NOT_REALLY_EXTERN (decl)))
6488 DECL_INITIAL (decl) = init;
6490 /* A variable definition. */
6491 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6492 /* Initialize the local variable. */
6493 initialize_local_var (decl, init);
6495 /* If a variable is defined, and then a subsequent
6496 definition with external linkage is encountered, we will
6497 get here twice for the same variable. We want to avoid
6498 calling expand_static_init more than once. For variables
6499 that are not static data members, we can call
6500 expand_static_init only when we actually process the
6501 initializer. It is not legal to redeclare a static data
6502 member, so this issue does not arise in that case. */
6503 else if (var_definition_p && TREE_STATIC (decl))
6504 expand_static_init (decl, init);
6507 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6508 reference, insert it in the statement-tree now. */
6512 FOR_EACH_VEC_ELT (*cleanups, i, t)
6513 push_cleanup (decl, t, false);
6514 release_tree_vector (cleanups);
6518 TREE_READONLY (decl) = 1;
6520 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
6523 /* Returns a declaration for a VAR_DECL as if:
6525 extern "C" TYPE NAME;
6527 had been seen. Used to create compiler-generated global
6531 declare_global_var (tree name, tree type)
6535 push_to_top_level ();
6536 decl = build_decl (input_location, VAR_DECL, name, type);
6537 TREE_PUBLIC (decl) = 1;
6538 DECL_EXTERNAL (decl) = 1;
6539 DECL_ARTIFICIAL (decl) = 1;
6540 /* If the user has explicitly declared this variable (perhaps
6541 because the code we are compiling is part of a low-level runtime
6542 library), then it is possible that our declaration will be merged
6543 with theirs by pushdecl. */
6544 decl = pushdecl (decl);
6545 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
6546 pop_from_top_level ();
6551 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6552 if "__cxa_atexit" is not being used) corresponding to the function
6553 to be called when the program exits. */
6556 get_atexit_fn_ptr_type (void)
6560 if (!atexit_fn_ptr_type_node)
6563 if (flag_use_cxa_atexit
6564 && !targetm.cxx.use_atexit_for_cxa_atexit ())
6565 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6566 arg_type = ptr_type_node;
6568 /* The parameter to "atexit" is "void (*)(void)". */
6569 arg_type = NULL_TREE;
6571 fn_type = build_function_type_list (void_type_node,
6572 arg_type, NULL_TREE);
6573 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
6576 return atexit_fn_ptr_type_node;
6579 /* Returns a pointer to the `atexit' function. Note that if
6580 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6581 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6584 get_atexit_node (void)
6590 bool use_aeabi_atexit;
6595 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6597 /* The declaration for `__cxa_atexit' is:
6599 int __cxa_atexit (void (*)(void *), void *, void *)
6601 We build up the argument types and then the function type
6603 tree argtype0, argtype1, argtype2;
6605 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
6606 /* First, build the pointer-to-function type for the first
6608 fn_ptr_type = get_atexit_fn_ptr_type ();
6609 /* Then, build the rest of the argument types. */
6610 argtype2 = ptr_type_node;
6611 if (use_aeabi_atexit)
6613 argtype1 = fn_ptr_type;
6614 argtype0 = ptr_type_node;
6618 argtype1 = ptr_type_node;
6619 argtype0 = fn_ptr_type;
6621 /* And the final __cxa_atexit type. */
6622 fn_type = build_function_type_list (integer_type_node,
6623 argtype0, argtype1, argtype2,
6625 if (use_aeabi_atexit)
6626 name = "__aeabi_atexit";
6628 name = "__cxa_atexit";
6632 /* The declaration for `atexit' is:
6634 int atexit (void (*)());
6636 We build up the argument types and then the function type
6638 fn_ptr_type = get_atexit_fn_ptr_type ();
6639 /* Build the final atexit type. */
6640 fn_type = build_function_type_list (integer_type_node,
6641 fn_ptr_type, NULL_TREE);
6645 /* Now, build the function declaration. */
6646 push_lang_context (lang_name_c);
6647 atexit_fndecl = build_library_fn_ptr (name, fn_type);
6648 mark_used (atexit_fndecl);
6649 pop_lang_context ();
6650 atexit_node = decay_conversion (atexit_fndecl, tf_warning_or_error);
6655 /* Like get_atexit_node, but for thread-local cleanups. */
6658 get_thread_atexit_node (void)
6660 /* The declaration for `__cxa_thread_atexit' is:
6662 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6663 tree fn_type = build_function_type_list (integer_type_node,
6664 get_atexit_fn_ptr_type (),
6665 ptr_type_node, ptr_type_node,
6668 /* Now, build the function declaration. */
6669 tree atexit_fndecl = build_library_fn_ptr ("__cxa_thread_atexit", fn_type);
6670 return decay_conversion (atexit_fndecl, tf_warning_or_error);
6673 /* Returns the __dso_handle VAR_DECL. */
6676 get_dso_handle_node (void)
6678 if (dso_handle_node)
6679 return dso_handle_node;
6681 /* Declare the variable. */
6682 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6685 #ifdef HAVE_GAS_HIDDEN
6686 DECL_VISIBILITY (dso_handle_node) = VISIBILITY_HIDDEN;
6687 DECL_VISIBILITY_SPECIFIED (dso_handle_node) = 1;
6690 return dso_handle_node;
6693 /* Begin a new function with internal linkage whose job will be simply
6694 to destroy some particular variable. */
6696 static GTY(()) int start_cleanup_cnt;
6699 start_cleanup_fn (void)
6704 bool use_cxa_atexit = flag_use_cxa_atexit
6705 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6707 push_to_top_level ();
6709 /* No need to mangle this. */
6710 push_lang_context (lang_name_c);
6712 /* Build the name of the function. */
6713 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6714 /* Build the function declaration. */
6715 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6716 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6717 /* It's a function with internal linkage, generated by the
6719 TREE_PUBLIC (fndecl) = 0;
6720 DECL_ARTIFICIAL (fndecl) = 1;
6721 /* Make the function `inline' so that it is only emitted if it is
6722 actually needed. It is unlikely that it will be inlined, since
6723 it is only called via a function pointer, but we avoid unnecessary
6724 emissions this way. */
6725 DECL_DECLARED_INLINE_P (fndecl) = 1;
6726 DECL_INTERFACE_KNOWN (fndecl) = 1;
6727 /* Build the parameter. */
6732 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6733 DECL_CONTEXT (parmdecl) = fndecl;
6734 TREE_USED (parmdecl) = 1;
6735 DECL_READ_P (parmdecl) = 1;
6736 DECL_ARGUMENTS (fndecl) = parmdecl;
6740 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6742 pop_lang_context ();
6744 return current_function_decl;
6747 /* Finish the cleanup function begun by start_cleanup_fn. */
6750 end_cleanup_fn (void)
6752 expand_or_defer_fn (finish_function (0));
6754 pop_from_top_level ();
6757 /* Generate code to handle the destruction of DECL, an object with
6758 static storage duration. */
6761 register_dtor_fn (tree decl)
6768 bool ob_parm, dso_parm, use_dtor;
6769 tree arg0, arg1, arg2;
6772 type = TREE_TYPE (decl);
6773 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6774 return void_zero_node;
6776 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
6777 "__aeabi_atexit"), and DECL is a class object, we can just pass the
6778 destructor to "__cxa_atexit"; we don't have to build a temporary
6779 function to do the cleanup. */
6780 dso_parm = (flag_use_cxa_atexit
6781 && !targetm.cxx.use_atexit_for_cxa_atexit ());
6782 ob_parm = (DECL_THREAD_LOCAL_P (decl) || dso_parm);
6783 use_dtor = ob_parm && CLASS_TYPE_P (type);
6788 /* Find the destructor. */
6789 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6790 gcc_assert (idx >= 0);
6791 cleanup = (*CLASSTYPE_METHOD_VEC (type))[idx];
6792 /* Make sure it is accessible. */
6793 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup,
6794 tf_warning_or_error);
6798 /* Call build_cleanup before we enter the anonymous function so
6799 that any access checks will be done relative to the current
6800 scope, rather than the scope of the anonymous function. */
6801 build_cleanup (decl);
6803 /* Now start the function. */
6804 cleanup = start_cleanup_fn ();
6806 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6807 to the original function, rather than the anonymous one. That
6808 will make the back end think that nested functions are in use,
6809 which causes confusion. */
6810 push_deferring_access_checks (dk_no_check);
6811 fcall = build_cleanup (decl);
6812 pop_deferring_access_checks ();
6814 /* Create the body of the anonymous function. */
6815 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6816 finish_expr_stmt (fcall);
6817 finish_compound_stmt (compound_stmt);
6821 /* Call atexit with the cleanup function. */
6822 mark_used (cleanup);
6823 cleanup = build_address (cleanup);
6825 if (DECL_THREAD_LOCAL_P (decl))
6826 atex_node = get_thread_atexit_node ();
6828 atex_node = get_atexit_node ();
6832 /* We must convert CLEANUP to the type that "__cxa_atexit"
6834 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6835 /* "__cxa_atexit" will pass the address of DECL to the
6836 cleanup function. */
6838 addr = build_address (decl);
6839 /* The declared type of the parameter to "__cxa_atexit" is
6840 "void *". For plain "T*", we could just let the
6841 machinery in cp_build_function_call convert it -- but if the
6842 type is "cv-qualified T *", then we need to convert it
6843 before passing it in, to avoid spurious errors. */
6844 addr = build_nop (ptr_type_node, addr);
6847 /* Since the cleanup functions we build ignore the address
6848 they're given, there's no reason to pass the actual address
6849 in, and, in general, it's cheaper to pass NULL than any
6851 addr = null_pointer_node;
6854 arg2 = cp_build_addr_expr (get_dso_handle_node (),
6855 tf_warning_or_error);
6857 /* Just pass NULL to the dso handle parm if we don't actually
6858 have a DSO handle on this target. */
6859 arg2 = null_pointer_node;
6865 if (!DECL_THREAD_LOCAL_P (decl)
6866 && targetm.cxx.use_aeabi_atexit ())
6882 return cp_build_function_call_nary (atex_node, tf_warning_or_error,
6883 arg0, arg1, arg2, NULL_TREE);
6886 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6887 is its initializer. Generate code to handle the construction
6888 and destruction of DECL. */
6891 expand_static_init (tree decl, tree init)
6893 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6894 gcc_assert (TREE_STATIC (decl));
6896 /* Some variables require no dynamic initialization. */
6898 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6901 if (DECL_THREAD_LOCAL_P (decl) && DECL_GNU_TLS_P (decl)
6902 && !DECL_FUNCTION_SCOPE_P (decl))
6905 error ("non-local variable %qD declared %<__thread%> "
6906 "needs dynamic initialization", decl);
6908 error ("non-local variable %qD declared %<__thread%> "
6909 "has a non-trivial destructor", decl);
6910 static bool informed;
6913 inform (DECL_SOURCE_LOCATION (decl),
6914 "C++11 %<thread_local%> allows dynamic initialization "
6921 if (DECL_FUNCTION_SCOPE_P (decl))
6923 /* Emit code to perform this initialization but once. */
6924 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6925 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6926 tree guard, guard_addr;
6928 /* We don't need thread-safety code for thread-local vars. */
6929 bool thread_guard = (flag_threadsafe_statics
6930 && !DECL_THREAD_LOCAL_P (decl));
6932 /* Emit code to perform this initialization but once. This code
6935 static <type> guard;
6936 if (!guard.first_byte) {
6937 if (__cxa_guard_acquire (&guard)) {
6940 // Do initialization.
6941 flag = true; __cxa_guard_release (&guard);
6942 // Register variable for destruction at end of program.
6944 if (!flag) __cxa_guard_abort (&guard);
6948 Note that the `flag' variable is only set to 1 *after* the
6949 initialization is complete. This ensures that an exception,
6950 thrown during the construction, will cause the variable to
6951 reinitialized when we pass through this code again, as per:
6955 If the initialization exits by throwing an exception, the
6956 initialization is not complete, so it will be tried again
6957 the next time control enters the declaration.
6959 This process should be thread-safe, too; multiple threads
6960 should not be able to initialize the variable more than
6963 /* Create the guard variable. */
6964 guard = get_guard (decl);
6966 /* This optimization isn't safe on targets with relaxed memory
6967 consistency. On such targets we force synchronization in
6968 __cxa_guard_acquire. */
6969 if (!targetm.relaxed_ordering || !thread_guard)
6971 /* Begin the conditional initialization. */
6972 if_stmt = begin_if_stmt ();
6973 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6974 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6979 tree vfntype = NULL_TREE;
6980 tree acquire_name, release_name, abort_name;
6981 tree acquire_fn, release_fn, abort_fn;
6982 guard_addr = build_address (guard);
6984 acquire_name = get_identifier ("__cxa_guard_acquire");
6985 release_name = get_identifier ("__cxa_guard_release");
6986 abort_name = get_identifier ("__cxa_guard_abort");
6987 acquire_fn = identifier_global_value (acquire_name);
6988 release_fn = identifier_global_value (release_name);
6989 abort_fn = identifier_global_value (abort_name);
6991 acquire_fn = push_library_fn
6992 (acquire_name, build_function_type_list (integer_type_node,
6993 TREE_TYPE (guard_addr),
6996 if (!release_fn || !abort_fn)
6997 vfntype = build_function_type_list (void_type_node,
6998 TREE_TYPE (guard_addr),
7001 release_fn = push_library_fn (release_name, vfntype, NULL_TREE);
7003 abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE);
7005 inner_if_stmt = begin_if_stmt ();
7006 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
7009 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
7010 begin = get_target_expr (boolean_false_node);
7011 flag = TARGET_EXPR_SLOT (begin);
7013 TARGET_EXPR_CLEANUP (begin)
7014 = build3 (COND_EXPR, void_type_node, flag,
7016 build_call_n (abort_fn, 1, guard_addr));
7017 CLEANUP_EH_ONLY (begin) = 1;
7019 /* Do the initialization itself. */
7020 init = add_stmt_to_compound (begin, init);
7021 init = add_stmt_to_compound
7022 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
7023 init = add_stmt_to_compound
7024 (init, build_call_n (release_fn, 1, guard_addr));
7027 init = add_stmt_to_compound (init, set_guard (guard));
7029 /* Use atexit to register a function for destroying this static
7031 init = add_stmt_to_compound (init, register_dtor_fn (decl));
7033 finish_expr_stmt (init);
7037 finish_compound_stmt (inner_then_clause);
7038 finish_then_clause (inner_if_stmt);
7039 finish_if_stmt (inner_if_stmt);
7042 if (!targetm.relaxed_ordering || !thread_guard)
7044 finish_compound_stmt (then_clause);
7045 finish_then_clause (if_stmt);
7046 finish_if_stmt (if_stmt);
7049 else if (DECL_THREAD_LOCAL_P (decl))
7050 tls_aggregates = tree_cons (init, decl, tls_aggregates);
7052 static_aggregates = tree_cons (init, decl, static_aggregates);
7056 /* Make TYPE a complete type based on INITIAL_VALUE.
7057 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7058 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7059 3 if the initializer list is empty (in pedantic mode). */
7062 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
7065 tree type, elt_type;
7069 unsigned HOST_WIDE_INT i;
7072 /* An array of character type can be initialized from a
7073 brace-enclosed string constant.
7075 FIXME: this code is duplicated from reshape_init. Probably
7076 we should just call reshape_init here? */
7077 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
7078 && TREE_CODE (initial_value) == CONSTRUCTOR
7079 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value)))
7081 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value);
7082 tree value = (*v)[0].value;
7084 if (TREE_CODE (value) == STRING_CST
7085 && v->length () == 1)
7086 initial_value = value;
7089 /* If any of the elements are parameter packs, we can't actually
7090 complete this type now because the array size is dependent. */
7091 if (TREE_CODE (initial_value) == CONSTRUCTOR)
7093 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
7096 if (PACK_EXPANSION_P (value))
7102 failure = complete_array_type (ptype, initial_value, do_default);
7104 /* We can create the array before the element type is complete, which
7105 means that we didn't have these two bits set in the original type
7106 either. In completing the type, we are expected to propagate these
7107 bits. See also complete_type which does the same thing for arrays
7110 if (TYPE_DOMAIN (type))
7112 elt_type = TREE_TYPE (type);
7113 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
7114 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7115 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
7121 /* As above, but either give an error or reject zero-size arrays, depending
7125 cp_complete_array_type_or_error (tree *ptype, tree initial_value,
7126 bool do_default, tsubst_flags_t complain)
7129 bool sfinae = !(complain & tf_error);
7130 /* In SFINAE context we can't be lenient about zero-size arrays. */
7133 failure = cp_complete_array_type (ptype, initial_value, do_default);
7139 /* Not an error. */;
7140 else if (failure == 1)
7141 error ("initializer fails to determine size of %qT", *ptype);
7142 else if (failure == 2)
7145 error ("array size missing in %qT", *ptype);
7147 else if (failure == 3)
7148 error ("zero-size array %qT", *ptype);
7149 *ptype = error_mark_node;
7154 /* Return zero if something is declared to be a member of type
7155 CTYPE when in the context of CUR_TYPE. STRING is the error
7156 message to print in that case. Otherwise, quietly return 1. */
7159 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
7161 if (ctype && ctype != cur_type)
7163 if (flags == DTOR_FLAG)
7164 error ("destructor for alien class %qT cannot be a member", ctype);
7166 error ("constructor for alien class %qT cannot be a member", ctype);
7172 /* Subroutine of `grokdeclarator'. */
7174 /* Generate errors possibly applicable for a given set of specifiers.
7175 This is for ARM $7.1.2. */
7178 bad_specifiers (tree object,
7179 enum bad_spec_place type,
7190 error ("%qD declared as a %<virtual%> variable", object);
7192 error ("%qD declared as an %<inline%> variable", object);
7194 error ("%<const%> and %<volatile%> function specifiers on "
7195 "%qD invalid in variable declaration", object);
7199 error ("%qD declared as a %<virtual%> parameter", object);
7201 error ("%qD declared as an %<inline%> parameter", object);
7203 error ("%<const%> and %<volatile%> function specifiers on "
7204 "%qD invalid in parameter declaration", object);
7208 error ("%qD declared as a %<virtual%> type", object);
7210 error ("%qD declared as an %<inline%> type", object);
7212 error ("%<const%> and %<volatile%> function specifiers on "
7213 "%qD invalid in type declaration", object);
7217 error ("%qD declared as a %<virtual%> field", object);
7219 error ("%qD declared as an %<inline%> field", object);
7221 error ("%<const%> and %<volatile%> function specifiers on "
7222 "%qD invalid in field declaration", object);
7228 error ("%q+D declared as a friend", object);
7230 && (TREE_CODE (object) == TYPE_DECL
7231 || (!TYPE_PTRFN_P (TREE_TYPE (object))
7232 && !TYPE_REFFN_P (TREE_TYPE (object))
7233 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
7234 error ("%q+D declared with an exception specification", object);
7237 /* DECL is a member function or static data member and is presently
7238 being defined. Check that the definition is taking place in a
7242 check_class_member_definition_namespace (tree decl)
7244 /* These checks only apply to member functions and static data
7246 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
7247 || TREE_CODE (decl) == VAR_DECL);
7248 /* We check for problems with specializations in pt.c in
7249 check_specialization_namespace, where we can issue better
7251 if (processing_specialization)
7253 /* There are no restrictions on the placement of
7254 explicit instantiations. */
7255 if (processing_explicit_instantiation)
7259 A member function definition that appears outside of the
7260 class definition shall appear in a namespace scope enclosing
7261 the class definition.
7265 The definition for a static data member shall appear in a
7266 namespace scope enclosing the member's class definition. */
7267 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
7268 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
7269 decl, DECL_CONTEXT (decl));
7272 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7273 METHOD_TYPE for a non-static member function; QUALS are the
7274 cv-qualifiers that apply to the function. */
7277 build_this_parm (tree type, cp_cv_quals quals)
7282 cp_cv_quals this_quals;
7284 if (CLASS_TYPE_P (type))
7287 = cp_build_qualified_type (type, quals & ~TYPE_QUAL_RESTRICT);
7288 this_type = build_pointer_type (this_type);
7291 this_type = type_of_this_parm (type);
7292 /* The `this' parameter is implicitly `const'; it cannot be
7294 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
7295 qual_type = cp_build_qualified_type (this_type, this_quals);
7296 parm = build_artificial_parm (this_identifier, qual_type);
7297 cp_apply_type_quals_to_decl (this_quals, parm);
7301 /* DECL is a static member function. Complain if it was declared
7302 with function-cv-quals. */
7305 check_static_quals (tree decl, cp_cv_quals quals)
7307 if (quals != TYPE_UNQUALIFIED)
7308 error ("static member function %q#D declared with type qualifiers",
7312 /* CTYPE is class type, or null if non-class.
7313 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7315 DECLARATOR is the function's name.
7316 PARMS is a chain of PARM_DECLs for the function.
7317 VIRTUALP is truthvalue of whether the function is virtual or not.
7318 FLAGS are to be passed through to `grokclassfn'.
7319 QUALS are qualifiers indicating whether the function is `const'
7321 RAISES is a list of exceptions that this function can raise.
7322 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7323 not look, and -1 if we should not call `grokclassfn' at all.
7325 SFK is the kind of special function (if any) for the new function.
7327 Returns `NULL_TREE' if something goes wrong, after issuing
7328 applicable error messages. */
7331 grokfndecl (tree ctype,
7335 tree orig_declarator,
7337 enum overload_flags flags,
7339 cp_ref_qualifier rqual,
7345 special_function_kind sfk,
7350 location_t location)
7353 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
7357 type = build_ref_qualified_type (type, rqual);
7359 type = build_exception_variant (type, raises);
7361 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
7363 /* If we have an explicit location, use it, otherwise use whatever
7364 build_lang_decl used (probably input_location). */
7365 if (location != UNKNOWN_LOCATION)
7366 DECL_SOURCE_LOCATION (decl) = location;
7368 if (TREE_CODE (type) == METHOD_TYPE)
7371 parm = build_this_parm (type, quals);
7372 DECL_CHAIN (parm) = parms;
7375 DECL_ARGUMENTS (decl) = parms;
7376 for (t = parms; t; t = DECL_CHAIN (t))
7377 DECL_CONTEXT (t) = decl;
7378 /* Propagate volatile out from type to decl. */
7379 if (TYPE_VOLATILE (type))
7380 TREE_THIS_VOLATILE (decl) = 1;
7382 /* Setup decl according to sfk. */
7385 case sfk_constructor:
7386 case sfk_copy_constructor:
7387 case sfk_move_constructor:
7388 DECL_CONSTRUCTOR_P (decl) = 1;
7390 case sfk_destructor:
7391 DECL_DESTRUCTOR_P (decl) = 1;
7397 /* If pointers to member functions use the least significant bit to
7398 indicate whether a function is virtual, ensure a pointer
7399 to this function will have that bit clear. */
7400 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
7401 && TREE_CODE (type) == METHOD_TYPE
7402 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
7403 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
7406 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7410 ("defining explicit specialization %qD in friend declaration",
7414 tree fns = TREE_OPERAND (orig_declarator, 0);
7415 tree args = TREE_OPERAND (orig_declarator, 1);
7417 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7419 /* Something like `template <class T> friend void f<T>()'. */
7420 error ("invalid use of template-id %qD in declaration "
7421 "of primary template",
7427 /* A friend declaration of the form friend void f<>(). Record
7428 the information in the TEMPLATE_ID_EXPR. */
7429 SET_DECL_IMPLICIT_INSTANTIATION (decl);
7431 if (TREE_CODE (fns) == COMPONENT_REF)
7433 /* Due to bison parser ickiness, we will have already looked
7434 up an operator_name or PFUNCNAME within the current class
7435 (see template_id in parse.y). If the current class contains
7436 such a name, we'll get a COMPONENT_REF here. Undo that. */
7438 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
7439 == current_class_type);
7440 fns = TREE_OPERAND (fns, 1);
7442 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
7443 || TREE_CODE (fns) == OVERLOAD);
7444 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
7446 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7447 if (TREE_PURPOSE (t)
7448 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7450 error ("default arguments are not allowed in declaration "
7451 "of friend template specialization %qD",
7458 error ("%<inline%> is not allowed in declaration of friend "
7459 "template specialization %qD",
7466 /* If this decl has namespace scope, set that up. */
7468 set_decl_namespace (decl, in_namespace, friendp);
7470 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
7472 /* `main' and builtins have implicit 'C' linkage. */
7473 if ((MAIN_NAME_P (declarator)
7474 || (IDENTIFIER_LENGTH (declarator) > 10
7475 && IDENTIFIER_POINTER (declarator)[0] == '_'
7476 && IDENTIFIER_POINTER (declarator)[1] == '_'
7477 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
7478 && current_lang_name == lang_name_cplusplus
7479 && ctype == NULL_TREE
7480 && DECL_FILE_SCOPE_P (decl))
7481 SET_DECL_LANGUAGE (decl, lang_c);
7483 /* Should probably propagate const out from type to decl I bet (mrs). */
7486 DECL_STATIC_FUNCTION_P (decl) = 1;
7487 DECL_CONTEXT (decl) = ctype;
7492 DECL_CONTEXT (decl) = ctype;
7494 check_class_member_definition_namespace (decl);
7497 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7499 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7500 error ("cannot declare %<::main%> to be a template");
7502 error ("cannot declare %<::main%> to be inline");
7504 error ("cannot declare %<::main%> to be static");
7509 /* Members of anonymous types and local classes have no linkage; make
7510 them internal. If a typedef is made later, this will be changed. */
7511 if (ctype && (TYPE_ANONYMOUS_P (ctype)
7512 || decl_function_context (TYPE_MAIN_DECL (ctype))))
7515 if (publicp && cxx_dialect == cxx98)
7517 /* [basic.link]: A name with no linkage (notably, the name of a class
7518 or enumeration declared in a local scope) shall not be used to
7519 declare an entity with linkage.
7521 DR 757 relaxes this restriction for C++0x. */
7522 t = no_linkage_check (TREE_TYPE (decl),
7523 /*relaxed_p=*/false);
7526 if (TYPE_ANONYMOUS_P (t))
7528 if (DECL_EXTERN_C_P (decl))
7529 /* Allow this; it's pretty common in C. */;
7532 permerror (input_location, "anonymous type with no linkage "
7533 "used to declare function %q#D with linkage",
7535 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7536 permerror (input_location, "%q+#D does not refer to the unqualified "
7537 "type, so it is not used for linkage",
7542 permerror (input_location, "type %qT with no linkage used to "
7543 "declare function %q#D with linkage", t, decl);
7547 TREE_PUBLIC (decl) = publicp;
7550 DECL_INTERFACE_KNOWN (decl) = 1;
7551 DECL_NOT_REALLY_EXTERN (decl) = 1;
7554 /* If the declaration was declared inline, mark it as such. */
7556 DECL_DECLARED_INLINE_P (decl) = 1;
7558 DECL_DECLARED_CONSTEXPR_P (decl) = true;
7560 DECL_EXTERNAL (decl) = 1;
7561 if (TREE_CODE (type) == FUNCTION_TYPE)
7566 ? G_("static member function %qD cannot have cv-qualifier")
7567 : G_("non-member function %qD cannot have cv-qualifier"),
7569 quals = TYPE_UNQUALIFIED;
7575 ? G_("static member function %qD cannot have ref-qualifier")
7576 : G_("non-member function %qD cannot have ref-qualifier"),
7578 rqual = REF_QUAL_NONE;
7582 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
7583 && !grok_op_properties (decl, /*complain=*/true))
7585 else if (UDLIT_OPER_P (DECL_NAME (decl)))
7587 bool long_long_unsigned_p;
7589 const char *suffix = NULL;
7590 /* [over.literal]/6: Literal operators shall not have C linkage. */
7591 if (DECL_LANGUAGE (decl) == lang_c)
7593 error ("literal operator with C linkage");
7597 if (DECL_NAMESPACE_SCOPE_P (decl))
7599 if (!check_literal_operator_args (decl, &long_long_unsigned_p,
7602 error ("%qD has invalid argument list", decl);
7606 suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl));
7607 if (long_long_unsigned_p)
7609 if (cpp_interpret_int_suffix (parse_in, suffix, strlen (suffix)))
7610 warning (0, "integer suffix %<%s%>"
7611 " shadowed by implementation", suffix);
7613 else if (long_double_p)
7615 if (cpp_interpret_float_suffix (parse_in, suffix, strlen (suffix)))
7616 warning (0, "floating point suffix %<%s%>"
7617 " shadowed by implementation", suffix);
7622 error ("%qD must be a non-member function", decl);
7628 /* Make the init_value nonzero so pushdecl knows this is not
7629 tentative. error_mark_node is replaced later with the BLOCK. */
7630 DECL_INITIAL (decl) = error_mark_node;
7632 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
7633 TREE_NOTHROW (decl) = 1;
7635 /* Caller will do the rest of this. */
7639 if (ctype != NULL_TREE)
7640 grokclassfn (ctype, decl, flags);
7643 if (cxx_dialect >= cxx0x
7644 && DECL_DESTRUCTOR_P (decl)
7645 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl))
7646 && !processing_template_decl)
7647 deduce_noexcept_on_destructor (decl);
7649 decl = check_explicit_specialization (orig_declarator, decl,
7652 4 * (friendp != 0));
7653 if (decl == error_mark_node)
7656 if (DECL_STATIC_FUNCTION_P (decl))
7657 check_static_quals (decl, quals);
7661 cplus_decl_attributes (&decl, *attrlist, 0);
7662 *attrlist = NULL_TREE;
7665 /* Check main's type after attributes have been applied. */
7666 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7668 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
7671 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
7673 error ("%<::main%> must return %<int%>");
7674 newtype = build_function_type (integer_type_node, oldtypeargs);
7675 TREE_TYPE (decl) = newtype;
7678 check_main_parameter_types (decl);
7681 if (ctype != NULL_TREE
7682 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
7685 tree old_decl = check_classfn (ctype, decl,
7686 (processing_template_decl
7687 > template_class_depth (ctype))
7688 ? current_template_parms
7691 if (old_decl == error_mark_node)
7699 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
7700 /* Because grokfndecl is always supposed to return a
7701 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7702 here. We depend on our callers to figure out that its
7703 really a template that's being returned. */
7704 old_decl = DECL_TEMPLATE_RESULT (old_decl);
7706 if (DECL_STATIC_FUNCTION_P (old_decl)
7707 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
7709 /* Remove the `this' parm added by grokclassfn. */
7710 revert_static_member_fn (decl);
7711 check_static_quals (decl, quals);
7713 if (DECL_ARTIFICIAL (old_decl))
7715 error ("definition of implicitly-declared %qD", old_decl);
7718 else if (DECL_DEFAULTED_FN (old_decl))
7720 error ("definition of explicitly-defaulted %q+D", decl);
7721 error ("%q+#D explicitly defaulted here", old_decl);
7725 /* Since we've smashed OLD_DECL to its
7726 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7727 if (TREE_CODE (decl) == TEMPLATE_DECL)
7728 decl = DECL_TEMPLATE_RESULT (decl);
7730 /* Attempt to merge the declarations. This can fail, in
7731 the case of some invalid specialization declarations. */
7732 pushed_scope = push_scope (ctype);
7733 ok = duplicate_decls (decl, old_decl, friendp);
7735 pop_scope (pushed_scope);
7738 error ("no %q#D member function declared in class %qT",
7746 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
7749 if (ctype == NULL_TREE || check)
7753 DECL_VIRTUAL_P (decl) = 1;
7758 /* decl is a FUNCTION_DECL.
7759 specifiers are the parsed virt-specifiers.
7761 Set flags to reflect the virt-specifiers.
7766 set_virt_specifiers (tree decl, cp_virt_specifiers specifiers)
7768 if (decl == NULL_TREE)
7770 if (specifiers & VIRT_SPEC_OVERRIDE)
7771 DECL_OVERRIDE_P (decl) = 1;
7772 if (specifiers & VIRT_SPEC_FINAL)
7773 DECL_FINAL_P (decl) = 1;
7777 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7778 the linkage that DECL will receive in the object file. */
7781 set_linkage_for_static_data_member (tree decl)
7783 /* A static data member always has static storage duration and
7784 external linkage. Note that static data members are forbidden in
7785 local classes -- the only situation in which a class has
7786 non-external linkage. */
7787 TREE_PUBLIC (decl) = 1;
7788 TREE_STATIC (decl) = 1;
7789 /* For non-template classes, static data members are always put
7790 out in exactly those files where they are defined, just as
7791 with ordinary namespace-scope variables. */
7792 if (!processing_template_decl)
7793 DECL_INTERFACE_KNOWN (decl) = 1;
7796 /* Create a VAR_DECL named NAME with the indicated TYPE.
7798 If SCOPE is non-NULL, it is the class type or namespace containing
7799 the variable. If SCOPE is NULL, the variable should is created in
7800 the innermost enclosings scope. */
7803 grokvardecl (tree type,
7805 const cp_decl_specifier_seq *declspecs,
7811 tree explicit_scope;
7813 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
7815 /* Compute the scope in which to place the variable, but remember
7816 whether or not that scope was explicitly specified by the user. */
7817 explicit_scope = scope;
7820 /* An explicit "extern" specifier indicates a namespace-scope
7822 if (declspecs->storage_class == sc_extern)
7823 scope = current_decl_namespace ();
7824 else if (!at_function_scope_p ())
7825 scope = current_scope ();
7829 && (/* If the variable is a namespace-scope variable declared in a
7830 template, we need DECL_LANG_SPECIFIC. */
7831 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
7832 /* Similarly for namespace-scope variables with language linkage
7834 || (TREE_CODE (scope) == NAMESPACE_DECL
7835 && current_lang_name != lang_name_cplusplus)
7836 /* Similarly for static data members. */
7838 decl = build_lang_decl (VAR_DECL, name, type);
7840 decl = build_decl (input_location, VAR_DECL, name, type);
7842 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
7843 set_decl_namespace (decl, explicit_scope, 0);
7845 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
7847 if (declspecs->storage_class == sc_extern)
7849 DECL_THIS_EXTERN (decl) = 1;
7850 DECL_EXTERNAL (decl) = !initialized;
7853 if (DECL_CLASS_SCOPE_P (decl))
7855 set_linkage_for_static_data_member (decl);
7856 /* This function is only called with out-of-class definitions. */
7857 DECL_EXTERNAL (decl) = 0;
7858 check_class_member_definition_namespace (decl);
7860 /* At top level, either `static' or no s.c. makes a definition
7861 (perhaps tentative), and absence of `static' makes it public. */
7862 else if (toplevel_bindings_p ())
7864 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
7865 && (DECL_THIS_EXTERN (decl) || ! constp));
7866 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
7868 /* Not at top level, only `static' makes a static definition. */
7871 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
7872 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
7875 if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
7877 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
7878 if (declspecs->gnu_thread_keyword_p)
7879 DECL_GNU_TLS_P (decl) = true;
7882 /* If the type of the decl has no linkage, make sure that we'll
7883 notice that in mark_used. */
7884 if (cxx_dialect > cxx98
7885 && decl_linkage (decl) != lk_none
7886 && DECL_LANG_SPECIFIC (decl) == NULL
7887 && !DECL_EXTERN_C_P (decl)
7888 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
7889 retrofit_lang_decl (decl);
7891 if (TREE_PUBLIC (decl))
7893 /* [basic.link]: A name with no linkage (notably, the name of a class
7894 or enumeration declared in a local scope) shall not be used to
7895 declare an entity with linkage.
7897 DR 757 relaxes this restriction for C++0x. */
7898 tree t = (cxx_dialect > cxx98 ? NULL_TREE
7899 : no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false));
7902 if (TYPE_ANONYMOUS_P (t))
7904 if (DECL_EXTERN_C_P (decl))
7905 /* Allow this; it's pretty common in C. */
7909 /* DRs 132, 319 and 389 seem to indicate types with
7910 no linkage can only be used to declare extern "C"
7911 entities. Since it's not always an error in the
7912 ISO C++ 90 Standard, we only issue a warning. */
7913 warning (0, "anonymous type with no linkage used to declare "
7914 "variable %q#D with linkage", decl);
7915 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7916 warning (0, "%q+#D does not refer to the unqualified "
7917 "type, so it is not used for linkage",
7922 warning (0, "type %qT with no linkage used to declare variable "
7923 "%q#D with linkage", t, decl);
7927 DECL_INTERFACE_KNOWN (decl) = 1;
7932 /* Create and return a canonical pointer to member function type, for
7933 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7936 build_ptrmemfunc_type (tree type)
7940 tree unqualified_variant = NULL_TREE;
7942 if (type == error_mark_node)
7945 /* If a canonical type already exists for this type, use it. We use
7946 this method instead of type_hash_canon, because it only does a
7947 simple equality check on the list of field members. */
7949 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7952 /* Make sure that we always have the unqualified pointer-to-member
7954 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7956 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7958 t = make_class_type (RECORD_TYPE);
7959 xref_basetypes (t, NULL_TREE);
7961 /* Let the front end know this is a pointer to member function... */
7962 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7963 /* ... and not really a class type. */
7964 SET_CLASS_TYPE_P (t, 0);
7966 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
7969 field = build_decl (input_location, FIELD_DECL, delta_identifier,
7971 DECL_CHAIN (field) = fields;
7974 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7976 /* Zap out the name so that the back end will give us the debugging
7977 information for this anonymous RECORD_TYPE. */
7978 TYPE_NAME (t) = NULL_TREE;
7980 /* If this is not the unqualified form of this pointer-to-member
7981 type, set the TYPE_MAIN_VARIANT for this type to be the
7982 unqualified type. Since they are actually RECORD_TYPEs that are
7983 not variants of each other, we must do this manually.
7984 As we just built a new type there is no need to do yet another copy. */
7985 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7987 int type_quals = cp_type_quals (type);
7988 TYPE_READONLY (t) = (type_quals & TYPE_QUAL_CONST) != 0;
7989 TYPE_VOLATILE (t) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
7990 TYPE_RESTRICT (t) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
7991 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7992 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7993 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7994 TREE_TYPE (TYPE_BINFO (t)) = t;
7997 /* Cache this pointer-to-member type so that we can find it again
7999 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8001 if (TYPE_STRUCTURAL_EQUALITY_P (type))
8002 SET_TYPE_STRUCTURAL_EQUALITY (t);
8003 else if (TYPE_CANONICAL (type) != type)
8004 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
8009 /* Create and return a pointer to data member type. */
8012 build_ptrmem_type (tree class_type, tree member_type)
8014 if (TREE_CODE (member_type) == METHOD_TYPE)
8016 cp_cv_quals quals = type_memfn_quals (member_type);
8017 cp_ref_qualifier rqual = type_memfn_rqual (member_type);
8018 member_type = build_memfn_type (member_type, class_type, quals, rqual);
8019 return build_ptrmemfunc_type (build_pointer_type (member_type));
8023 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
8024 return build_offset_type (class_type, member_type);
8028 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8029 Check to see that the definition is valid. Issue appropriate error
8030 messages. Return 1 if the definition is particularly bad, or 0
8034 check_static_variable_definition (tree decl, tree type)
8036 /* Can't check yet if we don't know the type. */
8037 if (dependent_type_p (type))
8039 /* If DECL is declared constexpr, we'll do the appropriate checks
8040 in check_initializer. */
8041 if (DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
8043 else if (cxx_dialect >= cxx0x && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
8045 if (!COMPLETE_TYPE_P (type))
8046 error ("in-class initialization of static data member %q#D of "
8047 "incomplete type", decl);
8048 else if (literal_type_p (type))
8049 permerror (input_location,
8050 "%<constexpr%> needed for in-class initialization of "
8051 "static data member %q#D of non-integral type", decl);
8053 error ("in-class initialization of static data member %q#D of "
8054 "non-literal type", decl);
8058 /* Motion 10 at San Diego: If a static const integral data member is
8059 initialized with an integral constant expression, the initializer
8060 may appear either in the declaration (within the class), or in
8061 the definition, but not both. If it appears in the class, the
8062 member is a member constant. The file-scope definition is always
8064 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
8066 error ("invalid in-class initialization of static data member "
8067 "of non-integral type %qT",
8071 else if (!CP_TYPE_CONST_P (type))
8072 error ("ISO C++ forbids in-class initialization of non-const "
8073 "static member %qD",
8075 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
8076 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids initialization of member constant "
8077 "%qD of non-integral type %qT", decl, type);
8082 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8083 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8084 expressions out into temporary variables so that walk_tree doesn't
8085 step into them (c++/15764). */
8088 stabilize_save_expr_r (tree *expr_p, int *walk_subtrees, void *data)
8090 struct pointer_set_t *pset = (struct pointer_set_t *)data;
8091 tree expr = *expr_p;
8092 if (TREE_CODE (expr) == SAVE_EXPR)
8094 tree op = TREE_OPERAND (expr, 0);
8095 cp_walk_tree (&op, stabilize_save_expr_r, data, pset);
8096 if (TREE_SIDE_EFFECTS (op))
8097 TREE_OPERAND (expr, 0) = get_temp_regvar (TREE_TYPE (op), op);
8100 else if (!EXPR_P (expr) || !TREE_SIDE_EFFECTS (expr))
8105 /* Entry point for the above. */
8108 stabilize_vla_size (tree size)
8110 struct pointer_set_t *pset = pointer_set_create ();
8111 /* Break out any function calls into temporary variables. */
8112 cp_walk_tree (&size, stabilize_save_expr_r, pset, pset);
8113 pointer_set_destroy (pset);
8116 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8117 not inside of SAVE_EXPR and fold them. */
8120 fold_sizeof_expr_r (tree *expr_p, int *walk_subtrees, void *data)
8122 tree expr = *expr_p;
8123 if (TREE_CODE (expr) == SAVE_EXPR || TYPE_P (expr))
8125 else if (TREE_CODE (expr) == SIZEOF_EXPR)
8127 *(bool *)data = true;
8128 if (SIZEOF_EXPR_TYPE_P (expr))
8129 expr = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr, 0)),
8130 SIZEOF_EXPR, false);
8131 else if (TYPE_P (TREE_OPERAND (expr, 0)))
8132 expr = cxx_sizeof_or_alignof_type (TREE_OPERAND (expr, 0), SIZEOF_EXPR,
8135 expr = cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr, 0), SIZEOF_EXPR,
8137 if (expr == error_mark_node)
8138 expr = size_one_node;
8145 /* Given the SIZE (i.e., number of elements) in an array, compute an
8146 appropriate index type for the array. If non-NULL, NAME is the
8147 name of the thing being declared. */
8150 compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
8154 tree abi_1_itype = NULL_TREE;
8156 if (error_operand_p (size))
8157 return error_mark_node;
8159 if (!type_dependent_expression_p (size))
8161 tree type = TREE_TYPE (size);
8163 mark_rvalue_use (size);
8165 if (cxx_dialect < cxx0x && TREE_CODE (size) == NOP_EXPR
8166 && TREE_SIDE_EFFECTS (size))
8167 /* In C++98, we mark a non-constant array bound with a magic
8168 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8171 size = fold_non_dependent_expr_sfinae (size, complain);
8173 if (CLASS_TYPE_P (type)
8174 && CLASSTYPE_LITERAL_P (type))
8176 size = build_expr_type_conversion (WANT_INT, size, true);
8179 if (!(complain & tf_error))
8180 return error_mark_node;
8182 error ("size of array %qD has non-integral type %qT",
8185 error ("size of array has non-integral type %qT", type);
8186 size = integer_one_node;
8188 if (size == error_mark_node)
8189 return error_mark_node;
8190 type = TREE_TYPE (size);
8191 /* We didn't support this case in GCC 3.2, so don't bother
8192 trying to model it now in ABI v1. */
8193 abi_1_itype = error_mark_node;
8196 size = maybe_constant_value (size);
8197 if (!TREE_CONSTANT (size))
8201 if (error_operand_p (size))
8202 return error_mark_node;
8204 /* The array bound must be an integer type. */
8205 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
8207 if (!(complain & tf_error))
8208 return error_mark_node;
8210 error ("size of array %qD has non-integral type %qT", name, type);
8212 error ("size of array has non-integral type %qT", type);
8213 size = integer_one_node;
8214 type = TREE_TYPE (size);
8218 /* A type is dependent if it is...an array type constructed from any
8219 dependent type or whose size is specified by a constant expression
8220 that is value-dependent. */
8221 /* We can only call value_dependent_expression_p on integral constant
8222 expressions; treat non-constant expressions as dependent, too. */
8223 if (processing_template_decl
8224 && (type_dependent_expression_p (size)
8225 || !TREE_CONSTANT (size) || value_dependent_expression_p (size)))
8227 /* We cannot do any checking for a SIZE that isn't known to be
8228 constant. Just build the index type and mark that it requires
8229 structural equality checks. */
8230 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8231 size, integer_one_node));
8232 TYPE_DEPENDENT_P (itype) = 1;
8233 TYPE_DEPENDENT_P_VALID (itype) = 1;
8234 SET_TYPE_STRUCTURAL_EQUALITY (itype);
8238 if (!abi_version_at_least (2) && processing_template_decl
8239 && abi_1_itype == NULL_TREE)
8240 /* For abi-1, we handled all instances in templates the same way,
8241 even when they were non-dependent. This affects the manglings
8242 produced. So, we do the normal checking for non-dependent
8243 sizes, but at the end we'll return the same type that abi-1
8244 would have, but with TYPE_CANONICAL set to the "right"
8245 value that the current ABI would provide. */
8246 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8247 osize, integer_one_node));
8249 /* Normally, the array-bound will be a constant. */
8250 if (TREE_CODE (size) == INTEGER_CST)
8252 /* Check to see if the array bound overflowed. Make that an
8253 error, no matter how generous we're being. */
8254 constant_expression_error (size);
8256 /* An array must have a positive number of elements. */
8257 if (INT_CST_LT (size, integer_zero_node))
8259 if (!(complain & tf_error))
8260 return error_mark_node;
8262 error ("size of array %qD is negative", name);
8264 error ("size of array is negative");
8265 size = integer_one_node;
8267 /* As an extension we allow zero-sized arrays. */
8268 else if (integer_zerop (size))
8270 if (!(complain & tf_error))
8271 /* We must fail if performing argument deduction (as
8272 indicated by the state of complain), so that
8273 another substitution can be found. */
8274 return error_mark_node;
8275 else if (in_system_header)
8276 /* Allow them in system headers because glibc uses them. */;
8278 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
8280 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array");
8283 else if (TREE_CONSTANT (size)
8284 /* We don't allow VLAs at non-function scopes, or during
8285 tentative template substitution. */
8286 || !at_function_scope_p () || !(complain & tf_error))
8288 if (!(complain & tf_error))
8289 return error_mark_node;
8290 /* `(int) &fn' is not a valid array bound. */
8292 error ("size of array %qD is not an integral constant-expression",
8295 error ("size of array is not an integral constant-expression");
8296 size = integer_one_node;
8298 else if (pedantic && warn_vla != 0)
8301 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
8303 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
8305 else if (warn_vla > 0)
8309 "variable length array %qD is used", name);
8312 "variable length array is used");
8315 if (processing_template_decl && !TREE_CONSTANT (size))
8316 /* A variable sized array. */
8317 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
8320 HOST_WIDE_INT saved_processing_template_decl;
8322 /* Compute the index of the largest element in the array. It is
8323 one less than the number of elements in the array. We save
8324 and restore PROCESSING_TEMPLATE_DECL so that computations in
8325 cp_build_binary_op will be appropriately folded. */
8326 saved_processing_template_decl = processing_template_decl;
8327 processing_template_decl = 0;
8328 itype = cp_build_binary_op (input_location,
8330 cp_convert (ssizetype, size, complain),
8331 cp_convert (ssizetype, integer_one_node,
8334 itype = fold (itype);
8335 processing_template_decl = saved_processing_template_decl;
8337 if (!TREE_CONSTANT (itype))
8339 /* A variable sized array. */
8340 itype = variable_size (itype);
8341 if (TREE_CODE (itype) != SAVE_EXPR)
8343 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8344 they might survive till gimplification. */
8345 tree newitype = itype;
8347 cp_walk_tree_without_duplicates (&newitype,
8348 fold_sizeof_expr_r, &found);
8350 itype = variable_size (fold (newitype));
8353 /* Make sure that there was no overflow when creating to a signed
8354 index type. (For example, on a 32-bit machine, an array with
8355 size 2^32 - 1 is too big.) */
8356 else if (TREE_CODE (itype) == INTEGER_CST
8357 && TREE_OVERFLOW (itype))
8359 if (!(complain & tf_error))
8360 return error_mark_node;
8361 error ("overflow in array dimension");
8362 TREE_OVERFLOW (itype) = 0;
8366 /* Create and return the appropriate index type. */
8367 if (abi_1_itype && abi_1_itype != error_mark_node)
8369 tree t = build_index_type (itype);
8370 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
8371 itype = abi_1_itype;
8374 itype = build_index_type (itype);
8376 /* If the index type were dependent, we would have returned early, so
8377 remember that it isn't. */
8378 TYPE_DEPENDENT_P (itype) = 0;
8379 TYPE_DEPENDENT_P_VALID (itype) = 1;
8383 /* Returns the scope (if any) in which the entity declared by
8384 DECLARATOR will be located. If the entity was declared with an
8385 unqualified name, NULL_TREE is returned. */
8388 get_scope_of_declarator (const cp_declarator *declarator)
8390 while (declarator && declarator->kind != cdk_id)
8391 declarator = declarator->declarator;
8393 /* If the declarator-id is a SCOPE_REF, the scope in which the
8394 declaration occurs is the first operand. */
8396 && declarator->u.id.qualifying_scope)
8397 return declarator->u.id.qualifying_scope;
8399 /* Otherwise, the declarator is not a qualified name; the entity will
8400 be declared in the current scope. */
8404 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8405 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8409 create_array_type_for_decl (tree name, tree type, tree size)
8411 tree itype = NULL_TREE;
8413 /* If things have already gone awry, bail now. */
8414 if (type == error_mark_node || size == error_mark_node)
8415 return error_mark_node;
8417 /* 8.3.4/1: If the type of the identifier of D contains the auto
8418 type-specifier, the program is ill-formed. */
8419 if (pedantic && type_uses_auto (type))
8420 pedwarn (input_location, OPT_Wpedantic,
8421 "declaration of %qD as array of %<auto%>", name);
8423 /* If there are some types which cannot be array elements,
8424 issue an error-message and return. */
8425 switch (TREE_CODE (type))
8429 error ("declaration of %qD as array of void", name);
8431 error ("creating array of void");
8432 return error_mark_node;
8436 error ("declaration of %qD as array of functions", name);
8438 error ("creating array of functions");
8439 return error_mark_node;
8441 case REFERENCE_TYPE:
8443 error ("declaration of %qD as array of references", name);
8445 error ("creating array of references");
8446 return error_mark_node;
8450 error ("declaration of %qD as array of function members", name);
8452 error ("creating array of function members");
8453 return error_mark_node;
8461 The constant expressions that specify the bounds of the arrays
8462 can be omitted only for the first member of the sequence. */
8463 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
8466 error ("declaration of %qD as multidimensional array must "
8467 "have bounds for all dimensions except the first",
8470 error ("multidimensional array must have bounds for all "
8471 "dimensions except the first");
8473 return error_mark_node;
8476 /* Figure out the index type for the array. */
8478 itype = compute_array_index_type (name, size, tf_warning_or_error);
8481 T is called the array element type; this type shall not be [...] an
8482 abstract class type. */
8483 abstract_virtuals_error (name, type);
8485 return build_cplus_array_type (type, itype);
8488 /* Check that it's OK to declare a function with the indicated TYPE.
8489 SFK indicates the kind of special function (if any) that this
8490 function is. OPTYPE is the type given in a conversion operator
8491 declaration, or the class type for a constructor/destructor.
8492 Returns the actual return type of the function; that
8493 may be different than TYPE if an error occurs, or for certain
8494 special functions. */
8497 check_special_function_return_type (special_function_kind sfk,
8503 case sfk_constructor:
8505 error ("return type specification for constructor invalid");
8507 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8508 type = build_pointer_type (optype);
8510 type = void_type_node;
8513 case sfk_destructor:
8515 error ("return type specification for destructor invalid");
8516 /* We can't use the proper return type here because we run into
8517 problems with ambiguous bases and covariant returns.
8518 Java classes are left unchanged because (void *) isn't a valid
8519 Java type, and we don't want to change the Java ABI. */
8520 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8521 type = build_pointer_type (void_type_node);
8523 type = void_type_node;
8526 case sfk_conversion:
8528 error ("return type specified for %<operator %T%>", optype);
8539 /* A variable or data member (whose unqualified name is IDENTIFIER)
8540 has been declared with the indicated TYPE. If the TYPE is not
8541 acceptable, issue an error message and return a type to use for
8542 error-recovery purposes. */
8545 check_var_type (tree identifier, tree type)
8547 if (VOID_TYPE_P (type))
8550 error ("unnamed variable or field declared void");
8551 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
8553 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
8554 error ("variable or field %qE declared void", identifier);
8557 error ("variable or field declared void");
8558 type = error_mark_node;
8564 /* Functions for adjusting the visibility of a tagged type and its nested
8565 types when it gets a name for linkage purposes from a typedef. */
8567 static void bt_reset_linkage (binding_entry, void *);
8569 reset_type_linkage (tree type)
8571 set_linkage_according_to_type (type, TYPE_MAIN_DECL (type));
8572 if (CLASS_TYPE_P (type))
8573 binding_table_foreach (CLASSTYPE_NESTED_UTDS (type), bt_reset_linkage, NULL);
8576 bt_reset_linkage (binding_entry b, void */*data*/)
8578 reset_type_linkage (b->type);
8581 /* Given declspecs and a declarator (abstract or otherwise), determine
8582 the name and type of the object declared and construct a DECL node
8585 DECLSPECS points to the representation of declaration-specifier
8586 sequence that precedes declarator.
8588 DECL_CONTEXT says which syntactic context this declaration is in:
8589 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8590 FUNCDEF for a function definition. Like NORMAL but a few different
8591 error messages in each case. Return value may be zero meaning
8592 this definition is too screwy to try to parse.
8593 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8594 handle member functions (which have FIELD context).
8595 Return value may be zero meaning this definition is too screwy to
8597 PARM for a parameter declaration (either within a function prototype
8598 or before a function body). Make a PARM_DECL, or return void_type_node.
8599 TPARM for a template parameter declaration.
8600 CATCHPARM for a parameter declaration before a catch clause.
8601 TYPENAME if for a typename (in a cast or sizeof).
8602 Don't make a DECL node; just return the ..._TYPE node.
8603 FIELD for a struct or union field; make a FIELD_DECL.
8604 BITFIELD for a field with specified width.
8606 INITIALIZED is as for start_decl.
8608 ATTRLIST is a pointer to the list of attributes, which may be NULL
8609 if there are none; *ATTRLIST may be modified if attributes from inside
8610 the declarator should be applied to the declaration.
8612 When this function is called, scoping variables (such as
8613 CURRENT_CLASS_TYPE) should reflect the scope in which the
8614 declaration occurs, not the scope in which the new declaration will
8615 be placed. For example, on:
8619 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8622 Returns a DECL (if a declarator is present), a TYPE (if there is no
8623 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8627 grokdeclarator (const cp_declarator *declarator,
8628 cp_decl_specifier_seq *declspecs,
8629 enum decl_context decl_context,
8633 tree type = NULL_TREE;
8635 int explicit_int128 = 0;
8636 int virtualp, explicitp, friendp, inlinep, staticp;
8637 int explicit_int = 0;
8638 int explicit_char = 0;
8639 int defaulted_int = 0;
8641 tree typedef_decl = NULL_TREE;
8642 const char *name = NULL;
8643 tree typedef_type = NULL_TREE;
8644 /* True if this declarator is a function definition. */
8645 bool funcdef_flag = false;
8646 cp_declarator_kind innermost_code = cdk_error;
8649 /* See the code below that used this. */
8650 tree decl_attr = NULL_TREE;
8653 /* Keep track of what sort of function is being processed
8654 so that we can warn about default return values, or explicit
8655 return values which do not match prescribed defaults. */
8656 special_function_kind sfk = sfk_none;
8658 tree dname = NULL_TREE;
8659 tree ctor_return_type = NULL_TREE;
8660 enum overload_flags flags = NO_SPECIAL;
8661 /* cv-qualifiers that apply to the declarator, for a declaration of
8662 a member function. */
8663 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
8664 /* virt-specifiers that apply to the declarator, for a declaration of
8665 a member function. */
8666 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
8667 /* ref-qualifier that applies to the declarator, for a declaration of
8668 a member function. */
8669 cp_ref_qualifier rqual = REF_QUAL_NONE;
8670 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8672 tree raises = NULL_TREE;
8673 int template_count = 0;
8674 tree returned_attrs = NULL_TREE;
8675 tree parms = NULL_TREE;
8676 const cp_declarator *id_declarator;
8677 /* The unqualified name of the declarator; either an
8678 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8679 tree unqualified_id;
8680 /* The class type, if any, in which this entity is located,
8681 or NULL_TREE if none. Note that this value may be different from
8682 the current class type; for example if an attempt is made to declare
8683 "A::f" inside "B", this value will be "A". */
8684 tree ctype = current_class_type;
8685 /* The NAMESPACE_DECL for the namespace in which this entity is
8686 located. If an unqualified name is used to declare the entity,
8687 this value will be NULL_TREE, even if the entity is located at
8689 tree in_namespace = NULL_TREE;
8690 cp_storage_class storage_class;
8691 bool unsigned_p, signed_p, short_p, long_p, thread_p;
8692 bool type_was_error_mark_node = false;
8693 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
8694 bool template_type_arg = false;
8695 bool template_parm_flag = false;
8696 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr);
8699 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed);
8700 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned);
8701 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short);
8702 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long);
8703 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long);
8704 explicit_int128 = declspecs->explicit_int128_p;
8705 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread);
8707 if (decl_context == FUNCDEF)
8708 funcdef_flag = true, decl_context = NORMAL;
8709 else if (decl_context == MEMFUNCDEF)
8710 funcdef_flag = true, decl_context = FIELD;
8711 else if (decl_context == BITFIELD)
8712 bitfield = 1, decl_context = FIELD;
8713 else if (decl_context == TEMPLATE_TYPE_ARG)
8714 template_type_arg = true, decl_context = TYPENAME;
8715 else if (decl_context == TPARM)
8716 template_parm_flag = true, decl_context = PARM;
8718 if (initialized > 1)
8719 funcdef_flag = true;
8721 /* Look inside a declarator for the name being declared
8722 and get it as a string, for an error message. */
8723 for (id_declarator = declarator;
8725 id_declarator = id_declarator->declarator)
8727 if (id_declarator->kind != cdk_id)
8728 innermost_code = id_declarator->kind;
8730 switch (id_declarator->kind)
8733 if (id_declarator->declarator
8734 && id_declarator->declarator->kind == cdk_id)
8736 sfk = id_declarator->declarator->u.id.sfk;
8737 if (sfk == sfk_destructor)
8744 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
8745 tree decl = id_declarator->u.id.unqualified_name;
8748 if (qualifying_scope)
8750 if (at_function_scope_p ())
8754 A declarator-id shall not be qualified except
8757 None of the cases are permitted in block
8759 if (qualifying_scope == global_namespace)
8760 error ("invalid use of qualified-name %<::%D%>",
8762 else if (TYPE_P (qualifying_scope))
8763 error ("invalid use of qualified-name %<%T::%D%>",
8764 qualifying_scope, decl);
8766 error ("invalid use of qualified-name %<%D::%D%>",
8767 qualifying_scope, decl);
8768 return error_mark_node;
8770 else if (TYPE_P (qualifying_scope))
8772 ctype = qualifying_scope;
8773 if (!MAYBE_CLASS_TYPE_P (ctype))
8775 error ("%q#T is not a class or a namespace", ctype);
8778 else if (innermost_code != cdk_function
8779 && current_class_type
8780 && !uniquely_derived_from_p (ctype,
8781 current_class_type))
8783 error ("invalid use of qualified-name %<%T::%D%>",
8784 qualifying_scope, decl);
8785 return error_mark_node;
8788 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
8789 in_namespace = qualifying_scope;
8791 switch (TREE_CODE (decl))
8797 if (innermost_code != cdk_function)
8799 error ("declaration of %qD as non-function", decl);
8800 return error_mark_node;
8802 else if (!qualifying_scope
8803 && !(current_class_type && at_class_scope_p ()))
8805 error ("declaration of %qD as non-member", decl);
8806 return error_mark_node;
8809 type = TREE_OPERAND (decl, 0);
8811 type = constructor_name (type);
8812 name = identifier_to_locale (IDENTIFIER_POINTER (type));
8817 case TEMPLATE_ID_EXPR:
8819 tree fns = TREE_OPERAND (decl, 0);
8822 if (TREE_CODE (dname) != IDENTIFIER_NODE)
8824 gcc_assert (is_overloaded_fn (dname));
8825 dname = DECL_NAME (get_first_fn (dname));
8830 case IDENTIFIER_NODE:
8831 if (TREE_CODE (decl) == IDENTIFIER_NODE)
8834 if (C_IS_RESERVED_WORD (dname))
8836 error ("declarator-id missing; using reserved word %qD",
8838 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8840 else if (!IDENTIFIER_TYPENAME_P (dname))
8841 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8844 gcc_assert (flags == NO_SPECIAL);
8845 flags = TYPENAME_FLAG;
8846 ctor_return_type = TREE_TYPE (dname);
8847 sfk = sfk_conversion;
8848 if (is_typename_at_global_scope (dname))
8849 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
8851 name = "<invalid operator>";
8868 return error_mark_node;
8873 if (id_declarator->kind == cdk_id)
8879 The declarator in a function-definition shall have the form
8880 D1 ( parameter-declaration-clause) ... */
8881 if (funcdef_flag && innermost_code != cdk_function)
8883 error ("function definition does not declare parameters");
8884 return error_mark_node;
8887 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
8888 && innermost_code != cdk_function
8889 && ! (ctype && !declspecs->any_specifiers_p))
8891 error ("declaration of %qD as non-function", dname);
8892 return error_mark_node;
8896 && TREE_CODE (dname) == IDENTIFIER_NODE
8897 && UDLIT_OPER_P (dname)
8898 && innermost_code != cdk_function)
8900 error ("declaration of %qD as non-function", dname);
8901 return error_mark_node;
8904 if (dname && IDENTIFIER_OPNAME_P (dname))
8906 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
8908 error ("declaration of %qD as %<typedef%>", dname);
8909 return error_mark_node;
8911 else if (decl_context == PARM || decl_context == CATCHPARM)
8913 error ("declaration of %qD as parameter", dname);
8914 return error_mark_node;
8918 /* Anything declared one level down from the top level
8919 must be one of the parameters of a function
8920 (because the body is at least two levels down). */
8922 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8923 by not allowing C++ class definitions to specify their parameters
8924 with xdecls (must be spec.d in the parmlist).
8926 Since we now wait to push a class scope until we are sure that
8927 we are in a legitimate method context, we must set oldcname
8928 explicitly (since current_class_name is not yet alive).
8930 We also want to avoid calling this a PARM if it is in a namespace. */
8932 if (decl_context == NORMAL && !toplevel_bindings_p ())
8934 cp_binding_level *b = current_binding_level;
8935 current_binding_level = b->level_chain;
8936 if (current_binding_level != 0 && toplevel_bindings_p ())
8937 decl_context = PARM;
8938 current_binding_level = b;
8942 name = decl_context == PARM ? "parameter" : "type name";
8944 if (constexpr_p && decl_spec_seq_has_spec_p (declspecs, ds_typedef))
8946 error ("%<constexpr%> cannot appear in a typedef declaration");
8947 return error_mark_node;
8950 /* If there were multiple types specified in the decl-specifier-seq,
8951 issue an error message. */
8952 if (declspecs->multiple_types_p)
8954 error ("two or more data types in declaration of %qs", name);
8955 return error_mark_node;
8958 if (declspecs->conflicting_specifiers_p)
8960 error ("conflicting specifiers in declaration of %qs", name);
8961 return error_mark_node;
8964 /* Extract the basic type from the decl-specifier-seq. */
8965 type = declspecs->type;
8966 if (type == error_mark_node)
8969 type_was_error_mark_node = true;
8971 /* If the entire declaration is itself tagged as deprecated then
8972 suppress reports of deprecated items. */
8973 if (type && TREE_DEPRECATED (type)
8974 && deprecated_state != DEPRECATED_SUPPRESS)
8975 warn_deprecated_use (type, NULL_TREE);
8976 if (type && TREE_CODE (type) == TYPE_DECL)
8978 typedef_decl = type;
8979 type = TREE_TYPE (typedef_decl);
8980 if (TREE_DEPRECATED (type)
8981 && DECL_ARTIFICIAL (typedef_decl)
8982 && deprecated_state != DEPRECATED_SUPPRESS)
8983 warn_deprecated_use (type, NULL_TREE);
8985 /* No type at all: default to `int', and set DEFAULTED_INT
8986 because it was not a user-defined typedef. */
8987 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
8989 /* These imply 'int'. */
8990 type = integer_type_node;
8994 explicit_int = declspecs->explicit_int_p;
8995 explicit_char = declspecs->explicit_char_p;
8998 /* See the code below that used this. */
9000 decl_attr = DECL_ATTRIBUTES (typedef_decl);
9002 typedef_type = type;
9005 if (sfk != sfk_conversion)
9006 ctor_return_type = ctype;
9008 if (sfk != sfk_none)
9009 type = check_special_function_return_type (sfk, type,
9011 else if (type == NULL_TREE)
9017 /* We handle `main' specially here, because 'main () { }' is so
9018 common. With no options, it is allowed. With -Wreturn-type,
9019 it is a warning. It is only an error with -pedantic-errors. */
9020 is_main = (funcdef_flag
9021 && dname && TREE_CODE (dname) == IDENTIFIER_NODE
9022 && MAIN_NAME_P (dname)
9023 && ctype == NULL_TREE
9024 && in_namespace == NULL_TREE
9025 && current_namespace == global_namespace);
9027 if (type_was_error_mark_node)
9028 /* We've already issued an error, don't complain more. */;
9029 else if (in_system_header || flag_ms_extensions)
9030 /* Allow it, sigh. */;
9032 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
9034 pedwarn (input_location, OPT_Wpedantic,
9035 "ISO C++ forbids declaration of %qs with no type", name);
9037 warning (OPT_Wreturn_type,
9038 "ISO C++ forbids declaration of %qs with no type", name);
9040 type = integer_type_node;
9045 if (explicit_int128)
9047 if (int128_integer_type_node == NULL_TREE)
9049 error ("%<__int128%> is not supported by this target");
9050 explicit_int128 = false;
9052 else if (pedantic && ! in_system_header)
9053 pedwarn (input_location, OPT_Wpedantic,
9054 "ISO C++ does not support %<__int128%> for %qs", name);
9057 /* Now process the modifiers that were specified
9058 and check for invalid combinations. */
9060 /* Long double is a special combination. */
9061 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
9064 type = cp_build_qualified_type (long_double_type_node,
9065 cp_type_quals (type));
9068 /* Check all other uses of type modifiers. */
9070 if (unsigned_p || signed_p || long_p || short_p)
9074 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
9075 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
9076 else if (signed_p && unsigned_p)
9077 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
9078 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
9079 error ("%<long long%> invalid for %qs", name);
9080 else if (long_p && TREE_CODE (type) == REAL_TYPE)
9081 error ("%<long%> invalid for %qs", name);
9082 else if (short_p && TREE_CODE (type) == REAL_TYPE)
9083 error ("%<short%> invalid for %qs", name);
9084 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
9085 error ("%<long%> or %<short%> invalid for %qs", name);
9086 else if ((long_p || short_p || explicit_char || explicit_int) && explicit_int128)
9087 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
9088 else if ((long_p || short_p) && explicit_char)
9089 error ("%<long%> or %<short%> specified with char for %qs", name);
9090 else if (long_p && short_p)
9091 error ("%<long%> and %<short%> specified together for %qs", name);
9092 else if (type == char16_type_node || type == char32_type_node)
9094 if (signed_p || unsigned_p)
9095 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
9096 else if (short_p || long_p)
9097 error ("%<short%> or %<long%> invalid for %qs", name);
9102 if (!explicit_int && !defaulted_int && !explicit_char && !explicit_int128 && pedantic)
9104 pedwarn (input_location, OPT_Wpedantic,
9105 "long, short, signed or unsigned used invalidly for %qs",
9107 if (flag_pedantic_errors)
9112 /* Discard the type modifiers if they are invalid. */
9123 /* Decide whether an integer type is signed or not.
9124 Optionally treat bitfields as signed by default. */
9128 It is implementation-defined whether a plain (neither
9129 explicitly signed or unsigned) char, short, int, or long
9130 bit-field is signed or unsigned.
9132 Naturally, we extend this to long long as well. Note that
9133 this does not include wchar_t. */
9134 || (bitfield && !flag_signed_bitfields
9136 /* A typedef for plain `int' without `signed' can be
9137 controlled just like plain `int', but a typedef for
9138 `signed int' cannot be so controlled. */
9140 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9141 && TREE_CODE (type) == INTEGER_TYPE
9142 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9144 if (explicit_int128)
9145 type = int128_unsigned_type_node;
9147 type = long_long_unsigned_type_node;
9149 type = long_unsigned_type_node;
9151 type = short_unsigned_type_node;
9152 else if (type == char_type_node)
9153 type = unsigned_char_type_node;
9154 else if (typedef_decl)
9155 type = unsigned_type_for (type);
9157 type = unsigned_type_node;
9159 else if (signed_p && type == char_type_node)
9160 type = signed_char_type_node;
9161 else if (explicit_int128)
9162 type = int128_integer_type_node;
9164 type = long_long_integer_type_node;
9166 type = long_integer_type_node;
9168 type = short_integer_type_node;
9170 if (decl_spec_seq_has_spec_p (declspecs, ds_complex))
9172 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9173 error ("complex invalid for %qs", name);
9174 /* If we just have "complex", it is equivalent to
9175 "complex double", but if any modifiers at all are specified it is
9176 the complex form of TYPE. E.g, "complex short" is
9177 "complex short int". */
9178 else if (defaulted_int && ! longlong && ! explicit_int128
9179 && ! (long_p || short_p || signed_p || unsigned_p))
9180 type = complex_double_type_node;
9181 else if (type == integer_type_node)
9182 type = complex_integer_type_node;
9183 else if (type == float_type_node)
9184 type = complex_float_type_node;
9185 else if (type == double_type_node)
9186 type = complex_double_type_node;
9187 else if (type == long_double_type_node)
9188 type = complex_long_double_type_node;
9190 type = build_complex_type (type);
9193 type_quals = TYPE_UNQUALIFIED;
9194 if (decl_spec_seq_has_spec_p (declspecs, ds_const))
9195 type_quals |= TYPE_QUAL_CONST;
9196 if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
9197 type_quals |= TYPE_QUAL_VOLATILE;
9198 if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
9199 type_quals |= TYPE_QUAL_RESTRICT;
9200 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
9201 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9204 /* If we're using the injected-class-name to form a compound type or a
9205 declaration, replace it with the underlying class so we don't get
9206 redundant typedefs in the debug output. But if we are returning the
9207 type unchanged, leave it alone so that it's available to
9208 maybe_get_template_decl_from_type_decl. */
9209 if (CLASS_TYPE_P (type)
9210 && DECL_SELF_REFERENCE_P (TYPE_NAME (type))
9211 && type == TREE_TYPE (TYPE_NAME (type))
9212 && (declarator || type_quals))
9213 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
9215 type_quals |= cp_type_quals (type);
9216 type = cp_build_qualified_type_real
9217 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
9218 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
9219 /* We might have ignored or rejected some of the qualifiers. */
9220 type_quals = cp_type_quals (type);
9223 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline);
9224 virtualp = decl_spec_seq_has_spec_p (declspecs, ds_virtual);
9225 explicitp = decl_spec_seq_has_spec_p (declspecs, ds_explicit);
9227 storage_class = declspecs->storage_class;
9228 if (storage_class == sc_static)
9229 staticp = 1 + (decl_context == FIELD);
9231 if (virtualp && staticp == 2)
9233 error ("member %qD cannot be declared both virtual and static", dname);
9234 storage_class = sc_none;
9237 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
9239 /* Issue errors about use of storage classes for parameters. */
9240 if (decl_context == PARM)
9242 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9244 error ("typedef declaration invalid in parameter declaration");
9245 return error_mark_node;
9247 else if (template_parm_flag && storage_class != sc_none)
9249 error ("storage class specified for template parameter %qs", name);
9250 return error_mark_node;
9252 else if (storage_class == sc_static
9253 || storage_class == sc_extern
9255 error ("storage class specifiers invalid in parameter declarations");
9257 /* Function parameters cannot be constexpr. If we saw one, moan
9258 and pretend it wasn't there. */
9261 error ("a parameter cannot be declared %<constexpr%>");
9266 /* Give error if `virtual' is used outside of class declaration. */
9268 && (current_class_name == NULL_TREE || decl_context != FIELD))
9270 error ("%<virtual%> outside class declaration");
9274 /* Static anonymous unions are dealt with here. */
9275 if (staticp && decl_context == TYPENAME
9277 && ANON_AGGR_TYPE_P (declspecs->type))
9278 decl_context = FIELD;
9280 /* Warn about storage classes that are invalid for certain
9281 kinds of declarations (parameters, typenames, etc.). */
9284 && storage_class != sc_extern
9285 && storage_class != sc_static)
9286 || decl_spec_seq_has_spec_p (declspecs, ds_typedef)))
9288 error ("multiple storage classes in declaration of %qs", name);
9291 if (decl_context != NORMAL
9292 && ((storage_class != sc_none
9293 && storage_class != sc_mutable)
9296 if ((decl_context == PARM || decl_context == CATCHPARM)
9297 && (storage_class == sc_register
9298 || storage_class == sc_auto))
9300 else if (decl_spec_seq_has_spec_p (declspecs, ds_typedef))
9302 else if (decl_context == FIELD
9303 /* C++ allows static class elements. */
9304 && storage_class == sc_static)
9305 /* C++ also allows inlines and signed and unsigned elements,
9306 but in those cases we don't come in here. */
9310 if (decl_context == FIELD)
9311 error ("storage class specified for %qs", name);
9314 if (decl_context == PARM || decl_context == CATCHPARM)
9315 error ("storage class specified for parameter %qs", name);
9317 error ("storage class specified for typename");
9319 if (storage_class == sc_register
9320 || storage_class == sc_auto
9321 || storage_class == sc_extern
9323 storage_class = sc_none;
9326 else if (storage_class == sc_extern && funcdef_flag
9327 && ! toplevel_bindings_p ())
9328 error ("nested function %qs declared %<extern%>", name);
9329 else if (toplevel_bindings_p ())
9331 if (storage_class == sc_auto)
9332 error ("top-level declaration of %qs specifies %<auto%>", name);
9335 && storage_class != sc_extern
9336 && storage_class != sc_static)
9338 if (declspecs->gnu_thread_keyword_p)
9339 pedwarn (input_location, 0, "function-scope %qs implicitly auto and "
9340 "declared %<__thread%>", name);
9342 /* When thread_local is applied to a variable of block scope the
9343 storage-class-specifier static is implied if it does not appear
9345 storage_class = declspecs->storage_class = sc_static;
9349 if (storage_class && friendp)
9351 error ("storage class specifiers invalid in friend function declarations");
9352 storage_class = sc_none;
9357 unqualified_id = NULL_TREE;
9360 unqualified_id = id_declarator->u.id.unqualified_name;
9361 switch (TREE_CODE (unqualified_id))
9364 unqualified_id = TREE_OPERAND (unqualified_id, 0);
9365 if (TYPE_P (unqualified_id))
9366 unqualified_id = constructor_name (unqualified_id);
9369 case IDENTIFIER_NODE:
9370 case TEMPLATE_ID_EXPR:
9378 if (declspecs->std_attributes)
9380 /* Apply the c++11 attributes to the type preceding them. */
9381 source_location saved_loc = input_location;
9382 input_location = declspecs->locations[ds_std_attribute];
9383 decl_attributes (&type, declspecs->std_attributes, 0);
9384 input_location = saved_loc;
9387 /* Determine the type of the entity declared by recurring on the
9389 for (; declarator; declarator = declarator->declarator)
9391 const cp_declarator *inner_declarator;
9394 if (type == error_mark_node)
9395 return error_mark_node;
9397 attrs = declarator->attributes;
9403 if (declarator == NULL || declarator->kind == cdk_id)
9404 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
9405 if (declarator->kind == cdk_function)
9406 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
9407 if (declarator->kind == cdk_array)
9408 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
9409 returned_attrs = decl_attributes (&type,
9410 chainon (returned_attrs, attrs),
9414 if (declarator->kind == cdk_id)
9417 inner_declarator = declarator->declarator;
9419 switch (declarator->kind)
9422 type = create_array_type_for_decl (dname, type,
9423 declarator->u.array.bounds);
9424 if (declarator->std_attributes)
9427 The optional attribute-specifier-seq appertains to the
9429 returned_attrs = chainon (returned_attrs,
9430 declarator->std_attributes);
9438 /* Declaring a function type.
9439 Make sure we have a valid type for the function to return. */
9441 if (type_quals != TYPE_UNQUALIFIED)
9443 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
9444 warning (OPT_Wignored_qualifiers,
9445 "type qualifiers ignored on function return type");
9446 /* We now know that the TYPE_QUALS don't apply to the
9447 decl, but to its return type. */
9448 type_quals = TYPE_UNQUALIFIED;
9450 errmsg = targetm.invalid_return_type (type);
9454 type = integer_type_node;
9457 /* Error about some types functions can't return. */
9459 if (TREE_CODE (type) == FUNCTION_TYPE)
9461 error ("%qs declared as function returning a function", name);
9462 return error_mark_node;
9464 if (TREE_CODE (type) == ARRAY_TYPE)
9466 error ("%qs declared as function returning an array", name);
9467 return error_mark_node;
9469 /* When decl_context == NORMAL we emit a better error message
9470 later in abstract_virtuals_error. */
9471 if (decl_context == TYPENAME && ABSTRACT_CLASS_TYPE_P (type))
9472 error ("%qs declared as function returning an abstract "
9473 "class type", name);
9475 /* Pick up type qualifiers which should be applied to `this'. */
9476 memfn_quals = declarator->u.function.qualifiers;
9477 /* Pick up virt-specifiers. */
9478 virt_specifiers = declarator->u.function.virt_specifiers;
9479 /* And ref-qualifier, too */
9480 rqual = declarator->u.function.ref_qualifier;
9481 /* Pick up the exception specifications. */
9482 raises = declarator->u.function.exception_specification;
9483 /* If the exception-specification is ill-formed, let's pretend
9484 there wasn't one. */
9485 if (raises == error_mark_node)
9488 /* Say it's a definition only for the CALL_EXPR
9489 closest to the identifier. */
9490 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
9492 /* Handle a late-specified return type. */
9495 if (type_uses_auto (type))
9497 if (!declarator->u.function.late_return_type)
9499 if (current_class_type
9500 && LAMBDA_TYPE_P (current_class_type))
9501 /* OK for C++11 lambdas. */;
9502 else if (cxx_dialect < cxx1y)
9503 pedwarn (input_location, 0, "%qs function uses "
9504 "%<auto%> type specifier without trailing "
9505 "return type", name);
9507 else if (!is_auto (type))
9509 error ("%qs function with trailing return type has"
9510 " %qT as its type rather than plain %<auto%>",
9512 return error_mark_node;
9515 else if (declarator->u.function.late_return_type)
9517 if (cxx_dialect < cxx0x)
9518 /* Not using maybe_warn_cpp0x because this should
9519 always be an error. */
9520 error ("trailing return type only available with "
9521 "-std=c++11 or -std=gnu++11");
9523 error ("%qs function with trailing return type not "
9524 "declared with %<auto%> type specifier", name);
9525 return error_mark_node;
9528 type = splice_late_return_type
9529 (type, declarator->u.function.late_return_type);
9530 if (type == error_mark_node)
9531 return error_mark_node;
9533 if (ctype == NULL_TREE
9534 && decl_context == FIELD
9536 && (friendp == 0 || dname == current_class_name))
9537 ctype = current_class_type;
9539 if (ctype && (sfk == sfk_constructor
9540 || sfk == sfk_destructor))
9542 /* We are within a class's scope. If our declarator name
9543 is the same as the class name, and we are defining
9544 a function, then it is a constructor/destructor, and
9545 therefore returns a void type. */
9547 /* ISO C++ 12.4/2. A destructor may not be declared
9548 const or volatile. A destructor may not be static.
9549 A destructor may not be declared with ref-qualifier.
9551 ISO C++ 12.1. A constructor may not be declared
9552 const or volatile. A constructor may not be
9553 virtual. A constructor may not be static.
9554 A constructor may not be declared with ref-qualifier. */
9556 error ((flags == DTOR_FLAG)
9557 ? G_("destructor cannot be static member function")
9558 : G_("constructor cannot be static member function"));
9561 error ((flags == DTOR_FLAG)
9562 ? G_("destructors may not be cv-qualified")
9563 : G_("constructors may not be cv-qualified"));
9564 memfn_quals = TYPE_UNQUALIFIED;
9569 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER);
9570 error ((flags == DTOR_FLAG)
9571 ? "destructors may not be ref-qualified"
9572 : "constructors may not be ref-qualified");
9573 rqual = REF_QUAL_NONE;
9576 if (decl_context == FIELD
9577 && !member_function_or_else (ctype,
9580 return error_mark_node;
9582 if (flags != DTOR_FLAG)
9584 /* It's a constructor. */
9589 permerror (input_location, "constructors cannot be declared virtual");
9592 if (decl_context == FIELD
9593 && sfk != sfk_constructor)
9594 return error_mark_node;
9596 if (decl_context == FIELD)
9602 error ("can%'t initialize friend function %qs", name);
9605 /* Cannot be both friend and virtual. */
9606 error ("virtual functions cannot be friends");
9609 if (decl_context == NORMAL)
9610 error ("friend declaration not in class definition");
9611 if (current_function_decl && funcdef_flag)
9612 error ("can%'t define friend function %qs in a local "
9616 else if (ctype && sfk == sfk_conversion)
9620 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION);
9625 arg_types = grokparms (declarator->u.function.parameters,
9628 if (inner_declarator
9629 && inner_declarator->kind == cdk_id
9630 && inner_declarator->u.id.sfk == sfk_destructor
9631 && arg_types != void_list_node)
9633 error ("destructors may not have parameters");
9634 arg_types = void_list_node;
9638 type = build_function_type (type, arg_types);
9639 if (declarator->std_attributes)
9642 The optional attribute-specifier-seq appertains to
9643 the function type. */
9644 decl_attributes (&type, declarator->std_attributes,
9652 /* Filter out pointers-to-references and references-to-references.
9653 We can get these if a TYPE_DECL is used. */
9655 if (TREE_CODE (type) == REFERENCE_TYPE)
9657 if (declarator->kind != cdk_reference)
9659 error ("cannot declare pointer to %q#T", type);
9660 type = TREE_TYPE (type);
9663 /* In C++0x, we allow reference to reference declarations
9664 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9665 and template type arguments [14.3.1/4 temp.arg.type]. The
9666 check for direct reference to reference declarations, which
9667 are still forbidden, occurs below. Reasoning behind the change
9668 can be found in DR106, DR540, and the rvalue reference
9670 else if (cxx_dialect == cxx98)
9672 error ("cannot declare reference to %q#T", type);
9673 type = TREE_TYPE (type);
9676 else if (VOID_TYPE_P (type))
9678 if (declarator->kind == cdk_reference)
9679 error ("cannot declare reference to %q#T", type);
9680 else if (declarator->kind == cdk_ptrmem)
9681 error ("cannot declare pointer to %q#T member", type);
9684 /* We now know that the TYPE_QUALS don't apply to the decl,
9685 but to the target of the pointer. */
9686 type_quals = TYPE_UNQUALIFIED;
9688 if (declarator->kind == cdk_ptrmem
9689 && (TREE_CODE (type) == FUNCTION_TYPE
9690 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
9692 memfn_quals |= type_memfn_quals (type);
9693 type = build_memfn_type (type,
9694 declarator->u.pointer.class_type,
9697 if (type == error_mark_node)
9698 return error_mark_node;
9700 rqual = REF_QUAL_NONE;
9701 memfn_quals = TYPE_UNQUALIFIED;
9704 if (TREE_CODE (type) == FUNCTION_TYPE
9705 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
9706 || type_memfn_rqual (type) != REF_QUAL_NONE))
9707 error (declarator->kind == cdk_reference
9708 ? G_("cannot declare reference to qualified function type %qT")
9709 : G_("cannot declare pointer to qualified function type %qT"),
9712 /* When the pointed-to type involves components of variable size,
9713 care must be taken to ensure that the size evaluation code is
9714 emitted early enough to dominate all the possible later uses
9715 and late enough for the variables on which it depends to have
9718 This is expected to happen automatically when the pointed-to
9719 type has a name/declaration of it's own, but special attention
9720 is required if the type is anonymous.
9722 We handle the NORMAL and FIELD contexts here by inserting a
9723 dummy statement that just evaluates the size at a safe point
9724 and ensures it is not deferred until e.g. within a deeper
9725 conditional context (c++/43555).
9727 We expect nothing to be needed here for PARM or TYPENAME.
9728 Evaluating the size at this point for TYPENAME would
9729 actually be incorrect, as we might be in the middle of an
9730 expression with side effects on the pointed-to type size
9731 "arguments" prior to the pointer declaration point and the
9732 size evaluation could end up prior to the side effects. */
9734 if (!TYPE_NAME (type)
9735 && (decl_context == NORMAL || decl_context == FIELD)
9736 && at_function_scope_p ()
9737 && variably_modified_type_p (type, NULL_TREE))
9739 /* First break out any side-effects. */
9740 stabilize_vla_size (TYPE_SIZE (type));
9741 /* And then force evaluation of the SAVE_EXPR. */
9742 finish_expr_stmt (TYPE_SIZE (type));
9745 if (declarator->kind == cdk_reference)
9747 /* In C++0x, the type we are creating a reference to might be
9748 a typedef which is itself a reference type. In that case,
9749 we follow the reference collapsing rules in
9750 [7.1.3/8 dcl.typedef] to create the final reference type:
9752 "If a typedef TD names a type that is a reference to a type
9753 T, an attempt to create the type 'lvalue reference to cv TD'
9754 creates the type 'lvalue reference to T,' while an attempt
9755 to create the type "rvalue reference to cv TD' creates the
9758 if (VOID_TYPE_P (type))
9759 /* We already gave an error. */;
9760 else if (TREE_CODE (type) == REFERENCE_TYPE)
9762 if (declarator->u.reference.rvalue_ref)
9763 /* Leave type alone. */;
9765 type = cp_build_reference_type (TREE_TYPE (type), false);
9768 type = cp_build_reference_type
9769 (type, declarator->u.reference.rvalue_ref);
9771 /* In C++0x, we need this check for direct reference to
9772 reference declarations, which are forbidden by
9773 [8.3.2/5 dcl.ref]. Reference to reference declarations
9774 are only allowed indirectly through typedefs and template
9775 type arguments. Example:
9777 void foo(int & &); // invalid ref-to-ref decl
9779 typedef int & int_ref;
9780 void foo(int_ref &); // valid ref-to-ref decl
9782 if (inner_declarator && inner_declarator->kind == cdk_reference)
9783 error ("cannot declare reference to %q#T, which is not "
9784 "a typedef or a template type argument", type);
9786 else if (TREE_CODE (type) == METHOD_TYPE)
9787 type = build_ptrmemfunc_type (build_pointer_type (type));
9788 else if (declarator->kind == cdk_ptrmem)
9790 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
9792 if (declarator->u.pointer.class_type == error_mark_node)
9793 /* We will already have complained. */
9794 type = error_mark_node;
9796 type = build_ptrmem_type (declarator->u.pointer.class_type,
9800 type = build_pointer_type (type);
9802 /* Process a list of type modifier keywords (such as
9803 const or volatile) that were given inside the `*' or `&'. */
9805 if (declarator->u.pointer.qualifiers)
9808 = cp_build_qualified_type (type,
9809 declarator->u.pointer.qualifiers);
9810 type_quals = cp_type_quals (type);
9813 /* Apply C++11 attributes to the pointer, and not to the
9814 type pointed to. This is unlike what is done for GNU
9815 attributes above. It is to comply with [dcl.ptr]/1:
9817 [the optional attribute-specifier-seq (7.6.1) appertains
9818 to the pointer and not to the object pointed to]. */
9819 if (declarator->std_attributes)
9820 decl_attributes (&type, declarator->std_attributes,
9834 /* We need to stabilize side-effects in VLA sizes for regular array
9835 declarations too, not just pointers to arrays. */
9836 if (type != error_mark_node && !TYPE_NAME (type)
9837 && (decl_context == NORMAL || decl_context == FIELD)
9838 && at_function_scope_p ()
9839 && variably_modified_type_p (type, NULL_TREE))
9840 stabilize_vla_size (TYPE_SIZE (type));
9842 /* A `constexpr' specifier used in an object declaration declares
9843 the object as `const'. */
9844 if (constexpr_p && innermost_code != cdk_function)
9846 if (type_quals & TYPE_QUAL_VOLATILE)
9847 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9848 if (TREE_CODE (type) != REFERENCE_TYPE)
9850 type_quals |= TYPE_QUAL_CONST;
9851 type = cp_build_qualified_type (type, type_quals);
9855 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
9856 && TREE_CODE (type) != FUNCTION_TYPE
9857 && TREE_CODE (type) != METHOD_TYPE)
9859 error ("template-id %qD used as a declarator",
9861 unqualified_id = dname;
9864 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9865 qualified with a class-name, turn it into a METHOD_TYPE, unless
9866 we know that the function is static. We take advantage of this
9867 opportunity to do other processing that pertains to entities
9868 explicitly declared to be class members. Note that if DECLARATOR
9869 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9870 would not have exited the loop above. */
9872 && declarator->u.id.qualifying_scope
9873 && MAYBE_CLASS_TYPE_P (declarator->u.id.qualifying_scope))
9875 ctype = declarator->u.id.qualifying_scope;
9876 ctype = TYPE_MAIN_VARIANT (ctype);
9877 template_count = num_template_headers_for_class (ctype);
9879 if (ctype == current_class_type)
9883 permerror (input_location, "member functions are implicitly friends of their class");
9887 permerror (declarator->id_loc,
9888 "extra qualification %<%T::%> on member %qs",
9891 else if (/* If the qualifying type is already complete, then we
9892 can skip the following checks. */
9893 !COMPLETE_TYPE_P (ctype)
9894 && (/* If the function is being defined, then
9895 qualifying type must certainly be complete. */
9897 /* A friend declaration of "T::f" is OK, even if
9898 "T" is a template parameter. But, if this
9899 function is not a friend, the qualifying type
9901 || (!friendp && !CLASS_TYPE_P (ctype))
9902 /* For a declaration, the type need not be
9903 complete, if either it is dependent (since there
9904 is no meaningful definition of complete in that
9905 case) or the qualifying class is currently being
9907 || !(dependent_type_p (ctype)
9908 || currently_open_class (ctype)))
9909 /* Check that the qualifying type is complete. */
9910 && !complete_type_or_else (ctype, NULL_TREE))
9911 return error_mark_node;
9912 else if (TREE_CODE (type) == FUNCTION_TYPE)
9914 if (current_class_type
9915 && (!friendp || funcdef_flag))
9918 ? G_("cannot define member function %<%T::%s%> "
9920 : G_("cannot declare member function %<%T::%s%> "
9922 ctype, name, current_class_type);
9923 return error_mark_node;
9926 else if (decl_spec_seq_has_spec_p (declspecs, ds_typedef)
9927 && current_class_type)
9929 error ("cannot declare member %<%T::%s%> within %qT",
9930 ctype, name, current_class_type);
9931 return error_mark_node;
9935 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0)
9936 ctype = current_class_type;
9938 /* Now TYPE has the actual type. */
9943 *attrlist = chainon (returned_attrs, *attrlist);
9945 attrlist = &returned_attrs;
9949 && declarator->kind == cdk_id
9950 && declarator->std_attributes)
9951 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
9952 a declarator-id appertains to the entity that is declared. */
9953 *attrlist = chainon (*attrlist, declarator->std_attributes);
9955 /* Handle parameter packs. */
9956 if (parameter_pack_p)
9958 if (decl_context == PARM)
9959 /* Turn the type into a pack expansion.*/
9960 type = make_pack_expansion (type);
9962 error ("non-parameter %qs cannot be a parameter pack", name);
9965 /* Did array size calculations overflow or does the array cover more
9966 than half of the address-space? */
9967 if (TREE_CODE (type) == ARRAY_TYPE
9968 && COMPLETE_TYPE_P (type)
9969 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
9970 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type)))
9972 error ("size of array %qs is too large", name);
9973 /* If we proceed with the array type as it is, we'll eventually
9974 crash in tree_low_cst(). */
9975 type = error_mark_node;
9978 if ((decl_context == FIELD || decl_context == PARM)
9979 && !processing_template_decl
9980 && variably_modified_type_p (type, NULL_TREE))
9982 if (decl_context == FIELD)
9983 error ("data member may not have variably modified type %qT", type);
9985 error ("parameter may not have variably modified type %qT", type);
9986 type = error_mark_node;
9989 if (explicitp == 1 || (explicitp && friendp))
9991 /* [dcl.fct.spec] The explicit specifier shall only be used in
9992 declarations of constructors within a class definition. */
9993 error ("only declarations of constructors can be %<explicit%>");
9997 if (storage_class == sc_mutable)
9999 if (decl_context != FIELD || friendp)
10001 error ("non-member %qs cannot be declared %<mutable%>", name);
10002 storage_class = sc_none;
10004 else if (decl_context == TYPENAME
10005 || decl_spec_seq_has_spec_p (declspecs, ds_typedef))
10007 error ("non-object member %qs cannot be declared %<mutable%>", name);
10008 storage_class = sc_none;
10010 else if (TREE_CODE (type) == FUNCTION_TYPE
10011 || TREE_CODE (type) == METHOD_TYPE)
10013 error ("function %qs cannot be declared %<mutable%>", name);
10014 storage_class = sc_none;
10018 error ("static %qs cannot be declared %<mutable%>", name);
10019 storage_class = sc_none;
10021 else if (type_quals & TYPE_QUAL_CONST)
10023 error ("const %qs cannot be declared %<mutable%>", name);
10024 storage_class = sc_none;
10026 else if (TREE_CODE (type) == REFERENCE_TYPE)
10028 permerror (input_location, "reference %qs cannot be declared "
10029 "%<mutable%>", name);
10030 storage_class = sc_none;
10034 /* If this is declaring a typedef name, return a TYPE_DECL. */
10035 if (decl_spec_seq_has_spec_p (declspecs, ds_typedef) && decl_context != TYPENAME)
10039 /* Note that the grammar rejects storage classes
10040 in typenames, fields or parameters. */
10041 if (current_lang_name == lang_name_java)
10042 TYPE_FOR_JAVA (type) = 1;
10044 /* This declaration:
10046 typedef void f(int) const;
10048 declares a function type which is not a member of any
10049 particular class, but which is cv-qualified; for
10050 example "f S::*" declares a pointer to a const-qualified
10051 member function of S. We record the cv-qualification in the
10053 if ((rqual || memfn_quals) && TREE_CODE (type) == FUNCTION_TYPE)
10055 type = apply_memfn_quals (type, memfn_quals, rqual);
10057 /* We have now dealt with these qualifiers. */
10058 memfn_quals = TYPE_UNQUALIFIED;
10059 rqual = REF_QUAL_NONE;
10062 if (type_uses_auto (type))
10064 error ("typedef declared %<auto%>");
10065 type = error_mark_node;
10068 if (decl_context == FIELD)
10069 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
10071 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
10072 if (id_declarator && declarator->u.id.qualifying_scope) {
10073 error_at (DECL_SOURCE_LOCATION (decl),
10074 "typedef name may not be a nested-name-specifier");
10075 TREE_TYPE (decl) = error_mark_node;
10078 if (decl_context != FIELD)
10080 if (!current_function_decl)
10081 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10082 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
10083 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10084 (current_function_decl)))
10085 /* The TYPE_DECL is "abstract" because there will be
10086 clones of this constructor/destructor, and there will
10087 be copies of this TYPE_DECL generated in those
10089 DECL_ABSTRACT (decl) = 1;
10091 else if (current_class_type
10092 && constructor_name_p (unqualified_id, current_class_type))
10093 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
10094 "as enclosing class",
10097 /* If the user declares "typedef struct {...} foo" then the
10098 struct will have an anonymous name. Fill that name in now.
10099 Nothing can refer to it, so nothing needs know about the name
10101 if (type != error_mark_node
10103 && TYPE_NAME (type)
10104 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10105 && TYPE_ANONYMOUS_P (type)
10106 && declspecs->type_definition_p
10107 && cp_type_quals (type) == TYPE_UNQUALIFIED)
10111 /* Replace the anonymous name with the real name everywhere. */
10112 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10114 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
10115 /* We do not rename the debug info representing the
10116 anonymous tagged type because the standard says in
10117 [dcl.typedef] that the naming applies only for
10118 linkage purposes. */
10119 /*debug_hooks->set_name (t, decl);*/
10120 TYPE_NAME (t) = decl;
10123 if (TYPE_LANG_SPECIFIC (type))
10124 TYPE_WAS_ANONYMOUS (type) = 1;
10126 /* If this is a typedef within a template class, the nested
10127 type is a (non-primary) template. The name for the
10128 template needs updating as well. */
10129 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10130 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10131 = TYPE_IDENTIFIER (type);
10133 /* Adjust linkage now that we aren't anonymous anymore. */
10134 reset_type_linkage (type);
10136 /* FIXME remangle member functions; member functions of a
10137 type with external linkage have external linkage. */
10141 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10142 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10144 bad_specifiers (decl, BSP_TYPE, virtualp,
10145 memfn_quals != TYPE_UNQUALIFIED,
10146 inlinep, friendp, raises != NULL_TREE);
10148 if (decl_spec_seq_has_spec_p (declspecs, ds_alias))
10149 /* Acknowledge that this was written:
10150 `using analias = atype;'. */
10151 TYPE_DECL_ALIAS_P (decl) = 1;
10156 /* Detect the case of an array type of unspecified size
10157 which came, as such, direct from a typedef name.
10158 We must copy the type, so that the array's domain can be
10159 individually set by the object's initializer. */
10161 if (type && typedef_type
10162 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
10163 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
10164 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
10166 /* Detect where we're using a typedef of function type to declare a
10167 function. PARMS will not be set, so we must create it now. */
10169 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
10171 tree decls = NULL_TREE;
10174 for (args = TYPE_ARG_TYPES (type);
10175 args && args != void_list_node;
10176 args = TREE_CHAIN (args))
10178 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
10180 DECL_CHAIN (decl) = decls;
10184 parms = nreverse (decls);
10186 if (decl_context != TYPENAME)
10188 /* A cv-qualifier-seq shall only be part of the function type
10189 for a non-static member function. A ref-qualifier shall only
10190 .... /same as above/ [dcl.fct] */
10191 if ((type_memfn_quals (type) != TYPE_UNQUALIFIED
10192 || type_memfn_rqual (type) != REF_QUAL_NONE)
10193 && (current_class_type == NULL_TREE || staticp) )
10196 ? G_("qualified function types cannot be used to "
10197 "declare static member functions")
10198 : G_("qualified function types cannot be used to "
10199 "declare free functions"));
10200 type = TYPE_MAIN_VARIANT (type);
10203 /* The qualifiers on the function type become the qualifiers on
10204 the non-static member function. */
10205 memfn_quals |= type_memfn_quals (type);
10206 rqual = type_memfn_rqual (type);
10207 type_quals = TYPE_UNQUALIFIED;
10211 /* If this is a type name (such as, in a cast or sizeof),
10212 compute the type and return it now. */
10214 if (decl_context == TYPENAME)
10216 /* Note that the grammar rejects storage classes
10217 in typenames, fields or parameters. */
10218 if (type_quals != TYPE_UNQUALIFIED)
10219 type_quals = TYPE_UNQUALIFIED;
10221 /* Special case: "friend class foo" looks like a TYPENAME context. */
10224 if (type_quals != TYPE_UNQUALIFIED)
10226 error ("type qualifiers specified for friend class declaration");
10227 type_quals = TYPE_UNQUALIFIED;
10231 error ("%<inline%> specified for friend class declaration");
10237 /* Don't allow friend declaration without a class-key. */
10238 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10239 permerror (input_location, "template parameters cannot be friends");
10240 else if (TREE_CODE (type) == TYPENAME_TYPE)
10241 permerror (input_location, "friend declaration requires class-key, "
10242 "i.e. %<friend class %T::%D%>",
10243 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
10245 permerror (input_location, "friend declaration requires class-key, "
10246 "i.e. %<friend %#T%>",
10250 /* Only try to do this stuff if we didn't already give up. */
10251 if (type != integer_type_node)
10253 /* A friendly class? */
10254 if (current_class_type)
10255 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
10256 /*complain=*/true);
10258 error ("trying to make class %qT a friend of global scope",
10261 type = void_type_node;
10264 else if (memfn_quals || rqual)
10266 if (ctype == NULL_TREE
10267 && TREE_CODE (type) == METHOD_TYPE)
10268 ctype = TYPE_METHOD_BASETYPE (type);
10271 type = build_memfn_type (type, ctype, memfn_quals, rqual);
10272 /* Core issue #547: need to allow this in template type args.
10273 Allow it in general in C++11 for alias-declarations. */
10274 else if ((template_type_arg || cxx_dialect >= cxx11)
10275 && TREE_CODE (type) == FUNCTION_TYPE)
10276 type = apply_memfn_quals (type, memfn_quals, rqual);
10278 error ("invalid qualifiers on non-member function type");
10283 else if (unqualified_id == NULL_TREE && decl_context != PARM
10284 && decl_context != CATCHPARM
10285 && TREE_CODE (type) != UNION_TYPE
10288 error ("abstract declarator %qT used as declaration", type);
10289 return error_mark_node;
10292 /* Only functions may be declared using an operator-function-id. */
10294 && IDENTIFIER_OPNAME_P (unqualified_id)
10295 && TREE_CODE (type) != FUNCTION_TYPE
10296 && TREE_CODE (type) != METHOD_TYPE)
10298 error ("declaration of %qD as non-function", unqualified_id);
10299 return error_mark_node;
10302 /* We don't check parameter types here because we can emit a better
10303 error message later. */
10304 if (decl_context != PARM)
10306 type = check_var_type (unqualified_id, type);
10307 if (type == error_mark_node)
10308 return error_mark_node;
10311 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10312 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10314 if (decl_context == PARM || decl_context == CATCHPARM)
10316 if (ctype || in_namespace)
10317 error ("cannot use %<::%> in parameter declaration");
10319 if (type_uses_auto (type))
10321 error ("parameter declared %<auto%>");
10322 type = error_mark_node;
10325 /* A parameter declared as an array of T is really a pointer to T.
10326 One declared as a function is really a pointer to a function.
10327 One declared as a member is really a pointer to member. */
10329 if (TREE_CODE (type) == ARRAY_TYPE)
10331 /* Transfer const-ness of array into that of type pointed to. */
10332 type = build_pointer_type (TREE_TYPE (type));
10333 type_quals = TYPE_UNQUALIFIED;
10335 else if (TREE_CODE (type) == FUNCTION_TYPE)
10336 type = build_pointer_type (type);
10339 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
10340 && !NEW_DELETE_OPNAME_P (unqualified_id))
10342 cp_cv_quals real_quals = memfn_quals;
10343 if (constexpr_p && sfk != sfk_constructor && sfk != sfk_destructor)
10344 real_quals |= TYPE_QUAL_CONST;
10345 type = build_memfn_type (type, ctype, real_quals, rqual);
10351 if (decl_context == PARM)
10353 decl = cp_build_parm_decl (unqualified_id, type);
10355 bad_specifiers (decl, BSP_PARM, virtualp,
10356 memfn_quals != TYPE_UNQUALIFIED,
10357 inlinep, friendp, raises != NULL_TREE);
10359 else if (decl_context == FIELD)
10361 if (!staticp && TREE_CODE (type) != METHOD_TYPE
10362 && type_uses_auto (type))
10364 error ("non-static data member declared %<auto%>");
10365 type = error_mark_node;
10368 /* The C99 flexible array extension. */
10369 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
10370 && TYPE_DOMAIN (type) == NULL_TREE)
10372 tree itype = compute_array_index_type (dname, integer_zero_node,
10373 tf_warning_or_error);
10374 type = build_cplus_array_type (TREE_TYPE (type), itype);
10377 if (type == error_mark_node)
10379 /* Happens when declaring arrays of sizes which
10380 are error_mark_node, for example. */
10383 else if (in_namespace && !friendp)
10385 /* Something like struct S { int N::j; }; */
10386 error ("invalid use of %<::%>");
10387 return error_mark_node;
10389 else if (TREE_CODE (type) == FUNCTION_TYPE
10390 || TREE_CODE (type) == METHOD_TYPE)
10393 tree function_context;
10397 /* This should never happen in pure C++ (the check
10398 could be an assert). It could happen in
10399 Objective-C++ if someone writes invalid code that
10400 uses a function declaration for an instance
10401 variable or property (instance variables and
10402 properties are parsed as FIELD_DECLs, but they are
10403 part of an Objective-C class, not a C++ class).
10404 That code is invalid and is caught by this
10408 error ("declaration of function %qD in invalid context",
10410 return error_mark_node;
10413 /* ``A union may [ ... ] not [ have ] virtual functions.''
10415 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10417 error ("function %qD declared virtual inside a union",
10419 return error_mark_node;
10422 if (NEW_DELETE_OPNAME_P (unqualified_id))
10426 error ("%qD cannot be declared virtual, since it "
10427 "is always static",
10434 /* Check that the name used for a destructor makes sense. */
10435 if (sfk == sfk_destructor)
10437 tree uqname = id_declarator->u.id.unqualified_name;
10441 gcc_assert (friendp);
10442 error ("expected qualified name in friend declaration "
10443 "for destructor %qD", uqname);
10444 return error_mark_node;
10447 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
10449 error ("declaration of %qD as member of %qT",
10451 return error_mark_node;
10455 error ("a destructor cannot be %<constexpr%>");
10456 return error_mark_node;
10459 else if (sfk == sfk_constructor && friendp && !ctype)
10461 error ("expected qualified name in friend declaration "
10462 "for constructor %qD",
10463 id_declarator->u.id.unqualified_name);
10464 return error_mark_node;
10467 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10468 function_context = (ctype != NULL_TREE) ?
10469 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10470 publicp = (! friendp || ! staticp)
10471 && function_context == NULL_TREE;
10472 decl = grokfndecl (ctype, type,
10473 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
10474 ? unqualified_id : dname,
10477 virtualp, flags, memfn_quals, rqual, raises,
10478 friendp ? -1 : 0, friendp, publicp,
10479 inlinep | (2 * constexpr_p),
10481 funcdef_flag, template_count, in_namespace,
10482 attrlist, declarator->id_loc);
10483 decl = set_virt_specifiers (decl, virt_specifiers);
10484 if (decl == NULL_TREE)
10485 return error_mark_node;
10487 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10488 /* The decl and setting of decl_attr is also turned off. */
10489 decl = build_decl_attribute_variant (decl, decl_attr);
10492 /* [class.conv.ctor]
10494 A constructor declared without the function-specifier
10495 explicit that can be called with a single parameter
10496 specifies a conversion from the type of its first
10497 parameter to the type of its class. Such a constructor
10498 is called a converting constructor. */
10499 if (explicitp == 2)
10500 DECL_NONCONVERTING_P (decl) = 1;
10502 else if (!staticp && !dependent_type_p (type)
10503 && !COMPLETE_TYPE_P (complete_type (type))
10504 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
10506 if (unqualified_id)
10507 error ("field %qD has incomplete type", unqualified_id);
10509 error ("name %qT has incomplete type", type);
10511 /* If we're instantiating a template, tell them which
10512 instantiation made the field's type be incomplete. */
10513 if (current_class_type
10514 && TYPE_NAME (current_class_type)
10515 && IDENTIFIER_TEMPLATE (current_class_name)
10517 && declspecs->type == type)
10518 error (" in instantiation of template %qT",
10519 current_class_type);
10521 return error_mark_node;
10527 error ("%qE is neither function nor member function; "
10528 "cannot be declared friend", unqualified_id);
10536 /* Friends are treated specially. */
10537 if (ctype == current_class_type)
10538 ; /* We already issued a permerror. */
10539 else if (decl && DECL_NAME (decl))
10541 if (template_class_depth (current_class_type) == 0)
10543 decl = check_explicit_specialization
10544 (unqualified_id, decl, template_count,
10545 2 * funcdef_flag + 4);
10546 if (decl == error_mark_node)
10547 return error_mark_node;
10550 decl = do_friend (ctype, unqualified_id, decl,
10556 return error_mark_node;
10559 /* Structure field. It may not be a function, except for C++. */
10561 if (decl == NULL_TREE)
10565 /* C++ allows static class members. All other work
10566 for this is done by grokfield. */
10567 decl = build_lang_decl_loc (declarator->id_loc,
10568 VAR_DECL, unqualified_id, type);
10569 set_linkage_for_static_data_member (decl);
10570 /* Even if there is an in-class initialization, DECL
10571 is considered undefined until an out-of-class
10572 definition is provided. */
10573 DECL_EXTERNAL (decl) = 1;
10577 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
10578 if (declspecs->gnu_thread_keyword_p)
10579 DECL_GNU_TLS_P (decl) = true;
10582 if (constexpr_p && !initialized)
10584 error ("constexpr static data member %qD must have an "
10585 "initializer", decl);
10586 constexpr_p = false;
10593 error ("non-static data member %qE declared %<constexpr%>",
10595 constexpr_p = false;
10597 decl = build_decl (input_location,
10598 FIELD_DECL, unqualified_id, type);
10599 DECL_NONADDRESSABLE_P (decl) = bitfield;
10600 if (bitfield && !unqualified_id)
10601 TREE_NO_WARNING (decl) = 1;
10603 if (storage_class == sc_mutable)
10605 DECL_MUTABLE_P (decl) = 1;
10606 storage_class = sc_none;
10611 /* An attempt is being made to initialize a non-static
10612 member. This is new in C++11. */
10613 maybe_warn_cpp0x (CPP0X_NSDMI);
10615 /* If this has been parsed with static storage class, but
10616 errors forced staticp to be cleared, ensure NSDMI is
10618 if (declspecs->storage_class == sc_static)
10619 DECL_INITIAL (decl) = error_mark_node;
10623 bad_specifiers (decl, BSP_FIELD, virtualp,
10624 memfn_quals != TYPE_UNQUALIFIED,
10625 inlinep, friendp, raises != NULL_TREE);
10628 else if (TREE_CODE (type) == FUNCTION_TYPE
10629 || TREE_CODE (type) == METHOD_TYPE)
10631 tree original_name;
10634 if (!unqualified_id)
10635 return error_mark_node;
10637 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
10638 original_name = dname;
10640 original_name = unqualified_id;
10642 if (storage_class == sc_auto)
10643 error ("storage class %<auto%> invalid for function %qs", name);
10644 else if (storage_class == sc_register)
10645 error ("storage class %<register%> invalid for function %qs", name);
10648 if (declspecs->gnu_thread_keyword_p)
10649 error ("storage class %<__thread%> invalid for function %qs",
10652 error ("storage class %<thread_local%> invalid for function %qs",
10656 if (virt_specifiers)
10657 error ("virt-specifiers in %qs not allowed outside a class definition", name);
10658 /* Function declaration not at top level.
10659 Storage classes other than `extern' are not allowed
10660 and `extern' makes no difference. */
10661 if (! toplevel_bindings_p ()
10662 && (storage_class == sc_static
10663 || decl_spec_seq_has_spec_p (declspecs, ds_inline))
10666 if (storage_class == sc_static)
10667 pedwarn (input_location, OPT_Wpedantic,
10668 "%<static%> specified invalid for function %qs "
10669 "declared out of global scope", name);
10671 pedwarn (input_location, OPT_Wpedantic,
10672 "%<inline%> specifier invalid for function %qs "
10673 "declared out of global scope", name);
10676 if (ctype == NULL_TREE)
10680 error ("virtual non-class function %qs", name);
10683 else if (sfk == sfk_constructor
10684 || sfk == sfk_destructor)
10686 error (funcdef_flag
10687 ? G_("%qs defined in a non-class scope")
10688 : G_("%qs declared in a non-class scope"), name);
10693 /* Record whether the function is public. */
10694 publicp = (ctype != NULL_TREE
10695 || storage_class != sc_static);
10697 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
10698 virtualp, flags, memfn_quals, rqual, raises,
10700 publicp, inlinep | (2 * constexpr_p), sfk,
10702 template_count, in_namespace, attrlist,
10703 declarator->id_loc);
10704 if (decl == NULL_TREE)
10705 return error_mark_node;
10709 int invalid_static = 0;
10711 /* Don't allow a static member function in a class, and forbid
10712 declaring main to be static. */
10713 if (TREE_CODE (type) == METHOD_TYPE)
10715 permerror (input_location, "cannot declare member function %qD to have "
10716 "static linkage", decl);
10717 invalid_static = 1;
10719 else if (current_function_decl)
10721 /* FIXME need arm citation */
10722 error ("cannot declare static function inside another function");
10723 invalid_static = 1;
10726 if (invalid_static)
10729 storage_class = sc_none;
10735 /* It's a variable. */
10737 /* An uninitialized decl with `extern' is a reference. */
10738 decl = grokvardecl (type, unqualified_id,
10741 (type_quals & TYPE_QUAL_CONST) != 0,
10742 ctype ? ctype : in_namespace);
10743 bad_specifiers (decl, BSP_VAR, virtualp,
10744 memfn_quals != TYPE_UNQUALIFIED,
10745 inlinep, friendp, raises != NULL_TREE);
10749 DECL_CONTEXT (decl) = ctype;
10752 permerror (input_location, "%<static%> may not be used when defining "
10753 "(as opposed to declaring) a static data member");
10755 storage_class = sc_none;
10757 if (storage_class == sc_register && TREE_STATIC (decl))
10759 error ("static member %qD declared %<register%>", decl);
10760 storage_class = sc_none;
10762 if (storage_class == sc_extern && pedantic)
10764 pedwarn (input_location, OPT_Wpedantic,
10765 "cannot explicitly declare member %q#D to have "
10766 "extern linkage", decl);
10767 storage_class = sc_none;
10770 else if (constexpr_p && DECL_EXTERNAL (decl))
10772 error ("declaration of constexpr variable %qD is not a definition",
10774 constexpr_p = false;
10778 if (storage_class == sc_extern && initialized && !funcdef_flag)
10780 if (toplevel_bindings_p ())
10782 /* It's common practice (and completely valid) to have a const
10783 be initialized and declared extern. */
10784 if (!(type_quals & TYPE_QUAL_CONST))
10785 warning (0, "%qs initialized and declared %<extern%>", name);
10789 error ("%qs has both %<extern%> and initializer", name);
10790 return error_mark_node;
10794 /* Record `register' declaration for warnings on &
10795 and in case doing stupid register allocation. */
10797 if (storage_class == sc_register)
10798 DECL_REGISTER (decl) = 1;
10799 else if (storage_class == sc_extern)
10800 DECL_THIS_EXTERN (decl) = 1;
10801 else if (storage_class == sc_static)
10802 DECL_THIS_STATIC (decl) = 1;
10804 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10805 if (constexpr_p && TREE_CODE (decl) == VAR_DECL)
10806 DECL_DECLARED_CONSTEXPR_P (decl) = true;
10808 /* Record constancy and volatility on the DECL itself . There's
10809 no need to do this when processing a template; we'll do this
10810 for the instantiated declaration based on the type of DECL. */
10811 if (!processing_template_decl)
10812 cp_apply_type_quals_to_decl (type_quals, decl);
10818 /* Subroutine of start_function. Ensure that each of the parameter
10819 types (as listed in PARMS) is complete, as is required for a
10820 function definition. */
10823 require_complete_types_for_parms (tree parms)
10825 for (; parms; parms = DECL_CHAIN (parms))
10827 if (dependent_type_p (TREE_TYPE (parms)))
10829 if (!VOID_TYPE_P (TREE_TYPE (parms))
10830 && complete_type_or_else (TREE_TYPE (parms), parms))
10832 relayout_decl (parms);
10833 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
10836 /* grokparms or complete_type_or_else will have already issued
10838 TREE_TYPE (parms) = error_mark_node;
10842 /* Returns nonzero if T is a local variable. */
10845 local_variable_p (const_tree t)
10847 if ((TREE_CODE (t) == VAR_DECL
10848 /* A VAR_DECL with a context that is a _TYPE is a static data
10850 && !TYPE_P (CP_DECL_CONTEXT (t))
10851 /* Any other non-local variable must be at namespace scope. */
10852 && !DECL_NAMESPACE_SCOPE_P (t))
10853 || (TREE_CODE (t) == PARM_DECL))
10859 /* Like local_variable_p, but suitable for use as a tree-walking
10863 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
10866 if (local_variable_p (*tp)
10867 && (!DECL_ARTIFICIAL (*tp) || DECL_NAME (*tp) == this_identifier))
10869 else if (TYPE_P (*tp))
10870 *walk_subtrees = 0;
10875 /* Check that ARG, which is a default-argument expression for a
10876 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10877 something goes wrong. DECL may also be a _TYPE node, rather than a
10878 DECL, if there is no DECL available. */
10881 check_default_argument (tree decl, tree arg, tsubst_flags_t complain)
10886 if (TREE_CODE (arg) == DEFAULT_ARG)
10887 /* We get a DEFAULT_ARG when looking at an in-class declaration
10888 with a default argument. Ignore the argument for now; we'll
10889 deal with it after the class is complete. */
10898 decl_type = TREE_TYPE (decl);
10900 if (arg == error_mark_node
10901 || decl == error_mark_node
10902 || TREE_TYPE (arg) == error_mark_node
10903 || decl_type == error_mark_node)
10904 /* Something already went wrong. There's no need to check
10906 return error_mark_node;
10908 /* [dcl.fct.default]
10910 A default argument expression is implicitly converted to the
10912 ++cp_unevaluated_operand;
10913 perform_implicit_conversion_flags (decl_type, arg, complain,
10915 --cp_unevaluated_operand;
10917 if (warn_zero_as_null_pointer_constant
10918 && TYPE_PTR_OR_PTRMEM_P (decl_type)
10919 && null_ptr_cst_p (arg)
10920 && (complain & tf_warning)
10921 && maybe_warn_zero_as_null_pointer_constant (arg, input_location))
10922 return nullptr_node;
10924 /* [dcl.fct.default]
10926 Local variables shall not be used in default argument
10929 The keyword `this' shall not be used in a default argument of a
10930 member function. */
10931 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
10934 if (complain & tf_warning_or_error)
10936 if (DECL_NAME (var) == this_identifier)
10937 permerror (input_location, "default argument %qE uses %qD",
10940 error ("default argument %qE uses local variable %qD", arg, var);
10942 return error_mark_node;
10949 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
10952 type_is_deprecated (tree type)
10954 enum tree_code code;
10955 if (TREE_DEPRECATED (type))
10957 if (TYPE_NAME (type)
10958 && TREE_DEPRECATED (TYPE_NAME (type)))
10961 /* Do warn about using typedefs to a deprecated class. */
10962 if (TAGGED_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
10963 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
10965 code = TREE_CODE (type);
10967 if (code == POINTER_TYPE || code == REFERENCE_TYPE
10968 || code == OFFSET_TYPE || code == FUNCTION_TYPE
10969 || code == METHOD_TYPE || code == ARRAY_TYPE)
10970 return type_is_deprecated (TREE_TYPE (type));
10972 if (TYPE_PTRMEMFUNC_P (type))
10973 return type_is_deprecated
10974 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
10979 /* Decode the list of parameter types for a function type.
10980 Given the list of things declared inside the parens,
10981 return a list of types.
10983 If this parameter does not end with an ellipsis, we append
10986 *PARMS is set to the chain of PARM_DECLs created. */
10989 grokparms (tree parmlist, tree *parms)
10991 tree result = NULL_TREE;
10992 tree decls = NULL_TREE;
10996 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
10998 tree type = NULL_TREE;
10999 tree init = TREE_PURPOSE (parm);
11000 tree decl = TREE_VALUE (parm);
11001 const char *errmsg;
11003 if (parm == void_list_node)
11006 if (! decl || TREE_TYPE (decl) == error_mark_node)
11009 type = TREE_TYPE (decl);
11010 if (VOID_TYPE_P (type))
11012 if (same_type_p (type, void_type_node)
11013 && DECL_SELF_REFERENCE_P (type)
11014 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
11015 /* this is a parmlist of `(void)', which is ok. */
11017 cxx_incomplete_type_error (decl, type);
11018 /* It's not a good idea to actually create parameters of
11019 type `void'; other parts of the compiler assume that a
11020 void type terminates the parameter list. */
11021 type = error_mark_node;
11022 TREE_TYPE (decl) = error_mark_node;
11025 if (type != error_mark_node
11026 && TYPE_FOR_JAVA (type)
11027 && MAYBE_CLASS_TYPE_P (type))
11029 error ("parameter %qD has Java class type", decl);
11030 type = error_mark_node;
11031 TREE_TYPE (decl) = error_mark_node;
11035 if (type != error_mark_node
11036 && (errmsg = targetm.invalid_parameter_type (type)))
11039 type = error_mark_node;
11040 TREE_TYPE (decl) = error_mark_node;
11043 if (type != error_mark_node)
11045 if (deprecated_state != DEPRECATED_SUPPRESS)
11047 tree deptype = type_is_deprecated (type);
11049 warn_deprecated_use (deptype, NULL_TREE);
11052 /* Top-level qualifiers on the parameters are
11053 ignored for function types. */
11054 type = cp_build_qualified_type (type, 0);
11055 if (TREE_CODE (type) == METHOD_TYPE)
11057 error ("parameter %qD invalidly declared method type", decl);
11058 type = build_pointer_type (type);
11059 TREE_TYPE (decl) = type;
11061 else if (abstract_virtuals_error (decl, type))
11062 any_error = 1; /* Seems like a good idea. */
11063 else if (POINTER_TYPE_P (type))
11065 /* [dcl.fct]/6, parameter types cannot contain pointers
11066 (references) to arrays of unknown bound. */
11067 tree t = TREE_TYPE (type);
11068 int ptr = TYPE_PTR_P (type);
11072 if (TYPE_PTR_P (t))
11074 else if (TREE_CODE (t) != ARRAY_TYPE)
11076 else if (!TYPE_DOMAIN (t))
11080 if (TREE_CODE (t) == ARRAY_TYPE)
11082 ? G_("parameter %qD includes pointer to array of "
11083 "unknown bound %qT")
11084 : G_("parameter %qD includes reference to array of "
11085 "unknown bound %qT"),
11091 else if (init && !processing_template_decl)
11092 init = check_default_argument (decl, init, tf_warning_or_error);
11095 DECL_CHAIN (decl) = decls;
11097 result = tree_cons (init, type, result);
11099 decls = nreverse (decls);
11100 result = nreverse (result);
11102 result = chainon (result, void_list_node);
11109 /* D is a constructor or overloaded `operator='.
11111 Let T be the class in which D is declared. Then, this function
11114 -1 if D's is an ill-formed constructor or copy assignment operator
11115 whose first parameter is of type `T'.
11116 0 if D is not a copy constructor or copy assignment
11118 1 if D is a copy constructor or copy assignment operator whose
11119 first parameter is a reference to non-const qualified T.
11120 2 if D is a copy constructor or copy assignment operator whose
11121 first parameter is a reference to const qualified T.
11123 This function can be used as a predicate. Positive values indicate
11124 a copy constructor and nonzero values indicate a copy assignment
11128 copy_fn_p (const_tree d)
11134 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
11136 if (TREE_CODE (d) == TEMPLATE_DECL
11137 || (DECL_TEMPLATE_INFO (d)
11138 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
11139 /* Instantiations of template member functions are never copy
11140 functions. Note that member functions of templated classes are
11141 represented as template functions internally, and we must
11142 accept those as copy functions. */
11145 args = FUNCTION_FIRST_USER_PARMTYPE (d);
11149 arg_type = TREE_VALUE (args);
11150 if (arg_type == error_mark_node)
11153 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
11155 /* Pass by value copy assignment operator. */
11158 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
11159 && !TYPE_REF_IS_RVALUE (arg_type)
11160 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
11162 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
11168 args = TREE_CHAIN (args);
11170 if (args && args != void_list_node && !TREE_PURPOSE (args))
11171 /* There are more non-optional args. */
11177 /* D is a constructor or overloaded `operator='.
11179 Let T be the class in which D is declared. Then, this function
11180 returns true when D is a move constructor or move assignment
11181 operator, false otherwise. */
11184 move_fn_p (const_tree d)
11186 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
11188 if (cxx_dialect == cxx98)
11189 /* There are no move constructors if we are in C++98 mode. */
11192 if (TREE_CODE (d) == TEMPLATE_DECL
11193 || (DECL_TEMPLATE_INFO (d)
11194 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
11195 /* Instantiations of template member functions are never move
11196 functions. Note that member functions of templated classes are
11197 represented as template functions internally, and we must
11198 accept those as move functions. */
11201 return move_signature_fn_p (d);
11204 /* D is a constructor or overloaded `operator='.
11206 Then, this function returns true when D has the same signature as a move
11207 constructor or move assignment operator (because either it is such a
11208 ctor/op= or it is a template specialization with the same signature),
11209 false otherwise. */
11212 move_signature_fn_p (const_tree d)
11216 bool result = false;
11218 args = FUNCTION_FIRST_USER_PARMTYPE (d);
11222 arg_type = TREE_VALUE (args);
11223 if (arg_type == error_mark_node)
11226 if (TREE_CODE (arg_type) == REFERENCE_TYPE
11227 && TYPE_REF_IS_RVALUE (arg_type)
11228 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
11232 args = TREE_CHAIN (args);
11234 if (args && args != void_list_node && !TREE_PURPOSE (args))
11235 /* There are more non-optional args. */
11241 /* Remember any special properties of member function DECL. */
11244 grok_special_member_properties (tree decl)
11248 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
11251 class_type = DECL_CONTEXT (decl);
11252 if (DECL_CONSTRUCTOR_P (decl))
11254 int ctor = copy_fn_p (decl);
11256 if (!DECL_ARTIFICIAL (decl))
11257 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
11263 A non-template constructor for class X is a copy
11264 constructor if its first parameter is of type X&, const
11265 X&, volatile X& or const volatile X&, and either there
11266 are no other parameters or else all other parameters have
11267 default arguments. */
11268 TYPE_HAS_COPY_CTOR (class_type) = 1;
11269 if (user_provided_p (decl))
11270 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
11272 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
11274 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
11276 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
11277 if (user_provided_p (decl))
11278 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
11280 else if (move_fn_p (decl) && user_provided_p (decl))
11281 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1;
11282 else if (is_list_ctor (decl))
11283 TYPE_HAS_LIST_CTOR (class_type) = 1;
11285 if (DECL_DECLARED_CONSTEXPR_P (decl)
11286 && !copy_fn_p (decl) && !move_fn_p (decl))
11287 TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
11289 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
11293 A non-template assignment operator for class X is a copy
11294 assignment operator if its parameter is of type X, X&, const
11295 X&, volatile X& or const volatile X&. */
11297 int assop = copy_fn_p (decl);
11301 TYPE_HAS_COPY_ASSIGN (class_type) = 1;
11302 if (user_provided_p (decl))
11303 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
11305 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
11307 else if (move_fn_p (decl) && user_provided_p (decl))
11308 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1;
11310 /* Destructors are handled in check_methods. */
11313 /* Check a constructor DECL has the correct form. Complains
11314 if the class has a constructor of the form X(X). */
11317 grok_ctor_properties (const_tree ctype, const_tree decl)
11319 int ctor_parm = copy_fn_p (decl);
11325 A declaration of a constructor for a class X is ill-formed if
11326 its first parameter is of type (optionally cv-qualified) X
11327 and either there are no other parameters or else all other
11328 parameters have default arguments.
11330 We *don't* complain about member template instantiations that
11331 have this form, though; they can occur as we try to decide
11332 what constructor to use during overload resolution. Since
11333 overload resolution will never prefer such a constructor to
11334 the non-template copy constructor (which is either explicitly
11335 or implicitly defined), there's no need to worry about their
11336 existence. Theoretically, they should never even be
11337 instantiated, but that's hard to forestall. */
11338 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11346 /* An operator with this code is unary, but can also be binary. */
11349 ambi_op_p (enum tree_code code)
11351 return (code == INDIRECT_REF
11352 || code == ADDR_EXPR
11353 || code == UNARY_PLUS_EXPR
11354 || code == NEGATE_EXPR
11355 || code == PREINCREMENT_EXPR
11356 || code == PREDECREMENT_EXPR);
11359 /* An operator with this name can only be unary. */
11362 unary_op_p (enum tree_code code)
11364 return (code == TRUTH_NOT_EXPR
11365 || code == BIT_NOT_EXPR
11366 || code == COMPONENT_REF
11367 || code == TYPE_EXPR);
11370 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11371 errors are issued for invalid declarations. */
11374 grok_op_properties (tree decl, bool complain)
11376 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11378 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11379 tree name = DECL_NAME (decl);
11380 enum tree_code operator_code;
11385 /* Count the number of arguments and check for ellipsis. */
11386 for (argtype = argtypes, arity = 0;
11387 argtype && argtype != void_list_node;
11388 argtype = TREE_CHAIN (argtype))
11390 ellipsis_p = !argtype;
11392 class_type = DECL_CONTEXT (decl);
11393 if (class_type && !CLASS_TYPE_P (class_type))
11394 class_type = NULL_TREE;
11396 if (DECL_CONV_FN_P (decl))
11397 operator_code = TYPE_EXPR;
11401 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11402 if (ansi_opname (CODE) == name) \
11404 operator_code = (CODE); \
11407 else if (ansi_assopname (CODE) == name) \
11409 operator_code = (CODE); \
11410 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11414 #include "operators.def"
11415 #undef DEF_OPERATOR
11417 gcc_unreachable ();
11420 gcc_assert (operator_code != MAX_TREE_CODES);
11421 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11424 switch (operator_code)
11427 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
11431 TYPE_GETS_DELETE (class_type) |= 1;
11435 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
11438 case VEC_DELETE_EXPR:
11439 TYPE_GETS_DELETE (class_type) |= 2;
11446 /* [basic.std.dynamic.allocation]/1:
11448 A program is ill-formed if an allocation function is declared
11449 in a namespace scope other than global scope or declared static
11452 The same also holds true for deallocation functions. */
11453 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
11454 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11456 if (DECL_NAMESPACE_SCOPE_P (decl))
11458 if (CP_DECL_CONTEXT (decl) != global_namespace)
11460 error ("%qD may not be declared within a namespace", decl);
11463 else if (!TREE_PUBLIC (decl))
11465 error ("%qD may not be declared as static", decl);
11471 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
11473 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11474 DECL_IS_OPERATOR_NEW (decl) = 1;
11476 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11477 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11480 /* An operator function must either be a non-static member function
11481 or have at least one parameter of a class, a reference to a class,
11482 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11483 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11485 if (operator_code == TYPE_EXPR
11486 || operator_code == CALL_EXPR
11487 || operator_code == COMPONENT_REF
11488 || operator_code == ARRAY_REF
11489 || operator_code == NOP_EXPR)
11491 error ("%qD must be a nonstatic member function", decl);
11498 if (DECL_STATIC_FUNCTION_P (decl))
11500 error ("%qD must be either a non-static member "
11501 "function or a non-member function", decl);
11505 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
11507 tree arg = non_reference (TREE_VALUE (p));
11508 if (arg == error_mark_node)
11511 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11512 because these checks are performed even on
11513 template functions. */
11514 if (MAYBE_CLASS_TYPE_P (arg)
11515 || TREE_CODE (arg) == ENUMERAL_TYPE)
11519 if (!p || p == void_list_node)
11522 error ("%qD must have an argument of class or "
11523 "enumerated type", decl);
11529 /* There are no restrictions on the arguments to an overloaded
11531 if (operator_code == CALL_EXPR)
11534 /* Warn about conversion operators that will never be used. */
11535 if (IDENTIFIER_TYPENAME_P (name)
11536 && ! DECL_TEMPLATE_INFO (decl)
11538 /* Warn only declaring the function; there is no need to
11539 warn again about out-of-class definitions. */
11540 && class_type == current_class_type)
11542 tree t = TREE_TYPE (name);
11543 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11546 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11548 if (TREE_CODE (t) == VOID_TYPE)
11549 warning (OPT_Wconversion,
11551 ? G_("conversion to a reference to void "
11552 "will never use a type conversion operator")
11553 : G_("conversion to void "
11554 "will never use a type conversion operator"));
11555 else if (class_type)
11557 if (t == class_type)
11558 warning (OPT_Wconversion,
11560 ? G_("conversion to a reference to the same type "
11561 "will never use a type conversion operator")
11562 : G_("conversion to the same type "
11563 "will never use a type conversion operator"));
11564 /* Don't force t to be complete here. */
11565 else if (MAYBE_CLASS_TYPE_P (t)
11566 && COMPLETE_TYPE_P (t)
11567 && DERIVED_FROM_P (t, class_type))
11568 warning (OPT_Wconversion,
11570 ? G_("conversion to a reference to a base class "
11571 "will never use a type conversion operator")
11572 : G_("conversion to a base class "
11573 "will never use a type conversion operator"));
11578 if (operator_code == COND_EXPR)
11581 error ("ISO C++ prohibits overloading operator ?:");
11584 else if (ellipsis_p)
11586 error ("%qD must not have variable number of arguments", decl);
11589 else if (ambi_op_p (operator_code))
11592 /* We pick the one-argument operator codes by default, so
11593 we don't have to change anything. */
11595 else if (arity == 2)
11597 /* If we thought this was a unary operator, we now know
11598 it to be a binary operator. */
11599 switch (operator_code)
11602 operator_code = MULT_EXPR;
11606 operator_code = BIT_AND_EXPR;
11609 case UNARY_PLUS_EXPR:
11610 operator_code = PLUS_EXPR;
11614 operator_code = MINUS_EXPR;
11617 case PREINCREMENT_EXPR:
11618 operator_code = POSTINCREMENT_EXPR;
11621 case PREDECREMENT_EXPR:
11622 operator_code = POSTDECREMENT_EXPR;
11626 gcc_unreachable ();
11629 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11631 if ((operator_code == POSTINCREMENT_EXPR
11632 || operator_code == POSTDECREMENT_EXPR)
11633 && ! processing_template_decl
11634 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11637 error ("postfix %qD must take %<int%> as its argument",
11640 error ("postfix %qD must take %<int%> as its second "
11648 error ("%qD must take either zero or one argument", decl);
11650 error ("%qD must take either one or two arguments", decl);
11654 /* More Effective C++ rule 6. */
11656 && (operator_code == POSTINCREMENT_EXPR
11657 || operator_code == POSTDECREMENT_EXPR
11658 || operator_code == PREINCREMENT_EXPR
11659 || operator_code == PREDECREMENT_EXPR))
11661 tree arg = TREE_VALUE (argtypes);
11662 tree ret = TREE_TYPE (TREE_TYPE (decl));
11663 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
11664 arg = TREE_TYPE (arg);
11665 arg = TYPE_MAIN_VARIANT (arg);
11666 if (operator_code == PREINCREMENT_EXPR
11667 || operator_code == PREDECREMENT_EXPR)
11669 if (TREE_CODE (ret) != REFERENCE_TYPE
11670 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
11672 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
11673 build_reference_type (arg));
11677 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
11678 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
11682 else if (unary_op_p (operator_code))
11687 error ("%qD must take %<void%>", decl);
11689 error ("%qD must take exactly one argument", decl);
11693 else /* if (binary_op_p (operator_code)) */
11698 error ("%qD must take exactly one argument", decl);
11700 error ("%qD must take exactly two arguments", decl);
11704 /* More Effective C++ rule 7. */
11706 && (operator_code == TRUTH_ANDIF_EXPR
11707 || operator_code == TRUTH_ORIF_EXPR
11708 || operator_code == COMPOUND_EXPR))
11709 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
11713 /* Effective C++ rule 23. */
11716 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
11717 && (operator_code == PLUS_EXPR
11718 || operator_code == MINUS_EXPR
11719 || operator_code == TRUNC_DIV_EXPR
11720 || operator_code == MULT_EXPR
11721 || operator_code == TRUNC_MOD_EXPR)
11722 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
11723 warning (OPT_Weffc__, "%qD should return by value", decl);
11725 /* [over.oper]/8 */
11726 for (; argtypes && argtypes != void_list_node;
11727 argtypes = TREE_CHAIN (argtypes))
11728 if (TREE_PURPOSE (argtypes))
11730 TREE_PURPOSE (argtypes) = NULL_TREE;
11731 if (operator_code == POSTINCREMENT_EXPR
11732 || operator_code == POSTDECREMENT_EXPR)
11734 pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments",
11739 error ("%qD cannot have default arguments", decl);
11747 /* Return a string giving the keyword associate with CODE. */
11749 static const char *
11750 tag_name (enum tag_types code)
11762 case typename_type:
11765 gcc_unreachable ();
11769 /* Name lookup in an elaborated-type-specifier (after the keyword
11770 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11771 elaborated-type-specifier is invalid, issue a diagnostic and return
11772 error_mark_node; otherwise, return the *_TYPE to which it referred.
11773 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11776 check_elaborated_type_specifier (enum tag_types tag_code,
11778 bool allow_template_p)
11784 struct S { struct S *p; };
11786 name lookup will find the TYPE_DECL for the implicit "S::S"
11787 typedef. Adjust for that here. */
11788 if (DECL_SELF_REFERENCE_P (decl))
11789 decl = TYPE_NAME (TREE_TYPE (decl));
11791 type = TREE_TYPE (decl);
11793 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11794 is false for this case as well. */
11795 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
11797 error ("using template type parameter %qT after %qs",
11798 type, tag_name (tag_code));
11799 return error_mark_node;
11801 /* Accept template template parameters. */
11802 else if (allow_template_p
11803 && (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
11804 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM))
11808 If the identifier resolves to a typedef-name or the
11809 simple-template-id resolves to an alias template
11810 specialization, the elaborated-type-specifier is ill-formed.
11812 In other words, the only legitimate declaration to use in the
11813 elaborated type specifier is the implicit typedef created when
11814 the type is declared. */
11815 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
11816 && !DECL_SELF_REFERENCE_P (decl)
11817 && tag_code != typename_type)
11819 if (alias_template_specialization_p (type))
11820 error ("using alias template specialization %qT after %qs",
11821 type, tag_name (tag_code));
11823 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
11824 inform (DECL_SOURCE_LOCATION (decl),
11825 "%qD has a previous declaration here", decl);
11826 return error_mark_node;
11828 else if (TREE_CODE (type) != RECORD_TYPE
11829 && TREE_CODE (type) != UNION_TYPE
11830 && tag_code != enum_type
11831 && tag_code != typename_type)
11833 error ("%qT referred to as %qs", type, tag_name (tag_code));
11834 error ("%q+T has a previous declaration here", type);
11835 return error_mark_node;
11837 else if (TREE_CODE (type) != ENUMERAL_TYPE
11838 && tag_code == enum_type)
11840 error ("%qT referred to as enum", type);
11841 error ("%q+T has a previous declaration here", type);
11842 return error_mark_node;
11844 else if (!allow_template_p
11845 && TREE_CODE (type) == RECORD_TYPE
11846 && CLASSTYPE_IS_TEMPLATE (type))
11848 /* If a class template appears as elaborated type specifier
11849 without a template header such as:
11851 template <class T> class C {};
11852 void f(class C); // No template header here
11854 then the required template argument is missing. */
11855 error ("template argument required for %<%s %T%>",
11856 tag_name (tag_code),
11857 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
11858 return error_mark_node;
11864 /* Lookup NAME in elaborate type specifier in scope according to
11865 SCOPE and issue diagnostics if necessary.
11866 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11867 found, and ERROR_MARK_NODE for type error. */
11870 lookup_and_check_tag (enum tag_types tag_code, tree name,
11871 tag_scope scope, bool template_header_p)
11875 if (scope == ts_global)
11877 /* First try ordinary name lookup, ignoring hidden class name
11878 injected via friend declaration. */
11879 decl = lookup_name_prefer_type (name, 2);
11880 /* If that fails, the name will be placed in the smallest
11881 non-class, non-function-prototype scope according to 3.3.1/5.
11882 We may already have a hidden name declared as friend in this
11883 scope. So lookup again but not ignoring hidden names.
11884 If we find one, that name will be made visible rather than
11885 creating a new tag. */
11887 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
11890 decl = lookup_type_scope (name, scope);
11893 && (DECL_CLASS_TEMPLATE_P (decl)
11894 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl)))
11895 decl = DECL_TEMPLATE_RESULT (decl);
11897 if (decl && TREE_CODE (decl) == TYPE_DECL)
11899 /* Look for invalid nested type:
11903 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
11905 error ("%qD has the same name as the class in which it is "
11908 return error_mark_node;
11911 /* Two cases we need to consider when deciding if a class
11912 template is allowed as an elaborated type specifier:
11913 1. It is a self reference to its own class.
11914 2. It comes with a template header.
11918 template <class T> class C {
11919 class C *c1; // DECL_SELF_REFERENCE_P is true
11922 template <class U> class C; // template_header_p is true
11923 template <class T> class C<T>::D {
11924 class C *c2; // DECL_SELF_REFERENCE_P is true
11927 t = check_elaborated_type_specifier (tag_code,
11930 | DECL_SELF_REFERENCE_P (decl));
11933 else if (decl && TREE_CODE (decl) == TREE_LIST)
11935 error ("reference to %qD is ambiguous", name);
11936 print_candidates (decl);
11937 return error_mark_node;
11943 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
11944 Define the tag as a forward-reference if it is not defined.
11946 If a declaration is given, process it here, and report an error if
11947 multiple declarations are not identical.
11949 SCOPE is TS_CURRENT when this is also a definition. Only look in
11950 the current frame for the name (since C++ allows new names in any
11951 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
11952 declaration. Only look beginning from the current scope outward up
11953 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
11955 TEMPLATE_HEADER_P is true when this declaration is preceded by
11956 a set of template parameters. */
11959 xref_tag_1 (enum tag_types tag_code, tree name,
11960 tag_scope orig_scope, bool template_header_p)
11962 enum tree_code code;
11964 tree context = NULL_TREE;
11967 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
11973 code = RECORD_TYPE;
11979 code = ENUMERAL_TYPE;
11982 gcc_unreachable ();
11985 if (orig_scope == ts_lambda)
11986 scope = ts_current;
11988 scope = orig_scope;
11990 /* In case of anonymous name, xref_tag is only called to
11991 make type node and push name. Name lookup is not required. */
11992 if (ANON_AGGRNAME_P (name))
11995 t = lookup_and_check_tag (tag_code, name,
11996 scope, template_header_p);
11998 if (t == error_mark_node)
11999 return error_mark_node;
12001 if (scope != ts_current && t && current_class_type
12002 && template_class_depth (current_class_type)
12003 && template_header_p)
12005 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
12008 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12009 definition of this tag. Since, in addition, we are currently
12010 processing a (member) template declaration of a template
12011 class, we must be very careful; consider:
12018 { template <class V>
12019 friend struct S1; };
12021 Here, the S2::S1 declaration should not be confused with the
12022 outer declaration. In particular, the inner version should
12023 have a template parameter of level 2, not level 1. This
12024 would be particularly important if the member declaration
12027 template <class V = U> friend struct S1;
12029 say, when we should tsubst into `U' when instantiating
12030 S2. On the other hand, when presented with:
12040 we must find the inner binding eventually. We
12041 accomplish this by making sure that the new type we
12042 create to represent this declaration has the right
12044 context = TYPE_CONTEXT (t);
12050 /* If no such tag is yet defined, create a forward-reference node
12051 and record it as the "definition".
12052 When a real declaration of this type is found,
12053 the forward-reference will be altered into a real type. */
12054 if (code == ENUMERAL_TYPE)
12056 error ("use of enum %q#D without previous declaration", name);
12057 return error_mark_node;
12061 t = make_class_type (code);
12062 TYPE_CONTEXT (t) = context;
12063 if (orig_scope == ts_lambda)
12064 /* Remember that we're declaring a lambda to avoid bogus errors
12065 in push_template_decl. */
12066 CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node;
12067 t = pushtag (name, t, scope);
12072 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
12074 if (!redeclare_class_template (t, current_template_parms))
12075 return error_mark_node;
12077 else if (!processing_template_decl
12078 && CLASS_TYPE_P (t)
12079 && CLASSTYPE_IS_TEMPLATE (t))
12081 error ("redeclaration of %qT as a non-template", t);
12082 error ("previous declaration %q+D", t);
12083 return error_mark_node;
12086 /* Make injected friend class visible. */
12087 if (scope != ts_within_enclosing_non_class
12088 && hidden_name_p (TYPE_NAME (t)))
12090 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
12091 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
12093 if (TYPE_TEMPLATE_INFO (t))
12095 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
12096 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
12104 /* Wrapper for xref_tag_1. */
12107 xref_tag (enum tag_types tag_code, tree name,
12108 tag_scope scope, bool template_header_p)
12112 subtime = timevar_cond_start (TV_NAME_LOOKUP);
12113 ret = xref_tag_1 (tag_code, name, scope, template_header_p);
12114 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
12120 xref_tag_from_type (tree old, tree id, tag_scope scope)
12122 enum tag_types tag_kind;
12124 if (TREE_CODE (old) == RECORD_TYPE)
12125 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
12127 tag_kind = union_type;
12129 if (id == NULL_TREE)
12130 id = TYPE_IDENTIFIER (old);
12132 return xref_tag (tag_kind, id, scope, false);
12135 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12136 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12137 access_* node, and the TREE_VALUE is the type of the base-class.
12138 Non-NULL TREE_TYPE indicates virtual inheritance.
12140 Returns true if the binfo hierarchy was successfully created,
12141 false if an error was detected. */
12144 xref_basetypes (tree ref, tree base_list)
12147 tree binfo, base_binfo;
12148 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
12149 unsigned max_bases = 0; /* Maximum direct bases. */
12151 tree default_access;
12152 tree igo_prev; /* Track Inheritance Graph Order. */
12154 if (ref == error_mark_node)
12157 /* The base of a derived class is private by default, all others are
12159 default_access = (TREE_CODE (ref) == RECORD_TYPE
12160 && CLASSTYPE_DECLARED_CLASS (ref)
12161 ? access_private_node : access_public_node);
12163 /* First, make sure that any templates in base-classes are
12164 instantiated. This ensures that if we call ourselves recursively
12165 we do not get confused about which classes are marked and which
12167 basep = &base_list;
12170 tree basetype = TREE_VALUE (*basep);
12172 /* The dependent_type_p call below should really be dependent_scope_p
12173 so that we give a hard error about using an incomplete type as a
12174 base, but we allow it with a pedwarn for backward
12176 if (processing_template_decl
12177 && CLASS_TYPE_P (basetype) && TYPE_BEING_DEFINED (basetype))
12178 cxx_incomplete_type_diagnostic (NULL_TREE, basetype, DK_PEDWARN);
12179 if (!dependent_type_p (basetype)
12180 && !complete_type_or_else (basetype, NULL))
12181 /* An incomplete type. Remove it from the list. */
12182 *basep = TREE_CHAIN (*basep);
12186 if (TREE_TYPE (*basep))
12188 if (CLASS_TYPE_P (basetype))
12189 max_vbases += vec_safe_length (CLASSTYPE_VBASECLASSES (basetype));
12190 basep = &TREE_CHAIN (*basep);
12194 TYPE_MARKED_P (ref) = 1;
12196 /* The binfo slot should be empty, unless this is an (ill-formed)
12198 if (TYPE_BINFO (ref) && !TYPE_SIZE (ref))
12200 error ("redefinition of %q#T", ref);
12204 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
12206 binfo = make_tree_binfo (max_bases);
12208 TYPE_BINFO (ref) = binfo;
12209 BINFO_OFFSET (binfo) = size_zero_node;
12210 BINFO_TYPE (binfo) = ref;
12212 /* Apply base-class info set up to the variants of this type. */
12213 fixup_type_variants (ref);
12217 vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases);
12218 /* An aggregate cannot have baseclasses. */
12219 CLASSTYPE_NON_AGGREGATE (ref) = 1;
12221 if (TREE_CODE (ref) == UNION_TYPE)
12223 error ("derived union %qT invalid", ref);
12230 if (TYPE_FOR_JAVA (ref))
12232 error ("Java class %qT cannot have multiple bases", ref);
12239 vec_alloc (CLASSTYPE_VBASECLASSES (ref), max_vbases);
12241 if (TYPE_FOR_JAVA (ref))
12243 error ("Java class %qT cannot have virtual bases", ref);
12248 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
12250 tree access = TREE_PURPOSE (base_list);
12251 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
12252 tree basetype = TREE_VALUE (base_list);
12254 if (access == access_default_node)
12255 access = default_access;
12257 if (PACK_EXPANSION_P (basetype))
12258 basetype = PACK_EXPANSION_PATTERN (basetype);
12259 if (TREE_CODE (basetype) == TYPE_DECL)
12260 basetype = TREE_TYPE (basetype);
12261 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
12263 error ("base type %qT fails to be a struct or class type",
12268 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
12269 TYPE_FOR_JAVA (ref) = 1;
12271 base_binfo = NULL_TREE;
12272 if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
12274 base_binfo = TYPE_BINFO (basetype);
12275 /* The original basetype could have been a typedef'd type. */
12276 basetype = BINFO_TYPE (base_binfo);
12278 /* Inherit flags from the base. */
12279 TYPE_HAS_NEW_OPERATOR (ref)
12280 |= TYPE_HAS_NEW_OPERATOR (basetype);
12281 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12282 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12283 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12284 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
12285 CLASSTYPE_DIAMOND_SHAPED_P (ref)
12286 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
12287 CLASSTYPE_REPEATED_BASE_P (ref)
12288 |= CLASSTYPE_REPEATED_BASE_P (basetype);
12291 /* We must do this test after we've seen through a typedef
12293 if (TYPE_MARKED_P (basetype))
12295 if (basetype == ref)
12296 error ("recursive type %qT undefined", basetype);
12298 error ("duplicate base type %qT invalid", basetype);
12302 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
12303 /* Regenerate the pack expansion for the bases. */
12304 basetype = make_pack_expansion (basetype);
12306 TYPE_MARKED_P (basetype) = 1;
12308 base_binfo = copy_binfo (base_binfo, basetype, ref,
12309 &igo_prev, via_virtual);
12310 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
12311 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
12313 BINFO_BASE_APPEND (binfo, base_binfo);
12314 BINFO_BASE_ACCESS_APPEND (binfo, access);
12317 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref)) < max_vbases)
12318 /* If we didn't get max_vbases vbases, we must have shared at
12319 least one of them, and are therefore diamond shaped. */
12320 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
12322 /* Unmark all the types. */
12323 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12324 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12325 TYPE_MARKED_P (ref) = 0;
12327 /* Now see if we have a repeated base type. */
12328 if (!CLASSTYPE_REPEATED_BASE_P (ref))
12330 for (base_binfo = binfo; base_binfo;
12331 base_binfo = TREE_CHAIN (base_binfo))
12333 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12335 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
12338 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
12340 for (base_binfo = binfo; base_binfo;
12341 base_binfo = TREE_CHAIN (base_binfo))
12342 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12343 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12352 /* Copies the enum-related properties from type SRC to type DST.
12353 Used with the underlying type of an enum and the enum itself. */
12355 copy_type_enum (tree dst, tree src)
12358 for (t = dst; t; t = TYPE_NEXT_VARIANT (t))
12360 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src);
12361 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src);
12362 TYPE_SIZE (t) = TYPE_SIZE (src);
12363 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src);
12364 SET_TYPE_MODE (dst, TYPE_MODE (src));
12365 TYPE_PRECISION (t) = TYPE_PRECISION (src);
12366 TYPE_ALIGN (t) = TYPE_ALIGN (src);
12367 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src);
12368 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src);
12372 /* Begin compiling the definition of an enumeration type.
12375 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12377 UNDERLYING_TYPE is the type that will be used as the storage for
12378 the enumeration type. This should be NULL_TREE if no storage type
12381 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12383 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12385 Returns the type object, as yet incomplete.
12386 Also records info about it so that build_enumerator
12387 may be used to declare the individual values as they are read. */
12390 start_enum (tree name, tree enumtype, tree underlying_type,
12391 bool scoped_enum_p, bool *is_new)
12393 tree prevtype = NULL_TREE;
12394 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
12398 /* [C++0x dcl.enum]p5:
12400 If not explicitly specified, the underlying type of a scoped
12401 enumeration type is int. */
12402 if (!underlying_type && scoped_enum_p)
12403 underlying_type = integer_type_node;
12405 if (underlying_type)
12406 underlying_type = cv_unqualified (underlying_type);
12408 /* If this is the real definition for a previous forward reference,
12409 fill in the contents in the same object that used to be the
12410 forward reference. */
12412 enumtype = lookup_and_check_tag (enum_type, name,
12413 /*tag_scope=*/ts_current,
12414 /*template_header_p=*/false);
12416 /* In case of a template_decl, the only check that should be deferred
12417 to instantiation time is the comparison of underlying types. */
12418 if (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12420 if (scoped_enum_p != SCOPED_ENUM_P (enumtype))
12422 error_at (input_location, "scoped/unscoped mismatch "
12423 "in enum %q#T", enumtype);
12424 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12425 "previous definition here");
12426 enumtype = error_mark_node;
12428 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) != !! underlying_type)
12430 error_at (input_location, "underlying type mismatch "
12431 "in enum %q#T", enumtype);
12432 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12433 "previous definition here");
12434 enumtype = error_mark_node;
12436 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype)
12437 && !dependent_type_p (underlying_type)
12438 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))
12439 && !same_type_p (underlying_type,
12440 ENUM_UNDERLYING_TYPE (enumtype)))
12442 error_at (input_location, "different underlying type "
12443 "in enum %q#T", enumtype);
12444 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12445 "previous definition here");
12446 underlying_type = NULL_TREE;
12450 if (!enumtype || TREE_CODE (enumtype) != ENUMERAL_TYPE
12451 || processing_template_decl)
12453 /* In case of error, make a dummy enum to allow parsing to
12455 if (enumtype == error_mark_node)
12457 name = make_anon_name ();
12458 enumtype = NULL_TREE;
12461 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12462 of an opaque enum, or an opaque enum of an already defined
12463 enumeration (C++0x only).
12464 In any other case, it'll be NULL_TREE. */
12470 prevtype = enumtype;
12472 /* Do not push the decl more than once, unless we need to
12473 compare underlying types at instantiation time */
12475 || TREE_CODE (enumtype) != ENUMERAL_TYPE
12476 || (underlying_type
12477 && dependent_type_p (underlying_type))
12478 || (ENUM_UNDERLYING_TYPE (enumtype)
12479 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))))
12481 enumtype = cxx_make_type (ENUMERAL_TYPE);
12482 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
12485 enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current,
12488 if (enumtype == error_mark_node)
12489 return error_mark_node;
12491 /* The enum is considered opaque until the opening '{' of the
12492 enumerator list. */
12493 SET_OPAQUE_ENUM_P (enumtype, true);
12494 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) = !! underlying_type;
12497 SET_SCOPED_ENUM_P (enumtype, scoped_enum_p);
12499 if (underlying_type)
12501 if (CP_INTEGRAL_TYPE_P (underlying_type))
12503 copy_type_enum (enumtype, underlying_type);
12504 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12506 else if (dependent_type_p (underlying_type))
12507 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12509 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12510 underlying_type, enumtype);
12513 /* If into a template class, the returned enum is always the first
12514 declaration (opaque or not) seen. This way all the references to
12515 this type will be to the same declaration. The following ones are used
12516 only to check for definition errors. */
12517 if (prevtype && processing_template_decl)
12523 /* After processing and defining all the values of an enumeration type,
12524 install their decls in the enumeration type.
12525 ENUMTYPE is the type object. */
12528 finish_enum_value_list (tree enumtype)
12531 tree underlying_type;
12534 tree minnode, maxnode;
12537 bool fixed_underlying_type_p
12538 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
12540 /* We built up the VALUES in reverse order. */
12541 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12543 /* For an enum defined in a template, just set the type of the values;
12544 all further processing is postponed until the template is
12545 instantiated. We need to set the type so that tsubst of a CONST_DECL
12547 if (processing_template_decl)
12549 for (values = TYPE_VALUES (enumtype);
12551 values = TREE_CHAIN (values))
12552 TREE_TYPE (TREE_VALUE (values)) = enumtype;
12556 /* Determine the minimum and maximum values of the enumerators. */
12557 if (TYPE_VALUES (enumtype))
12559 minnode = maxnode = NULL_TREE;
12561 for (values = TYPE_VALUES (enumtype);
12563 values = TREE_CHAIN (values))
12565 decl = TREE_VALUE (values);
12567 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12568 each enumerator has the type of its enumeration. Prior to the
12569 closing brace, the type of each enumerator is the type of its
12570 initializing value. */
12571 TREE_TYPE (decl) = enumtype;
12573 /* Update the minimum and maximum values, if appropriate. */
12574 value = DECL_INITIAL (decl);
12575 if (value == error_mark_node)
12576 value = integer_zero_node;
12577 /* Figure out what the minimum and maximum values of the
12578 enumerators are. */
12580 minnode = maxnode = value;
12581 else if (tree_int_cst_lt (maxnode, value))
12583 else if (tree_int_cst_lt (value, minnode))
12590 If the enumerator-list is empty, the underlying type is as if
12591 the enumeration had a single enumerator with value 0. */
12592 minnode = maxnode = integer_zero_node;
12594 if (!fixed_underlying_type_p)
12596 /* Compute the number of bits require to represent all values of the
12597 enumeration. We must do this before the type of MINNODE and
12598 MAXNODE are transformed, since tree_int_cst_min_precision relies
12599 on the TREE_TYPE of the value it is passed. */
12600 bool unsignedp = tree_int_cst_sgn (minnode) >= 0;
12601 int lowprec = tree_int_cst_min_precision (minnode, unsignedp);
12602 int highprec = tree_int_cst_min_precision (maxnode, unsignedp);
12603 int precision = MAX (lowprec, highprec);
12605 bool use_short_enum;
12607 /* Determine the underlying type of the enumeration.
12611 The underlying type of an enumeration is an integral type that
12612 can represent all the enumerator values defined in the
12613 enumeration. It is implementation-defined which integral type is
12614 used as the underlying type for an enumeration except that the
12615 underlying type shall not be larger than int unless the value of
12616 an enumerator cannot fit in an int or unsigned int.
12618 We use "int" or an "unsigned int" as the underlying type, even if
12619 a smaller integral type would work, unless the user has
12620 explicitly requested that we use the smallest possible type. The
12621 user can request that for all enumerations with a command line
12622 flag, or for just one enumeration with an attribute. */
12624 use_short_enum = flag_short_enums
12625 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
12627 for (itk = (use_short_enum ? itk_char : itk_int);
12631 underlying_type = integer_types[itk];
12632 if (underlying_type != NULL_TREE
12633 && TYPE_PRECISION (underlying_type) >= precision
12634 && TYPE_UNSIGNED (underlying_type) == unsignedp)
12637 if (itk == itk_none)
12641 IF no integral type can represent all the enumerator values, the
12642 enumeration is ill-formed. */
12643 error ("no integral type can represent all of the enumerator values "
12644 "for %qT", enumtype);
12645 precision = TYPE_PRECISION (long_long_integer_type_node);
12646 underlying_type = integer_types[itk_unsigned_long_long];
12651 The value of sizeof() applied to an enumeration type, an object
12652 of an enumeration type, or an enumerator, is the value of sizeof()
12653 applied to the underlying type. */
12654 copy_type_enum (enumtype, underlying_type);
12656 /* Compute the minimum and maximum values for the type.
12660 For an enumeration where emin is the smallest enumerator and emax
12661 is the largest, the values of the enumeration are the values of the
12662 underlying type in the range bmin to bmax, where bmin and bmax are,
12663 respectively, the smallest and largest values of the smallest bit-
12664 field that can store emin and emax. */
12666 /* The middle-end currently assumes that types with TYPE_PRECISION
12667 narrower than their underlying type are suitably zero or sign
12668 extended to fill their mode. Similarly, it assumes that the front
12669 end assures that a value of a particular type must be within
12670 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12672 We used to set these fields based on bmin and bmax, but that led
12673 to invalid assumptions like optimizing away bounds checking. So
12674 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12675 TYPE_MAX_VALUE to the values for the mode above and only restrict
12676 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12677 ENUM_UNDERLYING_TYPE (enumtype)
12678 = build_distinct_type_copy (underlying_type);
12679 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision;
12680 set_min_and_max_values_for_integral_type
12681 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
12683 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12684 if (flag_strict_enums)
12685 set_min_and_max_values_for_integral_type (enumtype, precision,
12689 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
12691 /* Convert each of the enumerators to the type of the underlying
12692 type of the enumeration. */
12693 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12695 location_t saved_location;
12697 decl = TREE_VALUE (values);
12698 saved_location = input_location;
12699 input_location = DECL_SOURCE_LOCATION (decl);
12700 if (fixed_underlying_type_p)
12701 /* If the enumeration type has a fixed underlying type, we
12702 already checked all of the enumerator values. */
12703 value = DECL_INITIAL (decl);
12705 value = perform_implicit_conversion (underlying_type,
12706 DECL_INITIAL (decl),
12707 tf_warning_or_error);
12708 input_location = saved_location;
12710 /* Do not clobber shared ints. */
12711 value = copy_node (value);
12713 TREE_TYPE (value) = enumtype;
12714 DECL_INITIAL (decl) = value;
12717 /* Fix up all variant types of this enum type. */
12718 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
12719 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
12721 if (at_class_scope_p ()
12722 && COMPLETE_TYPE_P (current_class_type)
12723 && UNSCOPED_ENUM_P (enumtype))
12724 insert_late_enum_def_into_classtype_sorted_fields (enumtype,
12725 current_class_type);
12727 /* Finish debugging output for this type. */
12728 rest_of_type_compilation (enumtype, namespace_bindings_p ());
12731 /* Finishes the enum type. This is called only the first time an
12732 enumeration is seen, be it opaque or odinary.
12733 ENUMTYPE is the type object. */
12736 finish_enum (tree enumtype)
12738 if (processing_template_decl)
12740 if (at_function_scope_p ())
12741 add_stmt (build_min (TAG_DEFN, enumtype));
12745 /* If this is a forward declaration, there should not be any variants,
12746 though we can get a variant in the middle of an enum-specifier with
12747 wacky code like 'enum E { e = sizeof(const E*) };' */
12748 gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
12749 && (TYPE_VALUES (enumtype)
12750 || !TYPE_NEXT_VARIANT (enumtype)));
12753 /* Build and install a CONST_DECL for an enumeration constant of the
12754 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12755 LOC is the location of NAME.
12756 Assignment of sequential values by default is handled here. */
12759 build_enumerator (tree name, tree value, tree enumtype, location_t loc)
12765 /* If the VALUE was erroneous, pretend it wasn't there; that will
12766 result in the enum being assigned the next value in sequence. */
12767 if (value == error_mark_node)
12770 /* Remove no-op casts from the value. */
12772 STRIP_TYPE_NOPS (value);
12774 if (! processing_template_decl)
12776 /* Validate and default VALUE. */
12777 if (value != NULL_TREE)
12779 value = cxx_constant_value (value);
12781 if (TREE_CODE (value) != INTEGER_CST
12782 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
12784 error ("enumerator value for %qD is not an integer constant",
12790 /* Default based on previous value. */
12791 if (value == NULL_TREE)
12793 if (TYPE_VALUES (enumtype))
12798 /* C++03 7.2/4: If no initializer is specified for the first
12799 enumerator, the type is an unspecified integral
12800 type. Otherwise the type is the same as the type of the
12801 initializing value of the preceding enumerator unless the
12802 incremented value is not representable in that type, in
12803 which case the type is an unspecified integral type
12804 sufficient to contain the incremented value. */
12805 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
12806 if (error_operand_p (prev_value))
12807 value = error_mark_node;
12810 double_int di = TREE_INT_CST (prev_value)
12811 .add_with_sign (double_int_one,
12812 false, &overflowed);
12815 tree type = TREE_TYPE (prev_value);
12816 bool pos = TYPE_UNSIGNED (type) || !di.is_negative ();
12817 if (!double_int_fits_to_tree_p (type, di))
12820 for (itk = itk_int; itk != itk_none; itk++)
12822 type = integer_types[itk];
12823 if (type != NULL_TREE
12824 && (pos || !TYPE_UNSIGNED (type))
12825 && double_int_fits_to_tree_p (type, di))
12828 if (type && cxx_dialect < cxx0x
12829 && itk > itk_unsigned_long)
12830 pedwarn (input_location, OPT_Wlong_long, pos ? "\
12831 incremented enumerator value is too large for %<unsigned long%>" : "\
12832 incremented enumerator value is too large for %<long%>");
12834 if (type == NULL_TREE)
12837 value = double_int_to_tree (type, di);
12842 error ("overflow in enumeration values at %qD", name);
12843 value = error_mark_node;
12848 value = integer_zero_node;
12851 /* Remove no-op casts from the value. */
12852 STRIP_TYPE_NOPS (value);
12854 /* If the underlying type of the enum is fixed, check whether
12855 the enumerator values fits in the underlying type. If it
12856 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12857 if (ENUM_UNDERLYING_TYPE (enumtype)
12859 && TREE_CODE (value) == INTEGER_CST)
12861 if (!int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
12862 error ("enumerator value %E is too large for underlying type %<%T%>",
12863 value, ENUM_UNDERLYING_TYPE (enumtype));
12865 /* Convert the value to the appropriate type. */
12866 value = convert (ENUM_UNDERLYING_TYPE (enumtype), value);
12870 /* C++ associates enums with global, function, or class declarations. */
12871 context = current_scope ();
12873 /* Build the actual enumeration constant. Note that the enumeration
12874 constants have the underlying type of the enum (if it is fixed)
12875 or the type of their initializer (if the underlying type of the
12876 enum is not fixed):
12880 If the underlying type is fixed, the type of each enumerator
12881 prior to the closing brace is the underlying type; if the
12882 initializing value of an enumerator cannot be represented by
12883 the underlying type, the program is ill-formed. If the
12884 underlying type is not fixed, the type of each enumerator is
12885 the type of its initializing value.
12887 If the underlying type is not fixed, it will be computed by
12888 finish_enum and we will reset the type of this enumerator. Of
12889 course, if we're processing a template, there may be no value. */
12890 type = value ? TREE_TYPE (value) : NULL_TREE;
12892 decl = build_decl (loc, CONST_DECL, name, type);
12894 DECL_CONTEXT (decl) = enumtype;
12895 TREE_CONSTANT (decl) = 1;
12896 TREE_READONLY (decl) = 1;
12897 DECL_INITIAL (decl) = value;
12899 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype))
12900 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12901 on the TYPE_FIELDS list for `S'. (That's so that you can say
12902 things like `S::i' later.) */
12903 finish_member_declaration (decl);
12907 /* Add this enumeration constant to the list for this type. */
12908 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
12911 /* Look for an enumerator with the given NAME within the enumeration
12912 type ENUMTYPE. This routine is used primarily for qualified name
12913 lookup into an enumerator in C++0x, e.g.,
12915 enum class Color { Red, Green, Blue };
12917 Color color = Color::Red;
12919 Returns the value corresponding to the enumerator, or
12920 NULL_TREE if no such enumerator was found. */
12922 lookup_enumerator (tree enumtype, tree name)
12925 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
12927 e = purpose_member (name, TYPE_VALUES (enumtype));
12928 return e? TREE_VALUE (e) : NULL_TREE;
12932 /* We're defining DECL. Make sure that its type is OK. */
12935 check_function_type (tree decl, tree current_function_parms)
12937 tree fntype = TREE_TYPE (decl);
12938 tree return_type = complete_type (TREE_TYPE (fntype));
12940 /* In a function definition, arg types must be complete. */
12941 require_complete_types_for_parms (current_function_parms);
12943 if (dependent_type_p (return_type)
12944 || type_uses_auto (return_type))
12946 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
12947 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
12949 tree args = TYPE_ARG_TYPES (fntype);
12951 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
12952 error ("return type %q#T is incomplete", return_type);
12954 error ("return type has Java class type %q#T", return_type);
12956 /* Make it return void instead. */
12957 if (TREE_CODE (fntype) == METHOD_TYPE)
12958 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
12960 TREE_CHAIN (args));
12962 fntype = build_function_type (void_type_node, args);
12964 = build_exception_variant (fntype,
12965 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
12966 fntype = (cp_build_type_attribute_variant
12967 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
12968 TREE_TYPE (decl) = fntype;
12971 abstract_virtuals_error (decl, TREE_TYPE (fntype));
12974 /* Create the FUNCTION_DECL for a function definition.
12975 DECLSPECS and DECLARATOR are the parts of the declaration;
12976 they describe the function's name and the type it returns,
12977 but twisted together in a fashion that parallels the syntax of C.
12979 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12980 DECLARATOR is really the DECL for the function we are about to
12981 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12982 indicating that the function is an inline defined in-class.
12984 This function creates a binding context for the function body
12985 as well as setting up the FUNCTION_DECL in current_function_decl.
12987 For C++, we must first check whether that datum makes any sense.
12988 For example, "class A local_a(1,2);" means that variable local_a
12989 is an aggregate of type A, which should have a constructor
12990 applied to it with the argument list [1, 2].
12992 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
12993 or may be a BLOCK if the function has been defined previously
12994 in this translation unit. On exit, DECL_INITIAL (decl1) will be
12995 error_mark_node if the function has never been defined, or
12996 a BLOCK if the function has been defined somewhere. */
12999 start_preparsed_function (tree decl1, tree attrs, int flags)
13001 tree ctype = NULL_TREE;
13004 int doing_friend = 0;
13005 cp_binding_level *bl;
13006 tree current_function_parms;
13007 struct c_fileinfo *finfo
13008 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
13009 bool honor_interface;
13011 /* Sanity check. */
13012 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
13013 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
13015 fntype = TREE_TYPE (decl1);
13016 if (TREE_CODE (fntype) == METHOD_TYPE)
13017 ctype = TYPE_METHOD_BASETYPE (fntype);
13019 /* ISO C++ 11.4/5. A friend function defined in a class is in
13020 the (lexical) scope of the class in which it is defined. */
13021 if (!ctype && DECL_FRIEND_P (decl1))
13023 ctype = DECL_FRIEND_CONTEXT (decl1);
13025 /* CTYPE could be null here if we're dealing with a template;
13026 for example, `inline friend float foo()' inside a template
13027 will have no CTYPE set. */
13028 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13034 if (DECL_DECLARED_INLINE_P (decl1)
13035 && lookup_attribute ("noinline", attrs))
13036 warning (0, "inline function %q+D given attribute noinline", decl1);
13038 /* Handle gnu_inline attribute. */
13039 if (GNU_INLINE_P (decl1))
13041 DECL_EXTERNAL (decl1) = 1;
13042 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13043 DECL_INTERFACE_KNOWN (decl1) = 1;
13044 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
13047 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13048 /* This is a constructor, we must ensure that any default args
13049 introduced by this definition are propagated to the clones
13050 now. The clones are used directly in overload resolution. */
13051 adjust_clone_args (decl1);
13053 /* Sometimes we don't notice that a function is a static member, and
13054 build a METHOD_TYPE for it. Fix that up now. */
13055 gcc_assert (!(ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13056 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE));
13058 /* Set up current_class_type, and enter the scope of the class, if
13061 push_nested_class (ctype);
13062 else if (DECL_STATIC_FUNCTION_P (decl1))
13063 push_nested_class (DECL_CONTEXT (decl1));
13065 /* Now that we have entered the scope of the class, we must restore
13066 the bindings for any template parameters surrounding DECL1, if it
13067 is an inline member template. (Order is important; consider the
13068 case where a template parameter has the same name as a field of
13069 the class.) It is not until after this point that
13070 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13071 if (flags & SF_INCLASS_INLINE)
13072 maybe_begin_member_template_processing (decl1);
13074 /* Effective C++ rule 15. */
13076 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13077 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
13078 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
13080 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13081 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13082 if (!DECL_INITIAL (decl1))
13083 DECL_INITIAL (decl1) = error_mark_node;
13085 /* This function exists in static storage.
13086 (This does not mean `static' in the C sense!) */
13087 TREE_STATIC (decl1) = 1;
13089 /* We must call push_template_decl after current_class_type is set
13090 up. (If we are processing inline definitions after exiting a
13091 class scope, current_class_type will be NULL_TREE until set above
13092 by push_nested_class.) */
13093 if (processing_template_decl)
13095 /* FIXME: Handle error_mark_node more gracefully. */
13096 tree newdecl1 = push_template_decl (decl1);
13097 if (newdecl1 != error_mark_node)
13101 /* We are now in the scope of the function being defined. */
13102 current_function_decl = decl1;
13104 /* Save the parm names or decls from this function's declarator
13105 where store_parm_decls will find them. */
13106 current_function_parms = DECL_ARGUMENTS (decl1);
13108 /* Make sure the parameter and return types are reasonable. When
13109 you declare a function, these types can be incomplete, but they
13110 must be complete when you define the function. */
13111 check_function_type (decl1, current_function_parms);
13113 /* Build the return declaration for the function. */
13114 restype = TREE_TYPE (fntype);
13116 if (DECL_RESULT (decl1) == NULL_TREE)
13120 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
13121 DECL_ARTIFICIAL (resdecl) = 1;
13122 DECL_IGNORED_P (resdecl) = 1;
13123 DECL_RESULT (decl1) = resdecl;
13125 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
13128 /* Let the user know we're compiling this function. */
13129 announce_function (decl1);
13131 /* Record the decl so that the function name is defined.
13132 If we already have a decl for this name, and it is a FUNCTION_DECL,
13133 use the old decl. */
13134 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13136 /* A specialization is not used to guide overload resolution. */
13137 if (!DECL_FUNCTION_MEMBER_P (decl1)
13138 && !(DECL_USE_TEMPLATE (decl1) &&
13139 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
13141 tree olddecl = pushdecl (decl1);
13143 if (olddecl == error_mark_node)
13144 /* If something went wrong when registering the declaration,
13145 use DECL1; we have to have a FUNCTION_DECL to use when
13146 parsing the body of the function. */
13150 /* Otherwise, OLDDECL is either a previous declaration
13151 of the same function or DECL1 itself. */
13153 if (warn_missing_declarations
13154 && olddecl == decl1
13155 && !DECL_MAIN_P (decl1)
13156 && TREE_PUBLIC (decl1)
13157 && !DECL_DECLARED_INLINE_P (decl1))
13161 /* Check whether DECL1 is in an anonymous
13163 for (context = DECL_CONTEXT (decl1);
13165 context = DECL_CONTEXT (context))
13167 if (TREE_CODE (context) == NAMESPACE_DECL
13168 && DECL_NAME (context) == NULL_TREE)
13172 if (context == NULL)
13173 warning (OPT_Wmissing_declarations,
13174 "no previous declaration for %q+D", decl1);
13182 /* We need to set the DECL_CONTEXT. */
13183 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13184 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13186 fntype = TREE_TYPE (decl1);
13187 restype = TREE_TYPE (fntype);
13189 /* If #pragma weak applies, mark the decl appropriately now.
13190 The pragma only applies to global functions. Because
13191 determining whether or not the #pragma applies involves
13192 computing the mangled name for the declaration, we cannot
13193 apply the pragma until after we have merged this declaration
13194 with any previous declarations; if the original declaration
13195 has a linkage specification, that specification applies to
13196 the definition as well, and may affect the mangled name. */
13197 if (DECL_FILE_SCOPE_P (decl1))
13198 maybe_apply_pragma_weak (decl1);
13201 /* Reset this in case the call to pushdecl changed it. */
13202 current_function_decl = decl1;
13204 gcc_assert (DECL_INITIAL (decl1));
13206 /* This function may already have been parsed, in which case just
13207 return; our caller will skip over the body without parsing. */
13208 if (DECL_INITIAL (decl1) != error_mark_node)
13211 /* Initialize RTL machinery. We cannot do this until
13212 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13213 even when processing a template; this is how we get
13214 CFUN set up, and our per-function variables initialized.
13215 FIXME factor out the non-RTL stuff. */
13216 bl = current_binding_level;
13217 allocate_struct_function (decl1, processing_template_decl);
13219 /* Initialize the language data structures. Whenever we start
13220 a new function, we destroy temporaries in the usual way. */
13221 cfun->language = ggc_alloc_cleared_language_function ();
13222 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
13223 current_binding_level = bl;
13225 if (!processing_template_decl && type_uses_auto (restype))
13227 FNDECL_USED_AUTO (decl1) = true;
13228 current_function_auto_return_pattern = restype;
13231 /* Start the statement-tree, start the tree now. */
13232 DECL_SAVED_TREE (decl1) = push_stmt_list ();
13234 /* If we are (erroneously) defining a function that we have already
13235 defined before, wipe out what we knew before. */
13236 if (!DECL_PENDING_INLINE_P (decl1))
13237 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13239 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13241 /* We know that this was set up by `grokclassfn'. We do not
13242 wait until `store_parm_decls', since evil parse errors may
13243 never get us to that point. Here we keep the consistency
13244 between `current_class_type' and `current_class_ptr'. */
13245 tree t = DECL_ARGUMENTS (decl1);
13247 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
13248 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
13250 cp_function_chain->x_current_class_ref
13251 = cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
13252 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13253 cp_function_chain->x_current_class_ptr = t;
13255 /* Constructors and destructors need to know whether they're "in
13256 charge" of initializing virtual base classes. */
13257 t = DECL_CHAIN (t);
13258 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13260 current_in_charge_parm = t;
13261 t = DECL_CHAIN (t);
13263 if (DECL_HAS_VTT_PARM_P (decl1))
13265 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
13266 current_vtt_parm = t;
13270 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
13271 /* Implicitly-defined methods (like the
13272 destructor for a class in which no destructor
13273 is explicitly declared) must not be defined
13274 until their definition is needed. So, we
13275 ignore interface specifications for
13276 compiler-generated functions. */
13277 && !DECL_ARTIFICIAL (decl1));
13279 if (processing_template_decl)
13280 /* Don't mess with interface flags. */;
13281 else if (DECL_INTERFACE_KNOWN (decl1))
13283 tree ctx = decl_function_context (decl1);
13285 if (DECL_NOT_REALLY_EXTERN (decl1))
13286 DECL_EXTERNAL (decl1) = 0;
13288 if (ctx != NULL_TREE && vague_linkage_p (ctx))
13289 /* This is a function in a local class in an extern inline
13290 or template function. */
13291 comdat_linkage (decl1);
13293 /* If this function belongs to an interface, it is public.
13294 If it belongs to someone else's interface, it is also external.
13295 This only affects inlines and template instantiations. */
13296 else if (!finfo->interface_unknown && honor_interface)
13298 if (DECL_DECLARED_INLINE_P (decl1)
13299 || DECL_TEMPLATE_INSTANTIATION (decl1))
13301 DECL_EXTERNAL (decl1)
13302 = (finfo->interface_only
13303 || (DECL_DECLARED_INLINE_P (decl1)
13304 && ! flag_implement_inlines
13305 && !DECL_VINDEX (decl1)));
13307 /* For WIN32 we also want to put these in linkonce sections. */
13308 maybe_make_one_only (decl1);
13311 DECL_EXTERNAL (decl1) = 0;
13312 DECL_INTERFACE_KNOWN (decl1) = 1;
13313 /* If this function is in an interface implemented in this file,
13314 make sure that the back end knows to emit this function
13316 if (!DECL_EXTERNAL (decl1))
13317 mark_needed (decl1);
13319 else if (finfo->interface_unknown && finfo->interface_only
13320 && honor_interface)
13322 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13323 interface, we will have both finfo->interface_unknown and
13324 finfo->interface_only set. In that case, we don't want to
13325 use the normal heuristics because someone will supply a
13326 #pragma implementation elsewhere, and deducing it here would
13327 produce a conflict. */
13328 comdat_linkage (decl1);
13329 DECL_EXTERNAL (decl1) = 0;
13330 DECL_INTERFACE_KNOWN (decl1) = 1;
13331 DECL_DEFER_OUTPUT (decl1) = 1;
13335 /* This is a definition, not a reference.
13336 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13337 if (!GNU_INLINE_P (decl1))
13338 DECL_EXTERNAL (decl1) = 0;
13340 if ((DECL_DECLARED_INLINE_P (decl1)
13341 || DECL_TEMPLATE_INSTANTIATION (decl1))
13342 && ! DECL_INTERFACE_KNOWN (decl1))
13343 DECL_DEFER_OUTPUT (decl1) = 1;
13345 DECL_INTERFACE_KNOWN (decl1) = 1;
13348 /* Determine the ELF visibility attribute for the function. We must not
13349 do this before calling "pushdecl", as we must allow "duplicate_decls"
13350 to merge any attributes appropriately. We also need to wait until
13352 if (!DECL_CLONED_FUNCTION_P (decl1))
13353 determine_visibility (decl1);
13355 begin_scope (sk_function_parms, decl1);
13359 if (DECL_DESTRUCTOR_P (decl1)
13360 || (DECL_CONSTRUCTOR_P (decl1)
13361 && targetm.cxx.cdtor_returns_this ()))
13363 cdtor_label = build_decl (input_location,
13364 LABEL_DECL, NULL_TREE, NULL_TREE);
13365 DECL_CONTEXT (cdtor_label) = current_function_decl;
13368 start_fname_decls ();
13370 store_parm_decls (current_function_parms);
13374 /* Like start_preparsed_function, except that instead of a
13375 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13377 Returns 1 on success. If the DECLARATOR is not suitable for a function
13378 (it defines a datum instead), we return 0, which tells
13379 yyparse to report a parse error. */
13382 start_function (cp_decl_specifier_seq *declspecs,
13383 const cp_declarator *declarator,
13388 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
13389 if (decl1 == error_mark_node)
13391 /* If the declarator is not suitable for a function definition,
13392 cause a syntax error. */
13393 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13395 error ("invalid function declaration");
13399 if (DECL_MAIN_P (decl1))
13400 /* main must return int. grokfndecl should have corrected it
13401 (and issued a diagnostic) if the user got it wrong. */
13402 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
13403 integer_type_node));
13405 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
13410 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13414 use_eh_spec_block (tree fn)
13416 return (flag_exceptions && flag_enforce_eh_specs
13417 && !processing_template_decl
13418 && !type_throw_all_p (TREE_TYPE (fn))
13419 /* We insert the EH_SPEC_BLOCK only in the original
13420 function; then, it is copied automatically to the
13422 && !DECL_CLONED_FUNCTION_P (fn)
13423 /* Implicitly-generated constructors and destructors have
13424 exception specifications. However, those specifications
13425 are the union of the possible exceptions specified by the
13426 constructors/destructors for bases and members, so no
13427 unallowed exception will ever reach this function. By
13428 not creating the EH_SPEC_BLOCK we save a little memory,
13429 and we avoid spurious warnings about unreachable
13431 && !DECL_DEFAULTED_FN (fn));
13434 /* Store the parameter declarations into the current function declaration.
13435 This is called after parsing the parameter declarations, before
13436 digesting the body of the function.
13438 Also install to binding contour return value identifier, if any. */
13441 store_parm_decls (tree current_function_parms)
13443 tree fndecl = current_function_decl;
13446 /* This is a chain of any other decls that came in among the parm
13447 declarations. If a parm is declared with enum {foo, bar} x;
13448 then CONST_DECLs for foo and bar are put here. */
13449 tree nonparms = NULL_TREE;
13451 if (current_function_parms)
13453 /* This case is when the function was defined with an ANSI prototype.
13454 The parms already have decls, so we need not do anything here
13455 except record them as in effect
13456 and complain if any redundant old-style parm decls were written. */
13458 tree specparms = current_function_parms;
13461 /* Must clear this because it might contain TYPE_DECLs declared
13463 current_binding_level->names = NULL;
13465 /* If we're doing semantic analysis, then we'll call pushdecl
13466 for each of these. We must do them in reverse order so that
13467 they end in the correct forward order. */
13468 specparms = nreverse (specparms);
13470 for (parm = specparms; parm; parm = next)
13472 next = DECL_CHAIN (parm);
13473 if (TREE_CODE (parm) == PARM_DECL)
13475 if (DECL_NAME (parm) == NULL_TREE
13476 || TREE_CODE (parm) != VOID_TYPE)
13479 error ("parameter %qD declared void", parm);
13483 /* If we find an enum constant or a type tag,
13484 put it aside for the moment. */
13485 TREE_CHAIN (parm) = NULL_TREE;
13486 nonparms = chainon (nonparms, parm);
13490 /* Get the decls in their original chain order and record in the
13491 function. This is all and only the PARM_DECLs that were
13492 pushed into scope by the loop above. */
13493 DECL_ARGUMENTS (fndecl) = getdecls ();
13496 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13498 /* Now store the final chain of decls for the arguments
13499 as the decl-chain of the current lexical scope.
13500 Put the enumerators in as well, at the front so that
13501 DECL_ARGUMENTS is not modified. */
13502 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
13504 if (use_eh_spec_block (current_function_decl))
13505 current_eh_spec_block = begin_eh_spec_block ();
13509 /* We have finished doing semantic analysis on DECL, but have not yet
13510 generated RTL for its body. Save away our current state, so that
13511 when we want to generate RTL later we know what to do. */
13514 save_function_data (tree decl)
13516 struct language_function *f;
13518 /* Save the language-specific per-function data so that we can
13519 get it back when we really expand this function. */
13520 gcc_assert (!DECL_PENDING_INLINE_P (decl));
13523 f = ggc_alloc_language_function ();
13524 memcpy (f, cp_function_chain, sizeof (struct language_function));
13525 DECL_SAVED_FUNCTION_DATA (decl) = f;
13527 /* Clear out the bits we don't need. */
13528 f->base.x_stmt_tree.x_cur_stmt_list = NULL;
13529 f->bindings = NULL;
13530 f->x_local_names = NULL;
13531 f->base.local_typedefs = NULL;
13535 /* Set the return value of the constructor (if present). */
13538 finish_constructor_body (void)
13543 if (targetm.cxx.cdtor_returns_this ()
13544 && (! TYPE_FOR_JAVA (current_class_type)))
13546 /* Any return from a constructor will end up here. */
13547 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13549 val = DECL_ARGUMENTS (current_function_decl);
13550 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13551 DECL_RESULT (current_function_decl), val);
13552 /* Return the address of the object. */
13553 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13554 add_stmt (exprstmt);
13558 /* Do all the processing for the beginning of a destructor; set up the
13559 vtable pointers and cleanups for bases and members. */
13562 begin_destructor_body (void)
13564 tree compound_stmt;
13566 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13567 issued an error message. We still want to try to process the
13568 body of the function, but initialize_vtbl_ptrs will crash if
13569 TYPE_BINFO is NULL. */
13570 if (COMPLETE_TYPE_P (current_class_type))
13572 compound_stmt = begin_compound_stmt (0);
13573 /* Make all virtual function table pointers in non-virtual base
13574 classes point to CURRENT_CLASS_TYPE's virtual function
13576 initialize_vtbl_ptrs (current_class_ptr);
13577 finish_compound_stmt (compound_stmt);
13579 /* And insert cleanups for our bases and members so that they
13580 will be properly destroyed if we throw. */
13581 push_base_cleanups ();
13585 /* At the end of every destructor we generate code to delete the object if
13586 necessary. Do that now. */
13589 finish_destructor_body (void)
13593 /* Any return from a destructor will end up here; that way all base
13594 and member cleanups will be run when the function returns. */
13595 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13597 /* In a virtual destructor, we must call delete. */
13598 if (DECL_VIRTUAL_P (current_function_decl))
13601 tree virtual_size = cxx_sizeof (current_class_type);
13605 At the point of definition of a virtual destructor (including
13606 an implicit definition), non-placement operator delete shall
13607 be looked up in the scope of the destructor's class and if
13608 found shall be accessible and unambiguous. */
13609 exprstmt = build_op_delete_call (DELETE_EXPR, current_class_ptr,
13611 /*global_p=*/false,
13612 /*placement=*/NULL_TREE,
13613 /*alloc_fn=*/NULL_TREE,
13614 tf_warning_or_error);
13616 if_stmt = begin_if_stmt ();
13617 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
13618 current_in_charge_parm,
13621 finish_expr_stmt (exprstmt);
13622 finish_then_clause (if_stmt);
13623 finish_if_stmt (if_stmt);
13626 if (targetm.cxx.cdtor_returns_this ())
13630 val = DECL_ARGUMENTS (current_function_decl);
13631 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13632 DECL_RESULT (current_function_decl), val);
13633 /* Return the address of the object. */
13634 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13635 add_stmt (exprstmt);
13639 /* Do the necessary processing for the beginning of a function body, which
13640 in this case includes member-initializers, but not the catch clauses of
13641 a function-try-block. Currently, this means opening a binding level
13642 for the member-initializers (in a ctor), member cleanups (in a dtor),
13643 and capture proxies (in a lambda operator()). */
13646 begin_function_body (void)
13650 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
13653 if (processing_template_decl)
13654 /* Do nothing now. */;
13656 /* Always keep the BLOCK node associated with the outermost pair of
13657 curly braces of a function. These are needed for correct
13658 operation of dwarfout.c. */
13659 keep_next_level (true);
13661 stmt = begin_compound_stmt (BCS_FN_BODY);
13663 if (processing_template_decl)
13664 /* Do nothing now. */;
13665 else if (DECL_DESTRUCTOR_P (current_function_decl))
13666 begin_destructor_body ();
13671 /* Do the processing for the end of a function body. Currently, this means
13672 closing out the cleanups for fully-constructed bases and members, and in
13673 the case of the destructor, deleting the object if desired. Again, this
13674 is only meaningful for [cd]tors, since they are the only functions where
13675 there is a significant distinction between the main body and any
13676 function catch clauses. Handling, say, main() return semantics here
13677 would be wrong, as flowing off the end of a function catch clause for
13678 main() would also need to return 0. */
13681 finish_function_body (tree compstmt)
13683 if (compstmt == NULL_TREE)
13686 /* Close the block. */
13687 finish_compound_stmt (compstmt);
13689 if (processing_template_decl)
13690 /* Do nothing now. */;
13691 else if (DECL_CONSTRUCTOR_P (current_function_decl))
13692 finish_constructor_body ();
13693 else if (DECL_DESTRUCTOR_P (current_function_decl))
13694 finish_destructor_body ();
13697 /* Given a function, returns the BLOCK corresponding to the outermost level
13698 of curly braces, skipping the artificial block created for constructor
13702 outer_curly_brace_block (tree fndecl)
13704 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
13705 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
13706 /* Skip the artificial function body block. */
13707 block = BLOCK_SUBBLOCKS (block);
13711 /* If FNDECL is a class's key method, add the class to the list of
13712 keyed classes that should be emitted. */
13715 record_key_method_defined (tree fndecl)
13717 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
13718 && DECL_VIRTUAL_P (fndecl)
13719 && !processing_template_decl)
13721 tree fnclass = DECL_CONTEXT (fndecl);
13722 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
13723 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
13727 /* Subroutine of finish_function.
13728 Save the body of constexpr functions for possible
13729 future compile time evaluation. */
13732 maybe_save_function_definition (tree fun)
13734 if (!processing_template_decl
13735 && DECL_DECLARED_CONSTEXPR_P (fun)
13736 && !DECL_CLONED_FUNCTION_P (fun))
13737 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
13740 /* Finish up a function declaration and compile that function
13741 all the way to assembler language output. The free the storage
13742 for the function definition.
13744 FLAGS is a bitwise or of the following values:
13746 We just finished processing the body of an in-class inline
13747 function definition. (This processing will have taken place
13748 after the class definition is complete.) */
13751 finish_function (int flags)
13753 tree fndecl = current_function_decl;
13754 tree fntype, ctype = NULL_TREE;
13755 int inclass_inline = (flags & 2) != 0;
13757 /* When we get some parse errors, we can end up without a
13758 current_function_decl, so cope. */
13759 if (fndecl == NULL_TREE)
13760 return error_mark_node;
13762 if (c_dialect_objc ())
13763 objc_finish_function ();
13765 gcc_assert (!defer_mark_used_calls);
13766 defer_mark_used_calls = true;
13768 record_key_method_defined (fndecl);
13770 fntype = TREE_TYPE (fndecl);
13772 /* TREE_READONLY (fndecl) = 1;
13773 This caused &foo to be of type ptr-to-const-function
13774 which then got a warning when stored in a ptr-to-function variable. */
13776 gcc_assert (building_stmt_list_p ());
13777 /* The current function is being defined, so its DECL_INITIAL should
13778 be set, and unless there's a multiple definition, it should be
13779 error_mark_node. */
13780 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
13782 /* For a cloned function, we've already got all the code we need;
13783 there's no need to add any extra bits. */
13784 if (!DECL_CLONED_FUNCTION_P (fndecl))
13786 /* Make it so that `main' always returns 0 by default. */
13787 if (DECL_MAIN_P (current_function_decl))
13788 finish_return_stmt (integer_zero_node);
13790 if (use_eh_spec_block (current_function_decl))
13791 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13792 (TREE_TYPE (current_function_decl)),
13793 current_eh_spec_block);
13796 /* If we're saving up tree structure, tie off the function now. */
13797 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
13799 finish_fname_decls ();
13801 /* If this function can't throw any exceptions, remember that. */
13802 if (!processing_template_decl
13803 && !cp_function_chain->can_throw
13804 && !flag_non_call_exceptions
13805 && !decl_replaceable_p (fndecl))
13806 TREE_NOTHROW (fndecl) = 1;
13808 /* This must come after expand_function_end because cleanups might
13809 have declarations (from inline functions) that need to go into
13810 this function's blocks. */
13812 /* If the current binding level isn't the outermost binding level
13813 for this function, either there is a bug, or we have experienced
13814 syntax errors and the statement tree is malformed. */
13815 if (current_binding_level->kind != sk_function_parms)
13817 /* Make sure we have already experienced errors. */
13818 gcc_assert (errorcount);
13820 /* Throw away the broken statement tree and extra binding
13822 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
13824 while (current_binding_level->kind != sk_function_parms)
13826 if (current_binding_level->kind == sk_class)
13827 pop_nested_class ();
13829 poplevel (0, 0, 0);
13832 poplevel (1, 0, 1);
13834 /* Statements should always be full-expressions at the outermost set
13835 of curly braces for a function. */
13836 gcc_assert (stmts_are_full_exprs_p ());
13838 /* If there are no return statements in a function with auto return type,
13839 the return type is void. But if the declared type is something like
13840 auto*, this is an error. */
13841 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
13842 && TREE_TYPE (fntype) == current_function_auto_return_pattern)
13844 if (!is_auto (current_function_auto_return_pattern)
13845 && !current_function_returns_value && !current_function_returns_null)
13847 error ("no return statements in function returning %qT",
13848 current_function_auto_return_pattern);
13849 inform (input_location, "only plain %<auto%> return type can be "
13850 "deduced to %<void%>");
13852 apply_deduced_return_type (fndecl, void_type_node);
13853 fntype = TREE_TYPE (fndecl);
13856 /* Save constexpr function body before it gets munged by
13857 the NRV transformation. */
13858 maybe_save_function_definition (fndecl);
13860 /* Set up the named return value optimization, if we can. Candidate
13861 variables are selected in check_return_expr. */
13862 if (current_function_return_value)
13864 tree r = current_function_return_value;
13867 if (r != error_mark_node
13868 /* This is only worth doing for fns that return in memory--and
13869 simpler, since we don't have to worry about promoted modes. */
13870 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
13871 /* Only allow this for variables declared in the outer scope of
13872 the function so we know that their lifetime always ends with a
13873 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13874 we were to do this optimization in tree-ssa. */
13875 && (outer = outer_curly_brace_block (fndecl))
13876 && chain_member (r, BLOCK_VARS (outer)))
13877 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
13879 current_function_return_value = NULL_TREE;
13882 /* Remember that we were in class scope. */
13883 if (current_class_name)
13884 ctype = current_class_type;
13886 /* Must mark the RESULT_DECL as being in this function. */
13887 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
13889 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13890 to the FUNCTION_DECL node itself. */
13891 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
13893 /* Save away current state, if appropriate. */
13894 if (!processing_template_decl)
13895 save_function_data (fndecl);
13897 /* Complain if there's just no return statement. */
13898 if (warn_return_type
13899 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
13900 && !dependent_type_p (TREE_TYPE (fntype))
13901 && !current_function_returns_value && !current_function_returns_null
13902 /* Don't complain if we abort or throw. */
13903 && !current_function_returns_abnormally
13904 /* Don't complain if we are declared noreturn. */
13905 && !TREE_THIS_VOLATILE (fndecl)
13906 && !DECL_NAME (DECL_RESULT (fndecl))
13907 && !TREE_NO_WARNING (fndecl)
13908 /* Structor return values (if any) are set by the compiler. */
13909 && !DECL_CONSTRUCTOR_P (fndecl)
13910 && !DECL_DESTRUCTOR_P (fndecl)
13911 && targetm.warn_func_return (fndecl))
13913 warning (OPT_Wreturn_type,
13914 "no return statement in function returning non-void");
13915 TREE_NO_WARNING (fndecl) = 1;
13918 /* Store the end of the function, so that we get good line number
13919 info for the epilogue. */
13920 cfun->function_end_locus = input_location;
13922 /* Complain about parameters that are only set, but never otherwise used. */
13923 if (warn_unused_but_set_parameter
13924 && !processing_template_decl
13925 && errorcount == unused_but_set_errorcount
13926 && !DECL_CLONED_FUNCTION_P (fndecl))
13930 for (decl = DECL_ARGUMENTS (fndecl);
13932 decl = DECL_CHAIN (decl))
13933 if (TREE_USED (decl)
13934 && TREE_CODE (decl) == PARM_DECL
13935 && !DECL_READ_P (decl)
13936 && DECL_NAME (decl)
13937 && !DECL_ARTIFICIAL (decl)
13938 && !TREE_NO_WARNING (decl)
13939 && !DECL_IN_SYSTEM_HEADER (decl)
13940 && TREE_TYPE (decl) != error_mark_node
13941 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
13942 && (!CLASS_TYPE_P (TREE_TYPE (decl))
13943 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
13944 warning (OPT_Wunused_but_set_parameter,
13945 "parameter %q+D set but not used", decl);
13946 unused_but_set_errorcount = errorcount;
13949 /* Complain about locally defined typedefs that are not used in this
13951 maybe_warn_unused_local_typedefs ();
13953 /* Genericize before inlining. */
13954 if (!processing_template_decl)
13956 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
13957 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
13958 cp_genericize (fndecl);
13959 /* Clear out the bits we don't need. */
13960 f->x_current_class_ptr = NULL;
13961 f->x_current_class_ref = NULL;
13962 f->x_eh_spec_block = NULL;
13963 f->x_in_charge_parm = NULL;
13964 f->x_vtt_parm = NULL;
13965 f->x_return_value = NULL;
13966 f->bindings = NULL;
13967 f->extern_decl_map = NULL;
13969 /* Clear out the bits we don't need. */
13970 local_names = NULL;
13972 /* We're leaving the context of this function, so zap cfun. It's still in
13973 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
13975 current_function_decl = NULL;
13977 /* If this is an in-class inline definition, we may have to pop the
13978 bindings for the template parameters that we added in
13979 maybe_begin_member_template_processing when start_function was
13981 if (inclass_inline)
13982 maybe_end_member_template_processing ();
13984 /* Leave the scope of the class. */
13986 pop_nested_class ();
13991 current_function_decl = NULL_TREE;
13993 defer_mark_used_calls = false;
13994 if (deferred_mark_used_calls)
13999 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls, i, decl)
14001 vec_free (deferred_mark_used_calls);
14007 /* Create the FUNCTION_DECL for a function definition.
14008 DECLSPECS and DECLARATOR are the parts of the declaration;
14009 they describe the return type and the name of the function,
14010 but twisted together in a fashion that parallels the syntax of C.
14012 This function creates a binding context for the function body
14013 as well as setting up the FUNCTION_DECL in current_function_decl.
14015 Returns a FUNCTION_DECL on success.
14017 If the DECLARATOR is not suitable for a function (it defines a datum
14018 instead), we return 0, which tells yyparse to report a parse error.
14020 May return void_type_node indicating that this method is actually
14021 a friend. See grokfield for more details.
14023 Came here with a `.pushlevel' .
14025 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14026 CHANGES TO CODE IN `grokfield'. */
14029 grokmethod (cp_decl_specifier_seq *declspecs,
14030 const cp_declarator *declarator, tree attrlist)
14032 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14035 if (fndecl == error_mark_node)
14036 return error_mark_node;
14038 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14040 error ("invalid member function declaration");
14041 return error_mark_node;
14045 cplus_decl_attributes (&fndecl, attrlist, 0);
14047 /* Pass friends other than inline friend functions back. */
14048 if (fndecl == void_type_node)
14051 if (DECL_IN_AGGR_P (fndecl))
14053 if (DECL_CLASS_SCOPE_P (fndecl))
14054 error ("%qD is already defined in class %qT", fndecl,
14055 DECL_CONTEXT (fndecl));
14056 return error_mark_node;
14059 check_template_shadow (fndecl);
14061 DECL_DECLARED_INLINE_P (fndecl) = 1;
14062 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
14064 /* We process method specializations in finish_struct_1. */
14065 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14067 fndecl = push_template_decl (fndecl);
14068 if (fndecl == error_mark_node)
14072 if (! DECL_FRIEND_P (fndecl))
14074 if (DECL_CHAIN (fndecl))
14076 fndecl = copy_node (fndecl);
14077 TREE_CHAIN (fndecl) = NULL_TREE;
14081 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
14083 DECL_IN_AGGR_P (fndecl) = 1;
14088 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14089 we can lay it out later, when and if its type becomes complete. */
14092 maybe_register_incomplete_var (tree var)
14094 gcc_assert (TREE_CODE (var) == VAR_DECL);
14096 /* Keep track of variables with incomplete types. */
14097 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14098 && DECL_EXTERNAL (var))
14100 tree inner_type = TREE_TYPE (var);
14102 while (TREE_CODE (inner_type) == ARRAY_TYPE)
14103 inner_type = TREE_TYPE (inner_type);
14104 inner_type = TYPE_MAIN_VARIANT (inner_type);
14106 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14107 /* RTTI TD entries are created while defining the type_info. */
14108 || (TYPE_LANG_SPECIFIC (inner_type)
14109 && TYPE_BEING_DEFINED (inner_type)))
14111 incomplete_var iv = {var, inner_type};
14112 vec_safe_push (incomplete_vars, iv);
14117 /* Called when a class type (given by TYPE) is defined. If there are
14118 any existing VAR_DECLs whose type has been completed by this
14119 declaration, update them now. */
14122 complete_vars (tree type)
14125 incomplete_var *iv;
14127 for (ix = 0; vec_safe_iterate (incomplete_vars, ix, &iv); )
14129 if (same_type_p (type, iv->incomplete_type))
14131 tree var = iv->decl;
14132 tree type = TREE_TYPE (var);
14133 /* Complete the type of the variable. The VAR_DECL itself
14134 will be laid out in expand_expr. */
14135 complete_type (type);
14136 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
14137 /* Remove this entry from the list. */
14138 incomplete_vars->unordered_remove (ix);
14144 /* Check for pending declarations which may have abstract type. */
14145 complete_type_check_abstract (type);
14148 /* If DECL is of a type which needs a cleanup, build and return an
14149 expression to perform that cleanup here. Return NULL_TREE if no
14150 cleanup need be done. */
14153 cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
14159 /* Assume no cleanup is required. */
14160 cleanup = NULL_TREE;
14162 if (error_operand_p (decl))
14165 /* Handle "__attribute__((cleanup))". We run the cleanup function
14166 before the destructor since the destructor is what actually
14167 terminates the lifetime of the object. */
14168 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
14175 /* Get the name specified by the user for the cleanup function. */
14176 id = TREE_VALUE (TREE_VALUE (attr));
14177 /* Look up the name to find the cleanup function to call. It is
14178 important to use lookup_name here because that is what is
14179 used in c-common.c:handle_cleanup_attribute when performing
14180 initial checks on the attribute. Note that those checks
14181 include ensuring that the function found is not an overloaded
14182 function, or an object with an overloaded call operator,
14183 etc.; we can rely on the fact that the function found is an
14184 ordinary FUNCTION_DECL. */
14185 fn = lookup_name (id);
14186 arg = build_address (decl);
14188 cleanup = cp_build_function_call_nary (fn, complain, arg, NULL_TREE);
14189 if (cleanup == error_mark_node)
14190 return error_mark_node;
14192 /* Handle ordinary C++ destructors. */
14193 type = TREE_TYPE (decl);
14194 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
14196 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
14197 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
14198 && CLASSTYPE_VBASECLASSES (type));
14202 if (TREE_CODE (type) == ARRAY_TYPE)
14205 addr = build_address (decl);
14207 /* Optimize for space over speed here. */
14208 if (!has_vbases || flag_expensive_optimizations)
14209 flags |= LOOKUP_NONVIRTUAL;
14211 call = build_delete (TREE_TYPE (addr), addr,
14212 sfk_complete_destructor, flags, 0, complain);
14213 if (call == error_mark_node)
14214 cleanup = error_mark_node;
14216 cleanup = cp_build_compound_expr (cleanup, call, complain);
14221 /* build_delete sets the location of the destructor call to the
14222 current location, even though the destructor is going to be
14223 called later, at the end of the current scope. This can lead to
14224 a "jumpy" behaviour for users of debuggers when they step around
14225 the end of the block. So let's unset the location of the
14226 destructor call instead. */
14227 if (cleanup != NULL && EXPR_P (cleanup))
14228 SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION);
14233 /* When a stmt has been parsed, this function is called. */
14240 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14241 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14242 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14245 static_fn_type (tree memfntype)
14250 if (TYPE_PTRMEMFUNC_P (memfntype))
14251 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
14252 if (POINTER_TYPE_P (memfntype)
14253 || TREE_CODE (memfntype) == FUNCTION_DECL)
14254 memfntype = TREE_TYPE (memfntype);
14255 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
14257 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
14258 args = TYPE_ARG_TYPES (memfntype);
14259 cp_ref_qualifier rqual = type_memfn_rqual (memfntype);
14260 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
14261 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype), rqual);
14262 fntype = (cp_build_type_attribute_variant
14263 (fntype, TYPE_ATTRIBUTES (memfntype)));
14264 fntype = (build_exception_variant
14265 (fntype, TYPE_RAISES_EXCEPTIONS (memfntype)));
14269 /* DECL was originally constructed as a non-static member function,
14270 but turned out to be static. Update it accordingly. */
14273 revert_static_member_fn (tree decl)
14275 tree stype = static_fn_type (decl);
14276 cp_cv_quals quals = type_memfn_quals (stype);
14277 cp_ref_qualifier rqual = type_memfn_rqual (stype);
14279 if (quals != TYPE_UNQUALIFIED || rqual != REF_QUAL_NONE)
14280 stype = apply_memfn_quals (stype, TYPE_UNQUALIFIED, REF_QUAL_NONE);
14282 TREE_TYPE (decl) = stype;
14284 if (DECL_ARGUMENTS (decl))
14285 DECL_ARGUMENTS (decl) = DECL_CHAIN (DECL_ARGUMENTS (decl));
14286 DECL_STATIC_FUNCTION_P (decl) = 1;
14289 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14290 one of the language-independent trees. */
14292 enum cp_tree_node_structure_enum
14293 cp_tree_node_structure (union lang_tree_node * t)
14295 switch (TREE_CODE (&t->generic))
14297 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
14298 case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT;
14299 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
14300 case OVERLOAD: return TS_CP_OVERLOAD;
14301 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
14302 case PTRMEM_CST: return TS_CP_PTRMEM;
14303 case BASELINK: return TS_CP_BASELINK;
14304 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
14305 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
14306 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
14307 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR;
14308 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO;
14309 case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL;
14310 default: return TS_CP_GENERIC;
14314 /* Build the void_list_node (void_type_node having been created). */
14316 build_void_list_node (void)
14318 tree t = build_tree_list (NULL_TREE, void_type_node);
14323 cp_missing_noreturn_ok_p (tree decl)
14325 /* A missing noreturn is ok for the `main' function. */
14326 return DECL_MAIN_P (decl);
14329 /* Return the COMDAT group into which DECL should be placed. */
14332 cxx_comdat_group (tree decl)
14336 /* Virtual tables, construction virtual tables, and virtual table
14337 tables all go in a single COMDAT group, named after the primary
14339 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
14340 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
14341 /* For all other DECLs, the COMDAT group is the mangled name of the
14342 declaration itself. */
14345 while (DECL_THUNK_P (decl))
14347 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14348 into the same section as the target function. In that case
14349 we must return target's name. */
14350 tree target = THUNK_TARGET (decl);
14351 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
14352 && DECL_SECTION_NAME (target) != NULL
14353 && DECL_ONE_ONLY (target))
14358 name = DECL_ASSEMBLER_NAME (decl);
14364 #include "gt-cp-decl.h"