gcc/
[official-gcc.git] / gcc / cp / decl.c
blob545f4cd9078bbde51661c39f8fcf48dfca16e4d2
1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2015 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)
10 any later version.
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. */
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "tm.h"
33 #include "alias.h"
34 #include "symtab.h"
35 #include "tree.h"
36 #include "tree-hasher.h"
37 #include "stringpool.h"
38 #include "stor-layout.h"
39 #include "varasm.h"
40 #include "attribs.h"
41 #include "calls.h"
42 #include "flags.h"
43 #include "cp-tree.h"
44 #include "tree-iterator.h"
45 #include "tree-inline.h"
46 #include "decl.h"
47 #include "intl.h"
48 #include "toplev.h"
49 #include "tm_p.h"
50 #include "target.h"
51 #include "c-family/c-common.h"
52 #include "c-family/c-objc.h"
53 #include "c-family/c-pragma.h"
54 #include "c-family/c-target.h"
55 #include "c-family/c-ubsan.h"
56 #include "diagnostic.h"
57 #include "intl.h"
58 #include "debug.h"
59 #include "timevar.h"
60 #include "splay-tree.h"
61 #include "plugin.h"
62 #include "plugin-api.h"
63 #include "hard-reg-set.h"
64 #include "function.h"
65 #include "ipa-ref.h"
66 #include "cgraph.h"
67 #include "cilk.h"
68 #include "builtins.h"
70 /* Possible cases of bad specifiers type used by bad_specifiers. */
71 enum bad_spec_place {
72 BSP_VAR, /* variable */
73 BSP_PARM, /* parameter */
74 BSP_TYPE, /* type */
75 BSP_FIELD /* field */
78 static tree grokparms (tree parmlist, tree *);
79 static const char *redeclaration_error_message (tree, tree);
81 static int decl_jump_unsafe (tree);
82 static void require_complete_types_for_parms (tree);
83 static int ambi_op_p (enum tree_code);
84 static int unary_op_p (enum tree_code);
85 static void push_local_name (tree);
86 static tree grok_reference_init (tree, tree, tree, int);
87 static tree grokvardecl (tree, tree, tree, const cp_decl_specifier_seq *,
88 int, int, int, tree);
89 static int check_static_variable_definition (tree, tree);
90 static void record_unknown_type (tree, const char *);
91 static tree builtin_function_1 (tree, tree, bool);
92 static int member_function_or_else (tree, tree, enum overload_flags);
93 static void bad_specifiers (tree, enum bad_spec_place, int, int, int, int,
94 int);
95 static void check_for_uninitialized_const_var (tree);
96 static tree local_variable_p_walkfn (tree *, int *, void *);
97 static tree record_builtin_java_type (const char *, int);
98 static const char *tag_name (enum tag_types);
99 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
100 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
101 static void maybe_deduce_size_from_array_init (tree, tree);
102 static void layout_var_decl (tree);
103 static tree check_initializer (tree, tree, int, vec<tree, va_gc> **);
104 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
105 static void save_function_data (tree);
106 static void copy_type_enum (tree , tree);
107 static void check_function_type (tree, tree);
108 static void finish_constructor_body (void);
109 static void begin_destructor_body (void);
110 static void finish_destructor_body (void);
111 static void record_key_method_defined (tree);
112 static tree create_array_type_for_decl (tree, tree, tree);
113 static tree get_atexit_node (void);
114 static tree get_dso_handle_node (void);
115 static tree start_cleanup_fn (void);
116 static void end_cleanup_fn (void);
117 static tree cp_make_fname_decl (location_t, tree, int);
118 static void initialize_predefined_identifiers (void);
119 static tree check_special_function_return_type
120 (special_function_kind, tree, tree);
121 static tree push_cp_library_fn (enum tree_code, tree, int);
122 static tree build_cp_library_fn (tree, enum tree_code, tree, int);
123 static void store_parm_decls (tree);
124 static void initialize_local_var (tree, tree);
125 static void expand_static_init (tree, tree);
127 /* The following symbols are subsumed in the cp_global_trees array, and
128 listed here individually for documentation purposes.
130 C++ extensions
131 tree wchar_decl_node;
133 tree vtable_entry_type;
134 tree delta_type_node;
135 tree __t_desc_type_node;
137 tree class_type_node;
138 tree unknown_type_node;
140 Array type `vtable_entry_type[]'
142 tree vtbl_type_node;
143 tree vtbl_ptr_type_node;
145 Namespaces,
147 tree std_node;
148 tree abi_node;
150 A FUNCTION_DECL which can call `abort'. Not necessarily the
151 one that the user will declare, but sufficient to be called
152 by routines that want to abort the program.
154 tree abort_fndecl;
156 Used by RTTI
157 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
158 tree tinfo_var_id; */
160 tree cp_global_trees[CPTI_MAX];
162 /* Indicates that there is a type value in some namespace, although
163 that is not necessarily in scope at the moment. */
165 tree global_type_node;
167 /* The node that holds the "name" of the global scope. */
168 tree global_scope_name;
170 #define local_names cp_function_chain->x_local_names
172 /* A list of objects which have constructors or destructors
173 which reside in the global scope. The decl is stored in
174 the TREE_VALUE slot and the initializer is stored
175 in the TREE_PURPOSE slot. */
176 tree static_aggregates;
178 /* Like static_aggregates, but for thread_local variables. */
179 tree tls_aggregates;
181 /* -- end of C++ */
183 /* A node for the integer constant 2. */
185 tree integer_two_node;
187 /* Used only for jumps to as-yet undefined labels, since jumps to
188 defined labels can have their validity checked immediately. */
190 struct GTY((chain_next ("%h.next"))) named_label_use_entry {
191 struct named_label_use_entry *next;
192 /* The binding level to which this entry is *currently* attached.
193 This is initially the binding level in which the goto appeared,
194 but is modified as scopes are closed. */
195 cp_binding_level *binding_level;
196 /* The head of the names list that was current when the goto appeared,
197 or the inner scope popped. These are the decls that will *not* be
198 skipped when jumping to the label. */
199 tree names_in_scope;
200 /* The location of the goto, for error reporting. */
201 location_t o_goto_locus;
202 /* True if an OpenMP structured block scope has been closed since
203 the goto appeared. This means that the branch from the label will
204 illegally exit an OpenMP scope. */
205 bool in_omp_scope;
208 /* A list of all LABEL_DECLs in the function that have names. Here so
209 we can clear out their names' definitions at the end of the
210 function, and so we can check the validity of jumps to these labels. */
212 struct GTY((for_user)) named_label_entry {
213 /* The decl itself. */
214 tree label_decl;
216 /* The binding level to which the label is *currently* attached.
217 This is initially set to the binding level in which the label
218 is defined, but is modified as scopes are closed. */
219 cp_binding_level *binding_level;
220 /* The head of the names list that was current when the label was
221 defined, or the inner scope popped. These are the decls that will
222 be skipped when jumping to the label. */
223 tree names_in_scope;
224 /* A vector of all decls from all binding levels that would be
225 crossed by a backward branch to the label. */
226 vec<tree, va_gc> *bad_decls;
228 /* A list of uses of the label, before the label is defined. */
229 struct named_label_use_entry *uses;
231 /* The following bits are set after the label is defined, and are
232 updated as scopes are popped. They indicate that a backward jump
233 to the label will illegally enter a scope of the given flavor. */
234 bool in_try_scope;
235 bool in_catch_scope;
236 bool in_omp_scope;
239 #define named_labels cp_function_chain->x_named_labels
241 /* The number of function bodies which we are currently processing.
242 (Zero if we are at namespace scope, one inside the body of a
243 function, two inside the body of a function in a local class, etc.) */
244 int function_depth;
246 /* To avoid unwanted recursion, finish_function defers all mark_used calls
247 encountered during its execution until it finishes. */
248 bool defer_mark_used_calls;
249 vec<tree, va_gc> *deferred_mark_used_calls;
251 /* States indicating how grokdeclarator() should handle declspecs marked
252 with __attribute__((deprecated)). An object declared as
253 __attribute__((deprecated)) suppresses warnings of uses of other
254 deprecated items. */
255 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
258 /* A list of VAR_DECLs whose type was incomplete at the time the
259 variable was declared. */
261 typedef struct GTY(()) incomplete_var_d {
262 tree decl;
263 tree incomplete_type;
264 } incomplete_var;
267 static GTY(()) vec<incomplete_var, va_gc> *incomplete_vars;
269 /* Returns the kind of template specialization we are currently
270 processing, given that it's declaration contained N_CLASS_SCOPES
271 explicit scope qualifications. */
273 tmpl_spec_kind
274 current_tmpl_spec_kind (int n_class_scopes)
276 int n_template_parm_scopes = 0;
277 int seen_specialization_p = 0;
278 int innermost_specialization_p = 0;
279 cp_binding_level *b;
281 /* Scan through the template parameter scopes. */
282 for (b = current_binding_level;
283 b->kind == sk_template_parms;
284 b = b->level_chain)
286 /* If we see a specialization scope inside a parameter scope,
287 then something is wrong. That corresponds to a declaration
288 like:
290 template <class T> template <> ...
292 which is always invalid since [temp.expl.spec] forbids the
293 specialization of a class member template if the enclosing
294 class templates are not explicitly specialized as well. */
295 if (b->explicit_spec_p)
297 if (n_template_parm_scopes == 0)
298 innermost_specialization_p = 1;
299 else
300 seen_specialization_p = 1;
302 else if (seen_specialization_p == 1)
303 return tsk_invalid_member_spec;
305 ++n_template_parm_scopes;
308 /* Handle explicit instantiations. */
309 if (processing_explicit_instantiation)
311 if (n_template_parm_scopes != 0)
312 /* We've seen a template parameter list during an explicit
313 instantiation. For example:
315 template <class T> template void f(int);
317 This is erroneous. */
318 return tsk_invalid_expl_inst;
319 else
320 return tsk_expl_inst;
323 if (n_template_parm_scopes < n_class_scopes)
324 /* We've not seen enough template headers to match all the
325 specialized classes present. For example:
327 template <class T> void R<T>::S<T>::f(int);
329 This is invalid; there needs to be one set of template
330 parameters for each class. */
331 return tsk_insufficient_parms;
332 else if (n_template_parm_scopes == n_class_scopes)
333 /* We're processing a non-template declaration (even though it may
334 be a member of a template class.) For example:
336 template <class T> void S<T>::f(int);
338 The `class T' matches the `S<T>', leaving no template headers
339 corresponding to the `f'. */
340 return tsk_none;
341 else if (n_template_parm_scopes > n_class_scopes + 1)
342 /* We've got too many template headers. For example:
344 template <> template <class T> void f (T);
346 There need to be more enclosing classes. */
347 return tsk_excessive_parms;
348 else
349 /* This must be a template. It's of the form:
351 template <class T> template <class U> void S<T>::f(U);
353 This is a specialization if the innermost level was a
354 specialization; otherwise it's just a definition of the
355 template. */
356 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
359 /* Exit the current scope. */
361 void
362 finish_scope (void)
364 poplevel (0, 0, 0);
367 /* When a label goes out of scope, check to see if that label was used
368 in a valid manner, and issue any appropriate warnings or errors. */
370 static void
371 pop_label (tree label, tree old_value)
373 if (!processing_template_decl)
375 if (DECL_INITIAL (label) == NULL_TREE)
377 location_t location;
379 error ("label %q+D used but not defined", label);
380 location = input_location;
381 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
382 /* Avoid crashing later. */
383 define_label (location, DECL_NAME (label));
385 else
386 warn_for_unused_label (label);
389 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
392 /* At the end of a function, all labels declared within the function
393 go out of scope. BLOCK is the top-level block for the
394 function. */
397 pop_labels_1 (named_label_entry **slot, tree block)
399 struct named_label_entry *ent = *slot;
401 pop_label (ent->label_decl, NULL_TREE);
403 /* Put the labels into the "variables" of the top-level block,
404 so debugger can see them. */
405 DECL_CHAIN (ent->label_decl) = BLOCK_VARS (block);
406 BLOCK_VARS (block) = ent->label_decl;
408 named_labels->clear_slot (slot);
410 return 1;
413 static void
414 pop_labels (tree block)
416 if (named_labels)
418 named_labels->traverse<tree, pop_labels_1> (block);
419 named_labels = NULL;
423 /* At the end of a block with local labels, restore the outer definition. */
425 static void
426 pop_local_label (tree label, tree old_value)
428 struct named_label_entry dummy;
430 pop_label (label, old_value);
432 dummy.label_decl = label;
433 named_label_entry **slot = named_labels->find_slot (&dummy, NO_INSERT);
434 named_labels->clear_slot (slot);
437 /* The following two routines are used to interface to Objective-C++.
438 The binding level is purposely treated as an opaque type. */
440 void *
441 objc_get_current_scope (void)
443 return current_binding_level;
446 /* The following routine is used by the NeXT-style SJLJ exceptions;
447 variables get marked 'volatile' so as to not be clobbered by
448 _setjmp()/_longjmp() calls. All variables in the current scope,
449 as well as parent scopes up to (but not including) ENCLOSING_BLK
450 shall be thusly marked. */
452 void
453 objc_mark_locals_volatile (void *enclosing_blk)
455 cp_binding_level *scope;
457 for (scope = current_binding_level;
458 scope && scope != enclosing_blk;
459 scope = scope->level_chain)
461 tree decl;
463 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
464 objc_volatilize_decl (decl);
466 /* Do not climb up past the current function. */
467 if (scope->kind == sk_function_parms)
468 break;
472 /* Update data for defined and undefined labels when leaving a scope. */
475 poplevel_named_label_1 (named_label_entry **slot, cp_binding_level *bl)
477 named_label_entry *ent = *slot;
478 cp_binding_level *obl = bl->level_chain;
480 if (ent->binding_level == bl)
482 tree decl;
484 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
485 TREE_LISTs representing OVERLOADs, so be careful. */
486 for (decl = ent->names_in_scope; decl; decl = (DECL_P (decl)
487 ? DECL_CHAIN (decl)
488 : TREE_CHAIN (decl)))
489 if (decl_jump_unsafe (decl))
490 vec_safe_push (ent->bad_decls, decl);
492 ent->binding_level = obl;
493 ent->names_in_scope = obl->names;
494 switch (bl->kind)
496 case sk_try:
497 ent->in_try_scope = true;
498 break;
499 case sk_catch:
500 ent->in_catch_scope = true;
501 break;
502 case sk_omp:
503 ent->in_omp_scope = true;
504 break;
505 default:
506 break;
509 else if (ent->uses)
511 struct named_label_use_entry *use;
513 for (use = ent->uses; use ; use = use->next)
514 if (use->binding_level == bl)
516 use->binding_level = obl;
517 use->names_in_scope = obl->names;
518 if (bl->kind == sk_omp)
519 use->in_omp_scope = true;
523 return 1;
526 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
527 when errors were reported, except for -Werror-unused-but-set-*. */
528 static int unused_but_set_errorcount;
530 /* Exit a binding level.
531 Pop the level off, and restore the state of the identifier-decl mappings
532 that were in effect when this level was entered.
534 If KEEP == 1, this level had explicit declarations, so
535 and create a "block" (a BLOCK node) for the level
536 to record its declarations and subblocks for symbol table output.
538 If FUNCTIONBODY is nonzero, this level is the body of a function,
539 so create a block as if KEEP were set and also clear out all
540 label names.
542 If REVERSE is nonzero, reverse the order of decls before putting
543 them into the BLOCK. */
545 tree
546 poplevel (int keep, int reverse, int functionbody)
548 tree link;
549 /* The chain of decls was accumulated in reverse order.
550 Put it into forward order, just for cleanliness. */
551 tree decls;
552 tree subblocks;
553 tree block;
554 tree decl;
555 int leaving_for_scope;
556 scope_kind kind;
557 unsigned ix;
558 cp_label_binding *label_bind;
560 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
561 restart:
563 block = NULL_TREE;
565 gcc_assert (current_binding_level->kind != sk_class);
567 if (current_binding_level->kind == sk_cleanup)
568 functionbody = 0;
569 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
571 gcc_assert (!vec_safe_length (current_binding_level->class_shadowed));
573 /* We used to use KEEP == 2 to indicate that the new block should go
574 at the beginning of the list of blocks at this binding level,
575 rather than the end. This hack is no longer used. */
576 gcc_assert (keep == 0 || keep == 1);
578 if (current_binding_level->keep)
579 keep = 1;
581 /* Any uses of undefined labels, and any defined labels, now operate
582 under constraints of next binding contour. */
583 if (cfun && !functionbody && named_labels)
584 named_labels->traverse<cp_binding_level *, poplevel_named_label_1>
585 (current_binding_level);
587 /* Get the decls in the order they were written.
588 Usually current_binding_level->names is in reverse order.
589 But parameter decls were previously put in forward order. */
591 if (reverse)
592 current_binding_level->names
593 = decls = nreverse (current_binding_level->names);
594 else
595 decls = current_binding_level->names;
597 /* If there were any declarations or structure tags in that level,
598 or if this level is a function body,
599 create a BLOCK to record them for the life of this function. */
600 block = NULL_TREE;
601 /* Avoid function body block if possible. */
602 if (functionbody && subblocks && BLOCK_CHAIN (subblocks) == NULL_TREE)
603 keep = 0;
604 else if (keep == 1 || functionbody)
605 block = make_node (BLOCK);
606 if (block != NULL_TREE)
608 BLOCK_VARS (block) = decls;
609 BLOCK_SUBBLOCKS (block) = subblocks;
612 /* In each subblock, record that this is its superior. */
613 if (keep >= 0)
614 for (link = subblocks; link; link = BLOCK_CHAIN (link))
615 BLOCK_SUPERCONTEXT (link) = block;
617 /* We still support the old for-scope rules, whereby the variables
618 in a for-init statement were in scope after the for-statement
619 ended. We only use the new rules if flag_new_for_scope is
620 nonzero. */
621 leaving_for_scope
622 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
624 /* Before we remove the declarations first check for unused variables. */
625 if ((warn_unused_variable || warn_unused_but_set_variable)
626 && current_binding_level->kind != sk_template_parms
627 && !processing_template_decl)
628 for (tree d = getdecls (); d; d = TREE_CHAIN (d))
630 /* There are cases where D itself is a TREE_LIST. See in
631 push_local_binding where the list of decls returned by
632 getdecls is built. */
633 decl = TREE_CODE (d) == TREE_LIST ? TREE_VALUE (d) : d;
634 tree type = TREE_TYPE (decl);
635 if (VAR_P (decl)
636 && (! TREE_USED (decl) || !DECL_READ_P (decl))
637 && ! DECL_IN_SYSTEM_HEADER (decl)
638 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)
639 && type != error_mark_node
640 && (!CLASS_TYPE_P (type)
641 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
642 || lookup_attribute ("warn_unused",
643 TYPE_ATTRIBUTES (TREE_TYPE (decl)))))
645 if (! TREE_USED (decl))
646 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
647 else if (DECL_CONTEXT (decl) == current_function_decl
648 // For -Wunused-but-set-variable leave references alone.
649 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
650 && errorcount == unused_but_set_errorcount)
652 warning (OPT_Wunused_but_set_variable,
653 "variable %q+D set but not used", decl);
654 unused_but_set_errorcount = errorcount;
659 /* Remove declarations for all the DECLs in this level. */
660 for (link = decls; link; link = TREE_CHAIN (link))
662 if (leaving_for_scope && VAR_P (link)
663 /* It's hard to make this ARM compatibility hack play nicely with
664 lambdas, and it really isn't necessary in C++11 mode. */
665 && cxx_dialect < cxx11
666 && DECL_NAME (link))
668 tree name = DECL_NAME (link);
669 cxx_binding *ob;
670 tree ns_binding;
672 ob = outer_binding (name,
673 IDENTIFIER_BINDING (name),
674 /*class_p=*/true);
675 if (!ob)
676 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
677 else
678 ns_binding = NULL_TREE;
680 if (ob && ob->scope == current_binding_level->level_chain)
681 /* We have something like:
683 int i;
684 for (int i; ;);
686 and we are leaving the `for' scope. There's no reason to
687 keep the binding of the inner `i' in this case. */
688 pop_binding (name, link);
689 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
690 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
691 /* Here, we have something like:
693 typedef int I;
695 void f () {
696 for (int I; ;);
699 We must pop the for-scope binding so we know what's a
700 type and what isn't. */
701 pop_binding (name, link);
702 else
704 /* Mark this VAR_DECL as dead so that we can tell we left it
705 there only for backward compatibility. */
706 DECL_DEAD_FOR_LOCAL (link) = 1;
708 /* Keep track of what should have happened when we
709 popped the binding. */
710 if (ob && ob->value)
712 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
713 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
716 /* Add it to the list of dead variables in the next
717 outermost binding to that we can remove these when we
718 leave that binding. */
719 vec_safe_push (
720 current_binding_level->level_chain->dead_vars_from_for,
721 link);
723 /* Although we don't pop the cxx_binding, we do clear
724 its SCOPE since the scope is going away now. */
725 IDENTIFIER_BINDING (name)->scope
726 = current_binding_level->level_chain;
729 else
731 tree name;
733 /* Remove the binding. */
734 decl = link;
736 if (TREE_CODE (decl) == TREE_LIST)
737 decl = TREE_VALUE (decl);
738 name = decl;
740 if (TREE_CODE (name) == OVERLOAD)
741 name = OVL_FUNCTION (name);
743 gcc_assert (DECL_P (name));
744 pop_binding (DECL_NAME (name), decl);
748 /* Remove declarations for any `for' variables from inner scopes
749 that we kept around. */
750 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->dead_vars_from_for,
751 ix, decl)
752 pop_binding (DECL_NAME (decl), decl);
754 /* Restore the IDENTIFIER_TYPE_VALUEs. */
755 for (link = current_binding_level->type_shadowed;
756 link; link = TREE_CHAIN (link))
757 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
759 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
760 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->shadowed_labels,
761 ix, label_bind)
762 pop_local_label (label_bind->label, label_bind->prev_value);
764 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
765 list if a `using' declaration put them there. The debugging
766 back ends won't understand OVERLOAD, so we remove them here.
767 Because the BLOCK_VARS are (temporarily) shared with
768 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
769 popped all the bindings. */
770 if (block)
772 tree* d;
774 for (d = &BLOCK_VARS (block); *d; )
776 if (TREE_CODE (*d) == TREE_LIST)
777 *d = TREE_CHAIN (*d);
778 else
779 d = &DECL_CHAIN (*d);
783 /* If the level being exited is the top level of a function,
784 check over all the labels. */
785 if (functionbody)
787 if (block)
789 /* Since this is the top level block of a function, the vars are
790 the function's parameters. Don't leave them in the BLOCK
791 because they are found in the FUNCTION_DECL instead. */
792 BLOCK_VARS (block) = 0;
793 pop_labels (block);
795 else
796 pop_labels (subblocks);
799 kind = current_binding_level->kind;
800 if (kind == sk_cleanup)
802 tree stmt;
804 /* If this is a temporary binding created for a cleanup, then we'll
805 have pushed a statement list level. Pop that, create a new
806 BIND_EXPR for the block, and insert it into the stream. */
807 stmt = pop_stmt_list (current_binding_level->statement_list);
808 stmt = c_build_bind_expr (input_location, block, stmt);
809 add_stmt (stmt);
812 leave_scope ();
813 if (functionbody)
815 /* The current function is being defined, so its DECL_INITIAL
816 should be error_mark_node. */
817 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
818 DECL_INITIAL (current_function_decl) = block ? block : subblocks;
819 if (subblocks)
821 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
823 if (BLOCK_SUBBLOCKS (subblocks))
824 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks)) = 1;
826 else
827 BLOCK_OUTER_CURLY_BRACE_P (subblocks) = 1;
830 else if (block)
831 current_binding_level->blocks
832 = block_chainon (current_binding_level->blocks, block);
834 /* If we did not make a block for the level just exited,
835 any blocks made for inner levels
836 (since they cannot be recorded as subblocks in that level)
837 must be carried forward so they will later become subblocks
838 of something else. */
839 else if (subblocks)
840 current_binding_level->blocks
841 = block_chainon (current_binding_level->blocks, subblocks);
843 /* Each and every BLOCK node created here in `poplevel' is important
844 (e.g. for proper debugging information) so if we created one
845 earlier, mark it as "used". */
846 if (block)
847 TREE_USED (block) = 1;
849 /* All temporary bindings created for cleanups are popped silently. */
850 if (kind == sk_cleanup)
851 goto restart;
853 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
854 return block;
857 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
858 itself, calling F for each. The DATA is passed to F as well. */
860 static int
861 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
863 int result = 0;
864 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
866 result |= (*f) (name_space, data);
868 for (; current; current = DECL_CHAIN (current))
869 result |= walk_namespaces_r (current, f, data);
871 return result;
874 /* Walk all the namespaces, calling F for each. The DATA is passed to
875 F as well. */
878 walk_namespaces (walk_namespaces_fn f, void* data)
880 return walk_namespaces_r (global_namespace, f, data);
883 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
886 wrapup_globals_for_namespace (tree name_space, void* data ATTRIBUTE_UNUSED)
888 cp_binding_level *level = NAMESPACE_LEVEL (name_space);
889 vec<tree, va_gc> *statics = level->static_decls;
890 tree *vec = statics->address ();
891 int len = statics->length ();
893 /* Write out any globals that need to be output. */
894 return wrapup_global_declarations (vec, len);
897 /* In C++, you don't have to write `struct S' to refer to `S'; you
898 can just use `S'. We accomplish this by creating a TYPE_DECL as
899 if the user had written `typedef struct S S'. Create and return
900 the TYPE_DECL for TYPE. */
902 tree
903 create_implicit_typedef (tree name, tree type)
905 tree decl;
907 decl = build_decl (input_location, TYPE_DECL, name, type);
908 DECL_ARTIFICIAL (decl) = 1;
909 /* There are other implicit type declarations, like the one *within*
910 a class that allows you to write `S::S'. We must distinguish
911 amongst these. */
912 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
913 TYPE_NAME (type) = decl;
914 TYPE_STUB_DECL (type) = decl;
916 return decl;
919 /* Remember a local name for name-mangling purposes. */
921 static void
922 push_local_name (tree decl)
924 size_t i, nelts;
925 tree t, name;
927 timevar_start (TV_NAME_LOOKUP);
929 name = DECL_NAME (decl);
931 nelts = vec_safe_length (local_names);
932 for (i = 0; i < nelts; i++)
934 t = (*local_names)[i];
935 if (DECL_NAME (t) == name)
937 if (!DECL_LANG_SPECIFIC (decl))
938 retrofit_lang_decl (decl);
939 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
940 if (DECL_DISCRIMINATOR_SET_P (t))
941 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
942 else
943 DECL_DISCRIMINATOR (decl) = 1;
945 (*local_names)[i] = decl;
946 timevar_stop (TV_NAME_LOOKUP);
947 return;
951 vec_safe_push (local_names, decl);
952 timevar_stop (TV_NAME_LOOKUP);
955 /* Subroutine of duplicate_decls: return truthvalue of whether
956 or not types of these decls match.
958 For C++, we must compare the parameter list so that `int' can match
959 `int&' in a parameter position, but `int&' is not confused with
960 `const int&'. */
963 decls_match (tree newdecl, tree olddecl)
965 int types_match;
967 if (newdecl == olddecl)
968 return 1;
970 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
971 /* If the two DECLs are not even the same kind of thing, we're not
972 interested in their types. */
973 return 0;
975 gcc_assert (DECL_P (newdecl));
977 if (TREE_CODE (newdecl) == FUNCTION_DECL)
979 tree f1 = TREE_TYPE (newdecl);
980 tree f2 = TREE_TYPE (olddecl);
981 tree p1 = TYPE_ARG_TYPES (f1);
982 tree p2 = TYPE_ARG_TYPES (f2);
983 tree r2;
985 /* Specializations of different templates are different functions
986 even if they have the same type. */
987 tree t1 = (DECL_USE_TEMPLATE (newdecl)
988 ? DECL_TI_TEMPLATE (newdecl)
989 : NULL_TREE);
990 tree t2 = (DECL_USE_TEMPLATE (olddecl)
991 ? DECL_TI_TEMPLATE (olddecl)
992 : NULL_TREE);
993 if (t1 != t2)
994 return 0;
996 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
997 && ! (DECL_EXTERN_C_P (newdecl)
998 && DECL_EXTERN_C_P (olddecl)))
999 return 0;
1001 /* A new declaration doesn't match a built-in one unless it
1002 is also extern "C". */
1003 if (DECL_IS_BUILTIN (olddecl)
1004 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
1005 return 0;
1007 if (TREE_CODE (f1) != TREE_CODE (f2))
1008 return 0;
1010 /* A declaration with deduced return type should use its pre-deduction
1011 type for declaration matching. */
1012 r2 = fndecl_declared_return_type (olddecl);
1014 if (same_type_p (TREE_TYPE (f1), r2))
1016 if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
1017 && (DECL_BUILT_IN (olddecl)
1018 #ifndef NO_IMPLICIT_EXTERN_C
1019 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
1020 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
1021 #endif
1024 types_match = self_promoting_args_p (p1);
1025 if (p1 == void_list_node)
1026 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1028 #ifndef NO_IMPLICIT_EXTERN_C
1029 else if (!prototype_p (f1)
1030 && (DECL_EXTERN_C_P (olddecl)
1031 && DECL_IN_SYSTEM_HEADER (olddecl)
1032 && !DECL_CLASS_SCOPE_P (olddecl))
1033 && (DECL_EXTERN_C_P (newdecl)
1034 && DECL_IN_SYSTEM_HEADER (newdecl)
1035 && !DECL_CLASS_SCOPE_P (newdecl)))
1037 types_match = self_promoting_args_p (p2);
1038 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1040 #endif
1041 else
1042 types_match =
1043 compparms (p1, p2)
1044 && type_memfn_rqual (f1) == type_memfn_rqual (f2)
1045 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
1046 || comp_type_attributes (TREE_TYPE (newdecl),
1047 TREE_TYPE (olddecl)) != 0);
1049 else
1050 types_match = 0;
1052 /* The decls dont match if they correspond to two different versions
1053 of the same function. Disallow extern "C" functions to be
1054 versions for now. */
1055 if (types_match
1056 && !DECL_EXTERN_C_P (newdecl)
1057 && !DECL_EXTERN_C_P (olddecl)
1058 && targetm.target_option.function_versions (newdecl, olddecl))
1060 /* Mark functions as versions if necessary. Modify the mangled decl
1061 name if necessary. */
1062 if (DECL_FUNCTION_VERSIONED (newdecl)
1063 && DECL_FUNCTION_VERSIONED (olddecl))
1064 return 0;
1065 if (!DECL_FUNCTION_VERSIONED (newdecl))
1067 DECL_FUNCTION_VERSIONED (newdecl) = 1;
1068 if (DECL_ASSEMBLER_NAME_SET_P (newdecl))
1069 mangle_decl (newdecl);
1071 if (!DECL_FUNCTION_VERSIONED (olddecl))
1073 DECL_FUNCTION_VERSIONED (olddecl) = 1;
1074 if (DECL_ASSEMBLER_NAME_SET_P (olddecl))
1075 mangle_decl (olddecl);
1077 cgraph_node::record_function_versions (olddecl, newdecl);
1078 return 0;
1081 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1083 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1084 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1085 return 0;
1087 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1088 DECL_TEMPLATE_PARMS (olddecl)))
1089 return 0;
1091 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1092 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1093 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1094 else
1095 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1096 DECL_TEMPLATE_RESULT (newdecl));
1098 else
1100 /* Need to check scope for variable declaration (VAR_DECL).
1101 For typedef (TYPE_DECL), scope is ignored. */
1102 if (VAR_P (newdecl)
1103 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1104 /* [dcl.link]
1105 Two declarations for an object with C language linkage
1106 with the same name (ignoring the namespace that qualify
1107 it) that appear in different namespace scopes refer to
1108 the same object. */
1109 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1110 return 0;
1112 if (TREE_TYPE (newdecl) == error_mark_node)
1113 types_match = TREE_TYPE (olddecl) == error_mark_node;
1114 else if (TREE_TYPE (olddecl) == NULL_TREE)
1115 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1116 else if (TREE_TYPE (newdecl) == NULL_TREE)
1117 types_match = 0;
1118 else
1119 types_match = comptypes (TREE_TYPE (newdecl),
1120 TREE_TYPE (olddecl),
1121 COMPARE_REDECLARATION);
1124 return types_match;
1127 /* If NEWDECL is `static' and an `extern' was seen previously,
1128 warn about it. OLDDECL is the previous declaration.
1130 Note that this does not apply to the C++ case of declaring
1131 a variable `extern const' and then later `const'.
1133 Don't complain about built-in functions, since they are beyond
1134 the user's control. */
1136 void
1137 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1139 if (TREE_CODE (newdecl) == TYPE_DECL
1140 || TREE_CODE (newdecl) == TEMPLATE_DECL
1141 || TREE_CODE (newdecl) == CONST_DECL
1142 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1143 return;
1145 /* Don't get confused by static member functions; that's a different
1146 use of `static'. */
1147 if (TREE_CODE (newdecl) == FUNCTION_DECL
1148 && DECL_STATIC_FUNCTION_P (newdecl))
1149 return;
1151 /* If the old declaration was `static', or the new one isn't, then
1152 everything is OK. */
1153 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1154 return;
1156 /* It's OK to declare a builtin function as `static'. */
1157 if (TREE_CODE (olddecl) == FUNCTION_DECL
1158 && DECL_ARTIFICIAL (olddecl))
1159 return;
1161 if (permerror (DECL_SOURCE_LOCATION (newdecl),
1162 "%qD was declared %<extern%> and later %<static%>", newdecl))
1163 inform (input_location, "previous declaration of %q+D", olddecl);
1166 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1167 function templates. If their exception specifications do not
1168 match, issue a diagnostic. */
1170 static void
1171 check_redeclaration_exception_specification (tree new_decl,
1172 tree old_decl)
1174 tree new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl));
1175 tree old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl));
1177 /* Two default specs are equivalent, don't force evaluation. */
1178 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions)
1179 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions))
1180 return;
1182 maybe_instantiate_noexcept (new_decl);
1183 maybe_instantiate_noexcept (old_decl);
1184 new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl));
1185 old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl));
1187 /* [except.spec]
1189 If any declaration of a function has an exception-specification,
1190 all declarations, including the definition and an explicit
1191 specialization, of that function shall have an
1192 exception-specification with the same set of type-ids. */
1193 if (! DECL_IS_BUILTIN (old_decl)
1194 && flag_exceptions
1195 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal))
1197 const char *msg
1198 = "declaration of %q+F has a different exception specifier";
1199 bool complained = true;
1200 if (! DECL_IN_SYSTEM_HEADER (old_decl))
1201 error (msg, new_decl);
1202 else
1203 complained = pedwarn (0, OPT_Wsystem_headers, msg, new_decl);
1204 if (complained)
1205 inform (0, "from previous declaration %q+F", old_decl);
1209 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1210 Otherwise issue diagnostics. */
1212 static bool
1213 validate_constexpr_redeclaration (tree old_decl, tree new_decl)
1215 old_decl = STRIP_TEMPLATE (old_decl);
1216 new_decl = STRIP_TEMPLATE (new_decl);
1217 if (!VAR_OR_FUNCTION_DECL_P (old_decl)
1218 || !VAR_OR_FUNCTION_DECL_P (new_decl))
1219 return true;
1220 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
1221 == DECL_DECLARED_CONSTEXPR_P (new_decl))
1222 return true;
1223 if (TREE_CODE (old_decl) == FUNCTION_DECL)
1225 if (DECL_BUILT_IN (old_decl))
1227 /* Hide a built-in declaration. */
1228 DECL_DECLARED_CONSTEXPR_P (old_decl)
1229 = DECL_DECLARED_CONSTEXPR_P (new_decl);
1230 return true;
1232 /* 7.1.5 [dcl.constexpr]
1233 Note: An explicit specialization can differ from the template
1234 declaration with respect to the constexpr specifier. */
1235 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl)
1236 && DECL_TEMPLATE_SPECIALIZATION (new_decl))
1237 return true;
1239 error ("redeclaration %q+D differs in %<constexpr%>", new_decl);
1240 error ("from previous declaration %q+D", old_decl);
1241 return false;
1243 return true;
1246 /* DECL is a redeclaration of a function or function template. If
1247 it does have default arguments issue a diagnostic. Note: this
1248 function is used to enforce the requirements in C++11 8.3.6 about
1249 no default arguments in redeclarations. */
1251 static void
1252 check_redeclaration_no_default_args (tree decl)
1254 gcc_assert (DECL_DECLARES_FUNCTION_P (decl));
1256 for (tree t = FUNCTION_FIRST_USER_PARMTYPE (decl);
1257 t && t != void_list_node; t = TREE_CHAIN (t))
1258 if (TREE_PURPOSE (t))
1260 permerror (input_location,
1261 "redeclaration of %q+#D may not have default "
1262 "arguments", decl);
1263 return;
1267 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1268 && lookup_attribute ("gnu_inline", \
1269 DECL_ATTRIBUTES (fn)))
1271 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1272 If the redeclaration is invalid, a diagnostic is issued, and the
1273 error_mark_node is returned. Otherwise, OLDDECL is returned.
1275 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1276 returned.
1278 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1280 tree
1281 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1283 unsigned olddecl_uid = DECL_UID (olddecl);
1284 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1285 int new_defines_function = 0;
1286 tree new_template_info;
1288 if (newdecl == olddecl)
1289 return olddecl;
1291 types_match = decls_match (newdecl, olddecl);
1293 /* If either the type of the new decl or the type of the old decl is an
1294 error_mark_node, then that implies that we have already issued an
1295 error (earlier) for some bogus type specification, and in that case,
1296 it is rather pointless to harass the user with yet more error message
1297 about the same declaration, so just pretend the types match here. */
1298 if (TREE_TYPE (newdecl) == error_mark_node
1299 || TREE_TYPE (olddecl) == error_mark_node)
1300 return error_mark_node;
1302 if (UDLIT_OPER_P (DECL_NAME (newdecl))
1303 && UDLIT_OPER_P (DECL_NAME (olddecl)))
1305 if (TREE_CODE (newdecl) == TEMPLATE_DECL
1306 && TREE_CODE (olddecl) != TEMPLATE_DECL
1307 && check_raw_literal_operator (olddecl))
1308 error ("literal operator template %q+D conflicts with"
1309 " raw literal operator %qD", newdecl, olddecl);
1310 else if (TREE_CODE (newdecl) != TEMPLATE_DECL
1311 && TREE_CODE (olddecl) == TEMPLATE_DECL
1312 && check_raw_literal_operator (newdecl))
1313 error ("raw literal operator %q+D conflicts with"
1314 " literal operator template %qD", newdecl, olddecl);
1317 if (DECL_P (olddecl)
1318 && TREE_CODE (newdecl) == FUNCTION_DECL
1319 && TREE_CODE (olddecl) == FUNCTION_DECL
1320 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1322 if (DECL_DECLARED_INLINE_P (newdecl)
1323 && DECL_UNINLINABLE (newdecl)
1324 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1325 /* Already warned elsewhere. */;
1326 else if (DECL_DECLARED_INLINE_P (olddecl)
1327 && DECL_UNINLINABLE (olddecl)
1328 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1329 /* Already warned. */;
1330 else if (DECL_DECLARED_INLINE_P (newdecl)
1331 && DECL_UNINLINABLE (olddecl)
1332 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1334 if (warning (OPT_Wattributes, "function %q+D redeclared as inline",
1335 newdecl))
1336 inform (DECL_SOURCE_LOCATION (olddecl),
1337 "previous declaration of %qD with attribute noinline",
1338 olddecl);
1340 else if (DECL_DECLARED_INLINE_P (olddecl)
1341 && DECL_UNINLINABLE (newdecl)
1342 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1344 if (warning (OPT_Wattributes, "function %q+D redeclared with "
1345 "attribute noinline", newdecl))
1346 inform (DECL_SOURCE_LOCATION (olddecl),
1347 "previous declaration of %qD was inline",
1348 olddecl);
1352 /* Check for redeclaration and other discrepancies. */
1353 if (TREE_CODE (olddecl) == FUNCTION_DECL
1354 && DECL_ARTIFICIAL (olddecl))
1356 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1357 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1359 /* Avoid warnings redeclaring built-ins which have not been
1360 explicitly declared. */
1361 if (DECL_ANTICIPATED (olddecl))
1362 return NULL_TREE;
1364 /* If you declare a built-in or predefined function name as static,
1365 the old definition is overridden, but optionally warn this was a
1366 bad choice of name. */
1367 if (! TREE_PUBLIC (newdecl))
1369 warning (OPT_Wshadow,
1370 DECL_BUILT_IN (olddecl)
1371 ? G_("shadowing built-in function %q#D")
1372 : G_("shadowing library function %q#D"), olddecl);
1373 /* Discard the old built-in function. */
1374 return NULL_TREE;
1376 /* If the built-in is not ansi, then programs can override
1377 it even globally without an error. */
1378 else if (! DECL_BUILT_IN (olddecl))
1379 warning (0, "library function %q#D redeclared as non-function %q+#D",
1380 olddecl, newdecl);
1381 else
1382 error ("declaration of %q+#D conflicts with built-in "
1383 "declaration %q#D", newdecl, olddecl);
1384 return NULL_TREE;
1386 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl))
1388 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl));
1389 error_at (DECL_SOURCE_LOCATION (newdecl),
1390 "redeclaration of %<pragma omp declare reduction%>");
1391 inform (DECL_SOURCE_LOCATION (olddecl),
1392 "previous %<pragma omp declare reduction%> declaration");
1393 return error_mark_node;
1395 else if (!types_match)
1397 /* Avoid warnings redeclaring built-ins which have not been
1398 explicitly declared. */
1399 if (DECL_ANTICIPATED (olddecl))
1401 /* Deal with fileptr_type_node. FILE type is not known
1402 at the time we create the builtins. */
1403 tree t1, t2;
1405 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1406 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1407 t1 || t2;
1408 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1409 if (!t1 || !t2)
1410 break;
1411 else if (TREE_VALUE (t2) == fileptr_type_node)
1413 tree t = TREE_VALUE (t1);
1415 if (TYPE_PTR_P (t)
1416 && TYPE_IDENTIFIER (TREE_TYPE (t))
1417 == get_identifier ("FILE")
1418 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1420 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1422 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1423 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1424 types_match = decls_match (newdecl, olddecl);
1425 if (types_match)
1426 return duplicate_decls (newdecl, olddecl,
1427 newdecl_is_friend);
1428 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1431 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1432 break;
1434 else if ((DECL_EXTERN_C_P (newdecl)
1435 && DECL_EXTERN_C_P (olddecl))
1436 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1437 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1439 /* A near match; override the builtin. */
1441 if (TREE_PUBLIC (newdecl))
1442 warning (0, "new declaration %q+#D ambiguates built-in "
1443 "declaration %q#D", newdecl, olddecl);
1444 else
1445 warning (OPT_Wshadow,
1446 DECL_BUILT_IN (olddecl)
1447 ? G_("shadowing built-in function %q#D")
1448 : G_("shadowing library function %q#D"), olddecl);
1450 else
1451 /* Discard the old built-in function. */
1452 return NULL_TREE;
1454 /* Replace the old RTL to avoid problems with inlining. */
1455 COPY_DECL_RTL (newdecl, olddecl);
1457 /* Even if the types match, prefer the new declarations type for
1458 built-ins which have not been explicitly declared, for
1459 exception lists, etc... */
1460 else if (DECL_IS_BUILTIN (olddecl))
1462 tree type = TREE_TYPE (newdecl);
1463 tree attribs = (*targetm.merge_type_attributes)
1464 (TREE_TYPE (olddecl), type);
1466 type = cp_build_type_attribute_variant (type, attribs);
1467 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1470 /* If a function is explicitly declared "throw ()", propagate that to
1471 the corresponding builtin. */
1472 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1473 && DECL_ANTICIPATED (olddecl)
1474 && TREE_NOTHROW (newdecl)
1475 && !TREE_NOTHROW (olddecl))
1477 enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl);
1478 tree tmpdecl = builtin_decl_explicit (fncode);
1479 if (tmpdecl && tmpdecl != olddecl && types_match)
1480 TREE_NOTHROW (tmpdecl) = 1;
1483 /* Whether or not the builtin can throw exceptions has no
1484 bearing on this declarator. */
1485 TREE_NOTHROW (olddecl) = 0;
1487 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1489 /* If a builtin function is redeclared as `static', merge
1490 the declarations, but make the original one static. */
1491 DECL_THIS_STATIC (olddecl) = 1;
1492 TREE_PUBLIC (olddecl) = 0;
1494 /* Make the old declaration consistent with the new one so
1495 that all remnants of the builtin-ness of this function
1496 will be banished. */
1497 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1498 COPY_DECL_RTL (newdecl, olddecl);
1501 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1503 /* C++ Standard, 3.3, clause 4:
1504 "[Note: a namespace name or a class template name must be unique
1505 in its declarative region (7.3.2, clause 14). ]" */
1506 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1507 && TREE_CODE (newdecl) != NAMESPACE_DECL
1508 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1509 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1510 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1511 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1513 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1514 && TREE_CODE (newdecl) != TYPE_DECL)
1515 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1516 && TREE_CODE (olddecl) != TYPE_DECL))
1518 /* We do nothing special here, because C++ does such nasty
1519 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1520 get shadowed, and know that if we need to find a TYPE_DECL
1521 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1522 slot of the identifier. */
1523 return NULL_TREE;
1526 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1527 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1528 || (TREE_CODE (olddecl) == FUNCTION_DECL
1529 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1530 return NULL_TREE;
1533 error ("%q#D redeclared as different kind of symbol", newdecl);
1534 if (TREE_CODE (olddecl) == TREE_LIST)
1535 olddecl = TREE_VALUE (olddecl);
1536 inform (DECL_SOURCE_LOCATION (olddecl),
1537 "previous declaration %q#D", olddecl);
1539 return error_mark_node;
1541 else if (!types_match)
1543 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1544 /* These are certainly not duplicate declarations; they're
1545 from different scopes. */
1546 return NULL_TREE;
1548 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1550 /* The name of a class template may not be declared to refer to
1551 any other template, class, function, object, namespace, value,
1552 or type in the same scope. */
1553 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1554 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1556 error ("conflicting declaration of template %q+#D", newdecl);
1557 inform (DECL_SOURCE_LOCATION (olddecl),
1558 "previous declaration %q#D", olddecl);
1559 return error_mark_node;
1561 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1562 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1563 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1564 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1565 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1566 DECL_TEMPLATE_PARMS (olddecl))
1567 /* Template functions can be disambiguated by
1568 return type. */
1569 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1570 TREE_TYPE (TREE_TYPE (olddecl))))
1572 error ("ambiguating new declaration %q+#D", newdecl);
1573 inform (DECL_SOURCE_LOCATION (olddecl),
1574 "old declaration %q#D", olddecl);
1576 return NULL_TREE;
1578 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1580 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1582 error ("conflicting declaration of C function %q+#D",
1583 newdecl);
1584 inform (DECL_SOURCE_LOCATION (olddecl),
1585 "previous declaration %q#D", olddecl);
1586 return NULL_TREE;
1588 /* For function versions, params and types match, but they
1589 are not ambiguous. */
1590 else if ((!DECL_FUNCTION_VERSIONED (newdecl)
1591 && !DECL_FUNCTION_VERSIONED (olddecl))
1592 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1593 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1595 error ("ambiguating new declaration of %q+#D", newdecl);
1596 inform (DECL_SOURCE_LOCATION (olddecl),
1597 "old declaration %q#D", olddecl);
1598 return error_mark_node;
1600 else
1601 return NULL_TREE;
1603 else
1605 error ("conflicting declaration %q+#D", newdecl);
1606 inform (DECL_SOURCE_LOCATION (olddecl),
1607 "previous declaration as %q#D", olddecl);
1608 return error_mark_node;
1611 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1612 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1613 && (!DECL_TEMPLATE_INFO (newdecl)
1614 || (DECL_TI_TEMPLATE (newdecl)
1615 != DECL_TI_TEMPLATE (olddecl))))
1616 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1617 && (!DECL_TEMPLATE_INFO (olddecl)
1618 || (DECL_TI_TEMPLATE (olddecl)
1619 != DECL_TI_TEMPLATE (newdecl))))))
1620 /* It's OK to have a template specialization and a non-template
1621 with the same type, or to have specializations of two
1622 different templates with the same type. Note that if one is a
1623 specialization, and the other is an instantiation of the same
1624 template, that we do not exit at this point. That situation
1625 can occur if we instantiate a template class, and then
1626 specialize one of its methods. This situation is valid, but
1627 the declarations must be merged in the usual way. */
1628 return NULL_TREE;
1629 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1630 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1631 && !DECL_USE_TEMPLATE (newdecl))
1632 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1633 && !DECL_USE_TEMPLATE (olddecl))))
1634 /* One of the declarations is a template instantiation, and the
1635 other is not a template at all. That's OK. */
1636 return NULL_TREE;
1637 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1639 /* In [namespace.alias] we have:
1641 In a declarative region, a namespace-alias-definition can be
1642 used to redefine a namespace-alias declared in that declarative
1643 region to refer only to the namespace to which it already
1644 refers.
1646 Therefore, if we encounter a second alias directive for the same
1647 alias, we can just ignore the second directive. */
1648 if (DECL_NAMESPACE_ALIAS (newdecl)
1649 && (DECL_NAMESPACE_ALIAS (newdecl)
1650 == DECL_NAMESPACE_ALIAS (olddecl)))
1651 return olddecl;
1652 /* [namespace.alias]
1654 A namespace-name or namespace-alias shall not be declared as
1655 the name of any other entity in the same declarative region.
1656 A namespace-name defined at global scope shall not be
1657 declared as the name of any other entity in any global scope
1658 of the program. */
1659 error ("conflicting declaration of namespace %q+D", newdecl);
1660 inform (DECL_SOURCE_LOCATION (olddecl),
1661 "previous declaration of namespace %qD here", olddecl);
1662 return error_mark_node;
1664 else
1666 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1667 if (errmsg)
1669 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1670 if (DECL_NAME (olddecl) != NULL_TREE)
1671 inform (input_location,
1672 (DECL_INITIAL (olddecl) && namespace_bindings_p ())
1673 ? G_("%q+#D previously defined here")
1674 : G_("%q+#D previously declared here"), olddecl);
1675 return error_mark_node;
1677 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1678 && DECL_INITIAL (olddecl) != NULL_TREE
1679 && !prototype_p (TREE_TYPE (olddecl))
1680 && prototype_p (TREE_TYPE (newdecl)))
1682 /* Prototype decl follows defn w/o prototype. */
1683 if (warning_at (DECL_SOURCE_LOCATION (newdecl), 0,
1684 "prototype specified for %q+#D", newdecl))
1685 inform (DECL_SOURCE_LOCATION (olddecl),
1686 "previous non-prototype definition here");
1688 else if (VAR_OR_FUNCTION_DECL_P (olddecl)
1689 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1691 /* [dcl.link]
1692 If two declarations of the same function or object
1693 specify different linkage-specifications ..., the program
1694 is ill-formed.... Except for functions with C++ linkage,
1695 a function declaration without a linkage specification
1696 shall not precede the first linkage specification for
1697 that function. A function can be declared without a
1698 linkage specification after an explicit linkage
1699 specification has been seen; the linkage explicitly
1700 specified in the earlier declaration is not affected by
1701 such a function declaration.
1703 DR 563 raises the question why the restrictions on
1704 functions should not also apply to objects. Older
1705 versions of G++ silently ignore the linkage-specification
1706 for this example:
1708 namespace N {
1709 extern int i;
1710 extern "C" int i;
1713 which is clearly wrong. Therefore, we now treat objects
1714 like functions. */
1715 if (current_lang_depth () == 0)
1717 /* There is no explicit linkage-specification, so we use
1718 the linkage from the previous declaration. */
1719 if (!DECL_LANG_SPECIFIC (newdecl))
1720 retrofit_lang_decl (newdecl);
1721 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1723 else
1725 error ("conflicting declaration of %q+#D with %qL linkage",
1726 newdecl, DECL_LANGUAGE (newdecl));
1727 inform (DECL_SOURCE_LOCATION (olddecl),
1728 "previous declaration with %qL linkage",
1729 DECL_LANGUAGE (olddecl));
1733 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1735 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1737 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1738 if (DECL_FUNCTION_MEMBER_P (olddecl)
1739 && (/* grokfndecl passes member function templates too
1740 as FUNCTION_DECLs. */
1741 DECL_TEMPLATE_INFO (olddecl)
1742 /* C++11 8.3.6/6.
1743 Default arguments for a member function of a class
1744 template shall be specified on the initial declaration
1745 of the member function within the class template. */
1746 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl))))
1747 check_redeclaration_no_default_args (newdecl);
1748 else
1750 tree t1 = FUNCTION_FIRST_USER_PARMTYPE (olddecl);
1751 tree t2 = FUNCTION_FIRST_USER_PARMTYPE (newdecl);
1752 int i = 1;
1754 for (; t1 && t1 != void_list_node;
1755 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1756 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1758 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1759 TREE_PURPOSE (t2)))
1761 if (permerror (input_location,
1762 "default argument given for parameter "
1763 "%d of %q#D", i, newdecl))
1764 inform (DECL_SOURCE_LOCATION (olddecl),
1765 "previous specification in %q#D here",
1766 olddecl);
1768 else
1770 error ("default argument given for parameter %d "
1771 "of %q#D", i, newdecl);
1772 inform (DECL_SOURCE_LOCATION (olddecl),
1773 "previous specification in %q#D here",
1774 olddecl);
1781 /* Do not merge an implicit typedef with an explicit one. In:
1783 class A;
1785 typedef class A A __attribute__ ((foo));
1787 the attribute should apply only to the typedef. */
1788 if (TREE_CODE (olddecl) == TYPE_DECL
1789 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1790 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1791 return NULL_TREE;
1793 /* If new decl is `static' and an `extern' was seen previously,
1794 warn about it. */
1795 warn_extern_redeclared_static (newdecl, olddecl);
1797 if (!validate_constexpr_redeclaration (olddecl, newdecl))
1798 return error_mark_node;
1800 /* We have committed to returning 1 at this point. */
1801 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1803 /* Now that functions must hold information normally held
1804 by field decls, there is extra work to do so that
1805 declaration information does not get destroyed during
1806 definition. */
1807 if (DECL_VINDEX (olddecl))
1808 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1809 if (DECL_CONTEXT (olddecl))
1810 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1811 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1812 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1813 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1814 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1815 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1816 DECL_FINAL_P (newdecl) |= DECL_FINAL_P (olddecl);
1817 DECL_OVERRIDE_P (newdecl) |= DECL_OVERRIDE_P (olddecl);
1818 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1819 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1820 SET_OVERLOADED_OPERATOR_CODE
1821 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1822 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1824 /* Optionally warn about more than one declaration for the same
1825 name, but don't warn about a function declaration followed by a
1826 definition. */
1827 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1828 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1829 /* Don't warn about extern decl followed by definition. */
1830 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1831 /* Don't warn about friends, let add_friend take care of it. */
1832 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
1833 /* Don't warn about declaration followed by specialization. */
1834 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
1835 || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
1837 if (warning (OPT_Wredundant_decls,
1838 "redundant redeclaration of %q+D in same scope",
1839 newdecl))
1840 inform (DECL_SOURCE_LOCATION (olddecl),
1841 "previous declaration of %qD", olddecl);
1844 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl)
1845 && DECL_TEMPLATE_SPECIALIZATION (newdecl)))
1847 if (DECL_DELETED_FN (newdecl))
1849 error ("deleted definition of %q+D", newdecl);
1850 inform (DECL_SOURCE_LOCATION (olddecl),
1851 "previous declaration of %qD", olddecl);
1853 DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl);
1857 /* Deal with C++: must preserve virtual function table size. */
1858 if (TREE_CODE (olddecl) == TYPE_DECL)
1860 tree newtype = TREE_TYPE (newdecl);
1861 tree oldtype = TREE_TYPE (olddecl);
1863 if (newtype != error_mark_node && oldtype != error_mark_node
1864 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1865 CLASSTYPE_FRIEND_CLASSES (newtype)
1866 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1868 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1871 /* Copy all the DECL_... slots specified in the new decl
1872 except for any that we copy here from the old type. */
1873 DECL_ATTRIBUTES (newdecl)
1874 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1876 if (DECL_DECLARES_FUNCTION_P (olddecl) && DECL_DECLARES_FUNCTION_P (newdecl))
1878 olddecl_friend = DECL_FRIEND_P (olddecl);
1879 hidden_friend = (DECL_ANTICIPATED (olddecl)
1880 && DECL_HIDDEN_FRIEND_P (olddecl)
1881 && newdecl_is_friend);
1882 if (!hidden_friend)
1884 DECL_ANTICIPATED (olddecl) = 0;
1885 DECL_HIDDEN_FRIEND_P (olddecl) = 0;
1889 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1891 tree old_result;
1892 tree new_result;
1893 old_result = DECL_TEMPLATE_RESULT (olddecl);
1894 new_result = DECL_TEMPLATE_RESULT (newdecl);
1895 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1896 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1897 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1898 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1900 DECL_ATTRIBUTES (old_result)
1901 = (*targetm.merge_decl_attributes) (old_result, new_result);
1903 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1905 /* Per C++11 8.3.6/4, default arguments cannot be added in later
1906 declarations of a function template. */
1907 if (DECL_SOURCE_LOCATION (newdecl)
1908 != DECL_SOURCE_LOCATION (olddecl))
1909 check_redeclaration_no_default_args (newdecl);
1911 check_default_args (newdecl);
1913 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1914 && DECL_INITIAL (new_result))
1916 if (DECL_INITIAL (old_result))
1917 DECL_UNINLINABLE (old_result) = 1;
1918 else
1919 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1920 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1921 DECL_NOT_REALLY_EXTERN (old_result)
1922 = DECL_NOT_REALLY_EXTERN (new_result);
1923 DECL_INTERFACE_KNOWN (old_result)
1924 = DECL_INTERFACE_KNOWN (new_result);
1925 DECL_DECLARED_INLINE_P (old_result)
1926 = DECL_DECLARED_INLINE_P (new_result);
1927 DECL_DISREGARD_INLINE_LIMITS (old_result)
1928 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1931 else
1933 DECL_DECLARED_INLINE_P (old_result)
1934 |= DECL_DECLARED_INLINE_P (new_result);
1935 DECL_DISREGARD_INLINE_LIMITS (old_result)
1936 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1937 check_redeclaration_exception_specification (newdecl, olddecl);
1941 /* If the new declaration is a definition, update the file and
1942 line information on the declaration, and also make
1943 the old declaration the same definition. */
1944 if (DECL_INITIAL (new_result) != NULL_TREE)
1946 DECL_SOURCE_LOCATION (olddecl)
1947 = DECL_SOURCE_LOCATION (old_result)
1948 = DECL_SOURCE_LOCATION (newdecl);
1949 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1950 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1952 tree parm;
1953 DECL_ARGUMENTS (old_result)
1954 = DECL_ARGUMENTS (new_result);
1955 for (parm = DECL_ARGUMENTS (old_result); parm;
1956 parm = DECL_CHAIN (parm))
1957 DECL_CONTEXT (parm) = old_result;
1961 return olddecl;
1964 if (types_match)
1966 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1967 check_redeclaration_exception_specification (newdecl, olddecl);
1969 /* Automatically handles default parameters. */
1970 tree oldtype = TREE_TYPE (olddecl);
1971 tree newtype;
1973 /* For typedefs use the old type, as the new type's DECL_NAME points
1974 at newdecl, which will be ggc_freed. */
1975 if (TREE_CODE (newdecl) == TYPE_DECL)
1976 newtype = oldtype;
1977 else
1978 /* Merge the data types specified in the two decls. */
1979 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1981 if (VAR_P (newdecl))
1983 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1984 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1985 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1986 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1987 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1988 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1990 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1991 if (DECL_LANG_SPECIFIC (olddecl)
1992 && CP_DECL_THREADPRIVATE_P (olddecl))
1994 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1995 if (!DECL_LANG_SPECIFIC (newdecl))
1996 retrofit_lang_decl (newdecl);
1998 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
2002 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
2004 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2005 check_default_args (newdecl);
2007 /* Lay the type out, unless already done. */
2008 if (! same_type_p (newtype, oldtype)
2009 && TREE_TYPE (newdecl) != error_mark_node
2010 && !(processing_template_decl && uses_template_parms (newdecl)))
2011 layout_type (TREE_TYPE (newdecl));
2013 if ((VAR_P (newdecl)
2014 || TREE_CODE (newdecl) == PARM_DECL
2015 || TREE_CODE (newdecl) == RESULT_DECL
2016 || TREE_CODE (newdecl) == FIELD_DECL
2017 || TREE_CODE (newdecl) == TYPE_DECL)
2018 && !(processing_template_decl && uses_template_parms (newdecl)))
2019 layout_decl (newdecl, 0);
2021 /* Merge the type qualifiers. */
2022 if (TREE_READONLY (newdecl))
2023 TREE_READONLY (olddecl) = 1;
2024 if (TREE_THIS_VOLATILE (newdecl))
2025 TREE_THIS_VOLATILE (olddecl) = 1;
2026 if (TREE_NOTHROW (newdecl))
2027 TREE_NOTHROW (olddecl) = 1;
2029 /* Merge deprecatedness. */
2030 if (TREE_DEPRECATED (newdecl))
2031 TREE_DEPRECATED (olddecl) = 1;
2033 /* Preserve function specific target and optimization options */
2034 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2036 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2037 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2038 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2039 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2041 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2042 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2043 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2044 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2047 /* Merge the initialization information. */
2048 if (DECL_INITIAL (newdecl) == NULL_TREE
2049 && DECL_INITIAL (olddecl) != NULL_TREE)
2051 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2052 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2053 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2055 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2056 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2060 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2062 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2063 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2064 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2065 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2066 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
2067 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2068 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2069 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2070 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2071 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
2072 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
2073 /* Keep the old RTL. */
2074 COPY_DECL_RTL (olddecl, newdecl);
2076 else if (VAR_P (newdecl)
2077 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
2079 /* Keep the old RTL. We cannot keep the old RTL if the old
2080 declaration was for an incomplete object and the new
2081 declaration is not since many attributes of the RTL will
2082 change. */
2083 COPY_DECL_RTL (olddecl, newdecl);
2086 /* If cannot merge, then use the new type and qualifiers,
2087 and don't preserve the old rtl. */
2088 else
2090 /* Clean out any memory we had of the old declaration. */
2091 tree oldstatic = value_member (olddecl, static_aggregates);
2092 if (oldstatic)
2093 TREE_VALUE (oldstatic) = error_mark_node;
2095 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2096 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2097 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2098 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
2101 /* Merge the storage class information. */
2102 merge_weak (newdecl, olddecl);
2104 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
2105 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2106 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
2107 if (! DECL_EXTERNAL (olddecl))
2108 DECL_EXTERNAL (newdecl) = 0;
2109 if (! DECL_COMDAT (olddecl))
2110 DECL_COMDAT (newdecl) = 0;
2112 new_template_info = NULL_TREE;
2113 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
2115 bool new_redefines_gnu_inline = false;
2117 if (new_defines_function
2118 && ((DECL_INTERFACE_KNOWN (olddecl)
2119 && TREE_CODE (olddecl) == FUNCTION_DECL)
2120 || (TREE_CODE (olddecl) == TEMPLATE_DECL
2121 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
2122 == FUNCTION_DECL))))
2124 tree fn = olddecl;
2126 if (TREE_CODE (fn) == TEMPLATE_DECL)
2127 fn = DECL_TEMPLATE_RESULT (olddecl);
2129 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
2132 if (!new_redefines_gnu_inline)
2134 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
2135 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
2136 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
2138 DECL_TEMPLATE_INSTANTIATED (newdecl)
2139 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
2140 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
2142 /* If the OLDDECL is an instantiation and/or specialization,
2143 then the NEWDECL must be too. But, it may not yet be marked
2144 as such if the caller has created NEWDECL, but has not yet
2145 figured out that it is a redeclaration. */
2146 if (!DECL_USE_TEMPLATE (newdecl))
2147 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
2149 /* Don't really know how much of the language-specific
2150 values we should copy from old to new. */
2151 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2152 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
2153 DECL_INITIALIZED_IN_CLASS_P (newdecl)
2154 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
2156 if (LANG_DECL_HAS_MIN (newdecl))
2158 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
2159 DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
2160 if (DECL_TEMPLATE_INFO (newdecl))
2162 new_template_info = DECL_TEMPLATE_INFO (newdecl);
2163 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2164 && DECL_TEMPLATE_SPECIALIZATION (newdecl))
2165 /* Remember the presence of explicit specialization args. */
2166 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl))
2167 = TINFO_USED_TEMPLATE_ID (new_template_info);
2169 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2171 /* Only functions have these fields. */
2172 if (DECL_DECLARES_FUNCTION_P (newdecl))
2174 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
2175 DECL_BEFRIENDING_CLASSES (newdecl)
2176 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
2177 DECL_BEFRIENDING_CLASSES (olddecl));
2178 /* DECL_THUNKS is only valid for virtual functions,
2179 otherwise it is a DECL_FRIEND_CONTEXT. */
2180 if (DECL_VIRTUAL_P (newdecl))
2181 SET_DECL_THUNKS (newdecl, DECL_THUNKS (olddecl));
2183 /* Only variables have this field. */
2184 else if (VAR_P (newdecl)
2185 && VAR_HAD_UNKNOWN_BOUND (olddecl))
2186 SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
2189 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2191 tree parm;
2193 /* Merge parameter attributes. */
2194 tree oldarg, newarg;
2195 for (oldarg = DECL_ARGUMENTS(olddecl),
2196 newarg = DECL_ARGUMENTS(newdecl);
2197 oldarg && newarg;
2198 oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) {
2199 DECL_ATTRIBUTES (newarg)
2200 = (*targetm.merge_decl_attributes) (oldarg, newarg);
2201 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
2204 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2205 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
2207 /* If newdecl is not a specialization, then it is not a
2208 template-related function at all. And that means that we
2209 should have exited above, returning 0. */
2210 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
2212 if (DECL_ODR_USED (olddecl))
2213 /* From [temp.expl.spec]:
2215 If a template, a member template or the member of a class
2216 template is explicitly specialized then that
2217 specialization shall be declared before the first use of
2218 that specialization that would cause an implicit
2219 instantiation to take place, in every translation unit in
2220 which such a use occurs. */
2221 error ("explicit specialization of %qD after first use",
2222 olddecl);
2224 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
2225 DECL_COMDAT (newdecl) = (TREE_PUBLIC (newdecl)
2226 && DECL_DECLARED_INLINE_P (newdecl));
2228 /* Don't propagate visibility from the template to the
2229 specialization here. We'll do that in determine_visibility if
2230 appropriate. */
2231 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
2233 /* [temp.expl.spec/14] We don't inline explicit specialization
2234 just because the primary template says so. */
2236 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2237 the always_inline attribute. */
2238 if (DECL_DISREGARD_INLINE_LIMITS (olddecl)
2239 && !DECL_DISREGARD_INLINE_LIMITS (newdecl))
2241 if (DECL_DECLARED_INLINE_P (newdecl))
2242 DECL_DISREGARD_INLINE_LIMITS (newdecl) = true;
2243 else
2244 DECL_ATTRIBUTES (newdecl)
2245 = remove_attribute ("always_inline",
2246 DECL_ATTRIBUTES (newdecl));
2249 else if (new_defines_function && DECL_INITIAL (olddecl))
2251 /* Never inline re-defined extern inline functions.
2252 FIXME: this could be better handled by keeping both
2253 function as separate declarations. */
2254 DECL_UNINLINABLE (newdecl) = 1;
2256 else
2258 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
2259 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2261 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
2263 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2264 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2266 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2267 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2268 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2269 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2272 /* Preserve abstractness on cloned [cd]tors. */
2273 DECL_ABSTRACT_P (newdecl) = DECL_ABSTRACT_P (olddecl);
2275 /* Update newdecl's parms to point at olddecl. */
2276 for (parm = DECL_ARGUMENTS (newdecl); parm;
2277 parm = DECL_CHAIN (parm))
2278 DECL_CONTEXT (parm) = olddecl;
2280 if (! types_match)
2282 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2283 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2284 COPY_DECL_RTL (newdecl, olddecl);
2286 if (! types_match || new_defines_function)
2288 /* These need to be copied so that the names are available.
2289 Note that if the types do match, we'll preserve inline
2290 info and other bits, but if not, we won't. */
2291 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2292 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2294 /* If redeclaring a builtin function, it stays built in
2295 if newdecl is a gnu_inline definition, or if newdecl is just
2296 a declaration. */
2297 if (DECL_BUILT_IN (olddecl)
2298 && (new_defines_function ? GNU_INLINE_P (newdecl) : types_match))
2300 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2301 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2302 /* If we're keeping the built-in definition, keep the rtl,
2303 regardless of declaration matches. */
2304 COPY_DECL_RTL (olddecl, newdecl);
2305 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2307 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2308 switch (fncode)
2310 /* If a compatible prototype of these builtin functions
2311 is seen, assume the runtime implements it with the
2312 expected semantics. */
2313 case BUILT_IN_STPCPY:
2314 if (builtin_decl_explicit_p (fncode))
2315 set_builtin_decl_implicit_p (fncode, true);
2316 break;
2317 default:
2318 if (builtin_decl_explicit_p (fncode))
2319 set_builtin_decl_declared_p (fncode, true);
2320 break;
2324 if (new_defines_function)
2325 /* If defining a function declared with other language
2326 linkage, use the previously declared language linkage. */
2327 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2328 else if (types_match)
2330 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2331 /* Don't clear out the arguments if we're just redeclaring a
2332 function. */
2333 if (DECL_ARGUMENTS (olddecl))
2334 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2337 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2338 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2340 /* Now preserve various other info from the definition. */
2341 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2342 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2343 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2344 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2346 /* Warn about conflicting visibility specifications. */
2347 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2348 && DECL_VISIBILITY_SPECIFIED (newdecl)
2349 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2351 if (warning_at (DECL_SOURCE_LOCATION (newdecl), OPT_Wattributes,
2352 "%qD: visibility attribute ignored because it "
2353 "conflicts with previous declaration", newdecl))
2354 inform (DECL_SOURCE_LOCATION (olddecl),
2355 "previous declaration of %qD", olddecl);
2357 /* Choose the declaration which specified visibility. */
2358 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2360 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2361 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2363 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2364 so keep this behavior. */
2365 if (VAR_P (newdecl) && DECL_HAS_INIT_PRIORITY_P (newdecl))
2367 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2368 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2370 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2371 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2373 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2374 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2376 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2377 if (TREE_CODE (newdecl) == FIELD_DECL)
2378 DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
2380 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2381 with that from NEWDECL below. */
2382 if (DECL_LANG_SPECIFIC (olddecl))
2384 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2385 != DECL_LANG_SPECIFIC (newdecl));
2386 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2389 /* Merge the USED information. */
2390 if (TREE_USED (olddecl))
2391 TREE_USED (newdecl) = 1;
2392 else if (TREE_USED (newdecl))
2393 TREE_USED (olddecl) = 1;
2394 if (VAR_P (newdecl))
2396 if (DECL_READ_P (olddecl))
2397 DECL_READ_P (newdecl) = 1;
2398 else if (DECL_READ_P (newdecl))
2399 DECL_READ_P (olddecl) = 1;
2401 if (DECL_PRESERVE_P (olddecl))
2402 DECL_PRESERVE_P (newdecl) = 1;
2403 else if (DECL_PRESERVE_P (newdecl))
2404 DECL_PRESERVE_P (olddecl) = 1;
2406 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2407 to olddecl and deleted. */
2408 if (TREE_CODE (newdecl) == FUNCTION_DECL
2409 && DECL_FUNCTION_VERSIONED (olddecl))
2411 /* Set the flag for newdecl so that it gets copied to olddecl. */
2412 DECL_FUNCTION_VERSIONED (newdecl) = 1;
2413 /* newdecl will be purged after copying to olddecl and is no longer
2414 a version. */
2415 cgraph_node::delete_function_version (newdecl);
2418 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2420 int function_size;
2421 struct symtab_node *snode = symtab_node::get (olddecl);
2423 function_size = sizeof (struct tree_decl_common);
2425 memcpy ((char *) olddecl + sizeof (struct tree_common),
2426 (char *) newdecl + sizeof (struct tree_common),
2427 function_size - sizeof (struct tree_common));
2429 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2430 (char *) newdecl + sizeof (struct tree_decl_common),
2431 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2433 /* Preserve symtab node mapping. */
2434 olddecl->decl_with_vis.symtab_node = snode;
2436 if (new_template_info)
2437 /* If newdecl is a template instantiation, it is possible that
2438 the following sequence of events has occurred:
2440 o A friend function was declared in a class template. The
2441 class template was instantiated.
2443 o The instantiation of the friend declaration was
2444 recorded on the instantiation list, and is newdecl.
2446 o Later, however, instantiate_class_template called pushdecl
2447 on the newdecl to perform name injection. But, pushdecl in
2448 turn called duplicate_decls when it discovered that another
2449 declaration of a global function with the same name already
2450 existed.
2452 o Here, in duplicate_decls, we decided to clobber newdecl.
2454 If we're going to do that, we'd better make sure that
2455 olddecl, and not newdecl, is on the list of
2456 instantiations so that if we try to do the instantiation
2457 again we won't get the clobbered declaration. */
2458 reregister_specialization (newdecl,
2459 new_template_info,
2460 olddecl);
2462 else
2464 size_t size = tree_code_size (TREE_CODE (newdecl));
2466 memcpy ((char *) olddecl + sizeof (struct tree_common),
2467 (char *) newdecl + sizeof (struct tree_common),
2468 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2469 switch (TREE_CODE (newdecl))
2471 case LABEL_DECL:
2472 case VAR_DECL:
2473 case RESULT_DECL:
2474 case PARM_DECL:
2475 case FIELD_DECL:
2476 case TYPE_DECL:
2477 case CONST_DECL:
2479 struct symtab_node *snode = NULL;
2481 if (TREE_CODE (newdecl) == VAR_DECL
2482 && (TREE_STATIC (olddecl) || TREE_PUBLIC (olddecl) || DECL_EXTERNAL (olddecl)))
2483 snode = symtab_node::get (olddecl);
2484 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2485 (char *) newdecl + sizeof (struct tree_decl_common),
2486 size - sizeof (struct tree_decl_common)
2487 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2488 if (TREE_CODE (newdecl) == VAR_DECL)
2489 olddecl->decl_with_vis.symtab_node = snode;
2491 break;
2492 default:
2493 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2494 (char *) newdecl + sizeof (struct tree_decl_common),
2495 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2496 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2497 break;
2501 if (TREE_CODE (newdecl) == FUNCTION_DECL
2502 || TREE_CODE (newdecl) == VAR_DECL)
2504 if (DECL_EXTERNAL (olddecl)
2505 || TREE_PUBLIC (olddecl)
2506 || TREE_STATIC (olddecl))
2508 /* Merge the section attribute.
2509 We want to issue an error if the sections conflict but that must be
2510 done later in decl_attributes since we are called before attributes
2511 are assigned. */
2512 if (DECL_SECTION_NAME (newdecl) != NULL)
2513 set_decl_section_name (olddecl, DECL_SECTION_NAME (newdecl));
2515 if (DECL_ONE_ONLY (newdecl))
2517 struct symtab_node *oldsym, *newsym;
2518 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2519 oldsym = cgraph_node::get_create (olddecl);
2520 else
2521 oldsym = varpool_node::get_create (olddecl);
2522 newsym = symtab_node::get (newdecl);
2523 oldsym->set_comdat_group (newsym->get_comdat_group ());
2527 if (TREE_CODE (newdecl) == VAR_DECL
2528 && DECL_THREAD_LOCAL_P (newdecl))
2529 set_decl_tls_model (olddecl, DECL_TLS_MODEL (newdecl));
2532 DECL_UID (olddecl) = olddecl_uid;
2533 if (olddecl_friend)
2534 DECL_FRIEND_P (olddecl) = 1;
2535 if (hidden_friend)
2537 DECL_ANTICIPATED (olddecl) = 1;
2538 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2541 /* NEWDECL contains the merged attribute lists.
2542 Update OLDDECL to be the same. */
2543 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2545 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2546 so that encode_section_info has a chance to look at the new decl
2547 flags and attributes. */
2548 if (DECL_RTL_SET_P (olddecl)
2549 && (TREE_CODE (olddecl) == FUNCTION_DECL
2550 || (VAR_P (olddecl)
2551 && TREE_STATIC (olddecl))))
2552 make_decl_rtl (olddecl);
2554 /* The NEWDECL will no longer be needed. Because every out-of-class
2555 declaration of a member results in a call to duplicate_decls,
2556 freeing these nodes represents in a significant savings.
2558 Before releasing the node, be sore to remove function from symbol
2559 table that might have been inserted there to record comdat group.
2560 Be sure to however do not free DECL_STRUCT_FUNCTION becuase this
2561 structure is shared in between newdecl and oldecl. */
2562 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2563 DECL_STRUCT_FUNCTION (newdecl) = NULL;
2564 if (TREE_CODE (newdecl) == FUNCTION_DECL
2565 || TREE_CODE (newdecl) == VAR_DECL)
2567 struct symtab_node *snode = symtab_node::get (newdecl);
2568 if (snode)
2569 snode->remove ();
2571 ggc_free (newdecl);
2573 return olddecl;
2576 /* Return zero if the declaration NEWDECL is valid
2577 when the declaration OLDDECL (assumed to be for the same name)
2578 has already been seen.
2579 Otherwise return an error message format string with a %s
2580 where the identifier should go. */
2582 static const char *
2583 redeclaration_error_message (tree newdecl, tree olddecl)
2585 if (TREE_CODE (newdecl) == TYPE_DECL)
2587 /* Because C++ can put things into name space for free,
2588 constructs like "typedef struct foo { ... } foo"
2589 would look like an erroneous redeclaration. */
2590 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2591 return NULL;
2592 else
2593 return G_("redefinition of %q#D");
2595 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2597 /* If this is a pure function, its olddecl will actually be
2598 the original initialization to `0' (which we force to call
2599 abort()). Don't complain about redefinition in this case. */
2600 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2601 && DECL_INITIAL (olddecl) == NULL_TREE)
2602 return NULL;
2604 /* If both functions come from different namespaces, this is not
2605 a redeclaration - this is a conflict with a used function. */
2606 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2607 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2608 && ! decls_match (olddecl, newdecl))
2609 return G_("%qD conflicts with used function");
2611 /* We'll complain about linkage mismatches in
2612 warn_extern_redeclared_static. */
2614 /* Defining the same name twice is no good. */
2615 if (DECL_INITIAL (olddecl) != NULL_TREE
2616 && DECL_INITIAL (newdecl) != NULL_TREE)
2618 if (DECL_NAME (olddecl) == NULL_TREE)
2619 return G_("%q#D not declared in class");
2620 else if (!GNU_INLINE_P (olddecl)
2621 || GNU_INLINE_P (newdecl))
2622 return G_("redefinition of %q#D");
2625 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2627 bool olda = GNU_INLINE_P (olddecl);
2628 bool newa = GNU_INLINE_P (newdecl);
2630 if (olda != newa)
2632 if (newa)
2633 return G_("%q+D redeclared inline with "
2634 "%<gnu_inline%> attribute");
2635 else
2636 return G_("%q+D redeclared inline without "
2637 "%<gnu_inline%> attribute");
2641 check_abi_tag_redeclaration
2642 (olddecl, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl)),
2643 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl)));
2645 return NULL;
2647 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2649 tree nt, ot;
2651 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2653 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2654 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2655 return G_("redefinition of %q#D");
2656 return NULL;
2659 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2660 || (DECL_TEMPLATE_RESULT (newdecl)
2661 == DECL_TEMPLATE_RESULT (olddecl)))
2662 return NULL;
2664 nt = DECL_TEMPLATE_RESULT (newdecl);
2665 if (DECL_TEMPLATE_INFO (nt))
2666 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2667 ot = DECL_TEMPLATE_RESULT (olddecl);
2668 if (DECL_TEMPLATE_INFO (ot))
2669 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2670 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2671 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2672 return G_("redefinition of %q#D");
2674 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2676 bool olda = GNU_INLINE_P (ot);
2677 bool newa = GNU_INLINE_P (nt);
2679 if (olda != newa)
2681 if (newa)
2682 return G_("%q+D redeclared inline with "
2683 "%<gnu_inline%> attribute");
2684 else
2685 return G_("%q+D redeclared inline without "
2686 "%<gnu_inline%> attribute");
2690 /* Core issue #226 (C++0x):
2692 If a friend function template declaration specifies a
2693 default template-argument, that declaration shall be a
2694 definition and shall be the only declaration of the
2695 function template in the translation unit. */
2696 if ((cxx_dialect != cxx98)
2697 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2698 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2699 /*is_primary=*/true,
2700 /*is_partial=*/false,
2701 /*is_friend_decl=*/2))
2702 return G_("redeclaration of friend %q#D "
2703 "may not have default template arguments");
2705 return NULL;
2707 else if (VAR_P (newdecl)
2708 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2709 && (! DECL_LANG_SPECIFIC (olddecl)
2710 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2711 || DECL_THREAD_LOCAL_P (newdecl)))
2713 /* Only variables can be thread-local, and all declarations must
2714 agree on this property. */
2715 if (DECL_THREAD_LOCAL_P (newdecl))
2716 return G_("thread-local declaration of %q#D follows "
2717 "non-thread-local declaration");
2718 else
2719 return G_("non-thread-local declaration of %q#D follows "
2720 "thread-local declaration");
2722 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2724 /* The objects have been declared at namespace scope. If either
2725 is a member of an anonymous union, then this is an invalid
2726 redeclaration. For example:
2728 int i;
2729 union { int i; };
2731 is invalid. */
2732 if ((VAR_P (newdecl) && DECL_ANON_UNION_VAR_P (newdecl))
2733 || (VAR_P (olddecl) && DECL_ANON_UNION_VAR_P (olddecl)))
2734 return G_("redeclaration of %q#D");
2735 /* If at least one declaration is a reference, there is no
2736 conflict. For example:
2738 int i = 3;
2739 extern int i;
2741 is valid. */
2742 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2743 return NULL;
2744 /* Reject two definitions. */
2745 return G_("redefinition of %q#D");
2747 else
2749 /* Objects declared with block scope: */
2750 /* Reject two definitions, and reject a definition
2751 together with an external reference. */
2752 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2753 return G_("redeclaration of %q#D");
2754 return NULL;
2758 /* Hash and equality functions for the named_label table. */
2760 hashval_t
2761 named_label_hasher::hash (named_label_entry *ent)
2763 return DECL_UID (ent->label_decl);
2766 bool
2767 named_label_hasher::equal (named_label_entry *a, named_label_entry *b)
2769 return a->label_decl == b->label_decl;
2772 /* Create a new label, named ID. */
2774 static tree
2775 make_label_decl (tree id, int local_p)
2777 struct named_label_entry *ent;
2778 tree decl;
2780 decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2782 DECL_CONTEXT (decl) = current_function_decl;
2783 DECL_MODE (decl) = VOIDmode;
2784 C_DECLARED_LABEL_FLAG (decl) = local_p;
2786 /* Say where one reference is to the label, for the sake of the
2787 error if it is not defined. */
2788 DECL_SOURCE_LOCATION (decl) = input_location;
2790 /* Record the fact that this identifier is bound to this label. */
2791 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2793 /* Create the label htab for the function on demand. */
2794 if (!named_labels)
2795 named_labels = hash_table<named_label_hasher>::create_ggc (13);
2797 /* Record this label on the list of labels used in this function.
2798 We do this before calling make_label_decl so that we get the
2799 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2800 ent = ggc_cleared_alloc<named_label_entry> ();
2801 ent->label_decl = decl;
2803 named_label_entry **slot = named_labels->find_slot (ent, INSERT);
2804 gcc_assert (*slot == NULL);
2805 *slot = ent;
2807 return decl;
2810 /* Look for a label named ID in the current function. If one cannot
2811 be found, create one. (We keep track of used, but undefined,
2812 labels, and complain about them at the end of a function.) */
2814 static tree
2815 lookup_label_1 (tree id)
2817 tree decl;
2819 /* You can't use labels at global scope. */
2820 if (current_function_decl == NULL_TREE)
2822 error ("label %qE referenced outside of any function", id);
2823 return NULL_TREE;
2826 /* See if we've already got this label. */
2827 decl = IDENTIFIER_LABEL_VALUE (id);
2828 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2829 return decl;
2831 decl = make_label_decl (id, /*local_p=*/0);
2832 return decl;
2835 /* Wrapper for lookup_label_1. */
2837 tree
2838 lookup_label (tree id)
2840 tree ret;
2841 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2842 ret = lookup_label_1 (id);
2843 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2844 return ret;
2847 /* Declare a local label named ID. */
2849 tree
2850 declare_local_label (tree id)
2852 tree decl;
2853 cp_label_binding bind;
2855 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2856 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2857 bind.prev_value = IDENTIFIER_LABEL_VALUE (id);
2859 decl = make_label_decl (id, /*local_p=*/1);
2860 bind.label = decl;
2861 vec_safe_push (current_binding_level->shadowed_labels, bind);
2863 return decl;
2866 /* Returns nonzero if it is ill-formed to jump past the declaration of
2867 DECL. Returns 2 if it's also a real problem. */
2869 static int
2870 decl_jump_unsafe (tree decl)
2872 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2873 with automatic storage duration is not in scope to a point where it is
2874 in scope is ill-formed unless the variable has scalar type, class type
2875 with a trivial default constructor and a trivial destructor, a
2876 cv-qualified version of one of these types, or an array of one of the
2877 preceding types and is declared without an initializer (8.5). */
2878 tree type = TREE_TYPE (decl);
2880 if (!VAR_P (decl) || TREE_STATIC (decl)
2881 || type == error_mark_node)
2882 return 0;
2884 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl)
2885 || variably_modified_type_p (type, NULL_TREE))
2886 return 2;
2888 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2889 return 1;
2891 return 0;
2894 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2896 static bool
2897 identify_goto (tree decl, const location_t *locus)
2899 bool complained = (decl
2900 ? permerror (input_location, "jump to label %qD", decl)
2901 : permerror (input_location, "jump to case label"));
2902 if (complained && locus)
2903 inform (*locus, " from here");
2904 return complained;
2907 /* Check that a single previously seen jump to a newly defined label
2908 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2909 the jump context; NAMES are the names in scope in LEVEL at the jump
2910 context; LOCUS is the source position of the jump or 0. Returns
2911 true if all is well. */
2913 static bool
2914 check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
2915 bool exited_omp, const location_t *locus)
2917 cp_binding_level *b;
2918 bool identified = false, complained = false;
2919 bool saw_eh = false, saw_omp = false;
2921 if (exited_omp)
2923 complained = identify_goto (decl, locus);
2924 if (complained)
2925 inform (input_location, " exits OpenMP structured block");
2926 identified = saw_omp = true;
2929 for (b = current_binding_level; b ; b = b->level_chain)
2931 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2933 for (new_decls = b->names; new_decls != old_decls;
2934 new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls)
2935 : TREE_CHAIN (new_decls)))
2937 int problem = decl_jump_unsafe (new_decls);
2938 if (! problem)
2939 continue;
2941 if (!identified)
2943 complained = identify_goto (decl, locus);
2944 identified = true;
2946 if (complained)
2948 if (problem > 1)
2949 inform (input_location,
2950 " crosses initialization of %q+#D", new_decls);
2951 else
2952 inform (input_location, " enters scope of %q+#D which has "
2953 "non-trivial destructor", new_decls);
2957 if (b == level)
2958 break;
2959 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2961 if (!identified)
2963 complained = identify_goto (decl, locus);
2964 identified = true;
2966 if (complained)
2968 if (b->kind == sk_try)
2969 inform (input_location, " enters try block");
2970 else
2971 inform (input_location, " enters catch block");
2973 saw_eh = true;
2975 if (b->kind == sk_omp && !saw_omp)
2977 if (!identified)
2979 complained = identify_goto (decl, locus);
2980 identified = true;
2982 if (complained)
2983 inform (input_location, " enters OpenMP structured block");
2984 saw_omp = true;
2988 return !identified;
2991 static void
2992 check_previous_goto (tree decl, struct named_label_use_entry *use)
2994 check_previous_goto_1 (decl, use->binding_level,
2995 use->names_in_scope, use->in_omp_scope,
2996 &use->o_goto_locus);
2999 static bool
3000 check_switch_goto (cp_binding_level* level)
3002 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
3005 /* Check that a new jump to a label DECL is OK. Called by
3006 finish_goto_stmt. */
3008 void
3009 check_goto (tree decl)
3011 struct named_label_entry *ent, dummy;
3012 bool saw_catch = false, identified = false, complained = false;
3013 tree bad;
3014 unsigned ix;
3016 /* We can't know where a computed goto is jumping.
3017 So we assume that it's OK. */
3018 if (TREE_CODE (decl) != LABEL_DECL)
3019 return;
3021 /* We didn't record any information about this label when we created it,
3022 and there's not much point since it's trivial to analyze as a return. */
3023 if (decl == cdtor_label)
3024 return;
3026 dummy.label_decl = decl;
3027 ent = named_labels->find (&dummy);
3028 gcc_assert (ent != NULL);
3030 /* If the label hasn't been defined yet, defer checking. */
3031 if (! DECL_INITIAL (decl))
3033 struct named_label_use_entry *new_use;
3035 /* Don't bother creating another use if the last goto had the
3036 same data, and will therefore create the same set of errors. */
3037 if (ent->uses
3038 && ent->uses->names_in_scope == current_binding_level->names)
3039 return;
3041 new_use = ggc_alloc<named_label_use_entry> ();
3042 new_use->binding_level = current_binding_level;
3043 new_use->names_in_scope = current_binding_level->names;
3044 new_use->o_goto_locus = input_location;
3045 new_use->in_omp_scope = false;
3047 new_use->next = ent->uses;
3048 ent->uses = new_use;
3049 return;
3052 if (ent->in_try_scope || ent->in_catch_scope
3053 || ent->in_omp_scope || !vec_safe_is_empty (ent->bad_decls))
3055 complained = permerror (input_location, "jump to label %q+D", decl);
3056 if (complained)
3057 inform (input_location, " from here");
3058 identified = true;
3061 FOR_EACH_VEC_SAFE_ELT (ent->bad_decls, ix, bad)
3063 int u = decl_jump_unsafe (bad);
3065 if (u > 1 && DECL_ARTIFICIAL (bad))
3067 /* Can't skip init of __exception_info. */
3068 if (complained)
3069 inform (DECL_SOURCE_LOCATION (bad), " enters catch block");
3070 saw_catch = true;
3072 else if (complained)
3074 if (u > 1)
3075 inform (input_location, " skips initialization of %q+#D", bad);
3076 else
3077 inform (input_location, " enters scope of %q+#D which has "
3078 "non-trivial destructor", bad);
3082 if (complained)
3084 if (ent->in_try_scope)
3085 inform (input_location, " enters try block");
3086 else if (ent->in_catch_scope && !saw_catch)
3087 inform (input_location, " enters catch block");
3090 if (ent->in_omp_scope)
3092 if (complained)
3093 inform (input_location, " enters OpenMP structured block");
3095 else if (flag_openmp)
3097 cp_binding_level *b;
3098 for (b = current_binding_level; b ; b = b->level_chain)
3100 if (b == ent->binding_level)
3101 break;
3102 if (b->kind == sk_omp)
3104 if (!identified)
3106 complained = permerror (input_location,
3107 "jump to label %q+D", decl);
3108 if (complained)
3109 inform (input_location, " from here");
3110 identified = true;
3112 if (complained)
3113 inform (input_location, " exits OpenMP structured block");
3114 break;
3120 /* Check that a return is ok wrt OpenMP structured blocks.
3121 Called by finish_return_stmt. Returns true if all is well. */
3123 bool
3124 check_omp_return (void)
3126 cp_binding_level *b;
3127 for (b = current_binding_level; b ; b = b->level_chain)
3128 if (b->kind == sk_omp)
3130 error ("invalid exit from OpenMP structured block");
3131 return false;
3133 else if (b->kind == sk_function_parms)
3134 break;
3135 return true;
3138 /* Define a label, specifying the location in the source file.
3139 Return the LABEL_DECL node for the label. */
3141 static tree
3142 define_label_1 (location_t location, tree name)
3144 struct named_label_entry *ent, dummy;
3145 cp_binding_level *p;
3146 tree decl;
3148 decl = lookup_label (name);
3150 dummy.label_decl = decl;
3151 ent = named_labels->find (&dummy);
3152 gcc_assert (ent != NULL);
3154 /* After labels, make any new cleanups in the function go into their
3155 own new (temporary) binding contour. */
3156 for (p = current_binding_level;
3157 p->kind != sk_function_parms;
3158 p = p->level_chain)
3159 p->more_cleanups_ok = 0;
3161 if (name == get_identifier ("wchar_t"))
3162 permerror (input_location, "label named wchar_t");
3164 if (DECL_INITIAL (decl) != NULL_TREE)
3166 error ("duplicate label %qD", decl);
3167 return error_mark_node;
3169 else
3171 struct named_label_use_entry *use;
3173 /* Mark label as having been defined. */
3174 DECL_INITIAL (decl) = error_mark_node;
3175 /* Say where in the source. */
3176 DECL_SOURCE_LOCATION (decl) = location;
3178 ent->binding_level = current_binding_level;
3179 ent->names_in_scope = current_binding_level->names;
3181 for (use = ent->uses; use ; use = use->next)
3182 check_previous_goto (decl, use);
3183 ent->uses = NULL;
3186 return decl;
3189 /* Wrapper for define_label_1. */
3191 tree
3192 define_label (location_t location, tree name)
3194 tree ret;
3195 bool running = timevar_cond_start (TV_NAME_LOOKUP);
3196 ret = define_label_1 (location, name);
3197 timevar_cond_stop (TV_NAME_LOOKUP, running);
3198 return ret;
3202 struct cp_switch
3204 cp_binding_level *level;
3205 struct cp_switch *next;
3206 /* The SWITCH_STMT being built. */
3207 tree switch_stmt;
3208 /* A splay-tree mapping the low element of a case range to the high
3209 element, or NULL_TREE if there is no high element. Used to
3210 determine whether or not a new case label duplicates an old case
3211 label. We need a tree, rather than simply a hash table, because
3212 of the GNU case range extension. */
3213 splay_tree cases;
3216 /* A stack of the currently active switch statements. The innermost
3217 switch statement is on the top of the stack. There is no need to
3218 mark the stack for garbage collection because it is only active
3219 during the processing of the body of a function, and we never
3220 collect at that point. */
3222 static struct cp_switch *switch_stack;
3224 /* Called right after a switch-statement condition is parsed.
3225 SWITCH_STMT is the switch statement being parsed. */
3227 void
3228 push_switch (tree switch_stmt)
3230 struct cp_switch *p = XNEW (struct cp_switch);
3231 p->level = current_binding_level;
3232 p->next = switch_stack;
3233 p->switch_stmt = switch_stmt;
3234 p->cases = splay_tree_new (case_compare, NULL, NULL);
3235 switch_stack = p;
3238 void
3239 pop_switch (void)
3241 struct cp_switch *cs = switch_stack;
3242 location_t switch_location;
3244 /* Emit warnings as needed. */
3245 switch_location = EXPR_LOC_OR_LOC (cs->switch_stmt, input_location);
3246 if (!processing_template_decl)
3247 c_do_switch_warnings (cs->cases, switch_location,
3248 SWITCH_STMT_TYPE (cs->switch_stmt),
3249 SWITCH_STMT_COND (cs->switch_stmt));
3251 splay_tree_delete (cs->cases);
3252 switch_stack = switch_stack->next;
3253 free (cs);
3256 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3257 condition. Note that if TYPE and VALUE are already integral we don't
3258 really do the conversion because the language-independent
3259 warning/optimization code will work better that way. */
3261 static tree
3262 case_conversion (tree type, tree value)
3264 if (value == NULL_TREE)
3265 return value;
3267 if (cxx_dialect >= cxx11
3268 && (SCOPED_ENUM_P (type)
3269 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
3271 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
3272 type = type_promotes_to (type);
3273 value = (perform_implicit_conversion_flags
3274 (type, value, tf_warning_or_error,
3275 LOOKUP_IMPLICIT | LOOKUP_NO_NON_INTEGRAL));
3277 return cxx_constant_value (value);
3280 /* Note that we've seen a definition of a case label, and complain if this
3281 is a bad place for one. */
3283 tree
3284 finish_case_label (location_t loc, tree low_value, tree high_value)
3286 tree cond, r;
3287 cp_binding_level *p;
3288 tree type;
3290 if (processing_template_decl)
3292 tree label;
3294 /* For templates, just add the case label; we'll do semantic
3295 analysis at instantiation-time. */
3296 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
3297 return add_stmt (build_case_label (low_value, high_value, label));
3300 /* Find the condition on which this switch statement depends. */
3301 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
3302 if (cond && TREE_CODE (cond) == TREE_LIST)
3303 cond = TREE_VALUE (cond);
3305 if (!check_switch_goto (switch_stack->level))
3306 return error_mark_node;
3308 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt);
3310 low_value = case_conversion (type, low_value);
3311 high_value = case_conversion (type, high_value);
3313 r = c_add_case_label (loc, switch_stack->cases, cond, type,
3314 low_value, high_value);
3316 /* After labels, make any new cleanups in the function go into their
3317 own new (temporary) binding contour. */
3318 for (p = current_binding_level;
3319 p->kind != sk_function_parms;
3320 p = p->level_chain)
3321 p->more_cleanups_ok = 0;
3323 return r;
3326 struct typename_info {
3327 tree scope;
3328 tree name;
3329 tree template_id;
3330 bool enum_p;
3331 bool class_p;
3334 struct typename_hasher : ggc_ptr_hash<tree_node>
3336 typedef typename_info *compare_type;
3338 /* Hash a TYPENAME_TYPE. */
3340 static hashval_t
3341 hash (tree t)
3343 hashval_t hash;
3345 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
3346 ^ htab_hash_pointer (TYPE_IDENTIFIER (t)));
3348 return hash;
3351 /* Compare two TYPENAME_TYPEs. */
3353 static bool
3354 equal (tree t1, const typename_info *t2)
3356 return (TYPE_IDENTIFIER (t1) == t2->name
3357 && TYPE_CONTEXT (t1) == t2->scope
3358 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
3359 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
3360 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
3364 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3365 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3367 Returns the new TYPENAME_TYPE. */
3369 static GTY (()) hash_table<typename_hasher> *typename_htab;
3371 static tree
3372 build_typename_type (tree context, tree name, tree fullname,
3373 enum tag_types tag_type)
3375 tree t;
3376 tree d;
3377 typename_info ti;
3378 tree *e;
3379 hashval_t hash;
3381 if (typename_htab == NULL)
3382 typename_htab = hash_table<typename_hasher>::create_ggc (61);
3384 ti.scope = FROB_CONTEXT (context);
3385 ti.name = name;
3386 ti.template_id = fullname;
3387 ti.enum_p = tag_type == enum_type;
3388 ti.class_p = (tag_type == class_type
3389 || tag_type == record_type
3390 || tag_type == union_type);
3391 hash = (htab_hash_pointer (ti.scope)
3392 ^ htab_hash_pointer (ti.name));
3394 /* See if we already have this type. */
3395 e = typename_htab->find_slot_with_hash (&ti, hash, INSERT);
3396 if (*e)
3397 t = *e;
3398 else
3400 /* Build the TYPENAME_TYPE. */
3401 t = cxx_make_type (TYPENAME_TYPE);
3402 TYPE_CONTEXT (t) = ti.scope;
3403 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
3404 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
3405 TYPENAME_IS_CLASS_P (t) = ti.class_p;
3407 /* Build the corresponding TYPE_DECL. */
3408 d = build_decl (input_location, TYPE_DECL, name, t);
3409 TYPE_NAME (TREE_TYPE (d)) = d;
3410 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3411 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3412 DECL_ARTIFICIAL (d) = 1;
3414 /* Store it in the hash table. */
3415 *e = t;
3417 /* TYPENAME_TYPEs must always be compared structurally, because
3418 they may or may not resolve down to another type depending on
3419 the currently open classes. */
3420 SET_TYPE_STRUCTURAL_EQUALITY (t);
3423 return t;
3426 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3427 provided to name the type. Returns an appropriate type, unless an
3428 error occurs, in which case error_mark_node is returned. If we
3429 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3430 return that, rather than the _TYPE it corresponds to, in other
3431 cases we look through the type decl. If TF_ERROR is set, complain
3432 about errors, otherwise be quiet. */
3434 tree
3435 make_typename_type (tree context, tree name, enum tag_types tag_type,
3436 tsubst_flags_t complain)
3438 tree fullname;
3439 tree t;
3440 bool want_template;
3442 if (name == error_mark_node
3443 || context == NULL_TREE
3444 || context == error_mark_node)
3445 return error_mark_node;
3447 if (TYPE_P (name))
3449 if (!(TYPE_LANG_SPECIFIC (name)
3450 && (CLASSTYPE_IS_TEMPLATE (name)
3451 || CLASSTYPE_USE_TEMPLATE (name))))
3452 name = TYPE_IDENTIFIER (name);
3453 else
3454 /* Create a TEMPLATE_ID_EXPR for the type. */
3455 name = build_nt (TEMPLATE_ID_EXPR,
3456 CLASSTYPE_TI_TEMPLATE (name),
3457 CLASSTYPE_TI_ARGS (name));
3459 else if (TREE_CODE (name) == TYPE_DECL)
3460 name = DECL_NAME (name);
3462 fullname = name;
3464 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3466 name = TREE_OPERAND (name, 0);
3467 if (DECL_TYPE_TEMPLATE_P (name))
3468 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3469 if (TREE_CODE (name) != IDENTIFIER_NODE)
3471 if (complain & tf_error)
3472 error ("%qD is not a type", name);
3473 return error_mark_node;
3476 if (TREE_CODE (name) == TEMPLATE_DECL)
3478 if (complain & tf_error)
3479 error ("%qD used without template parameters", name);
3480 return error_mark_node;
3482 gcc_assert (identifier_p (name));
3483 gcc_assert (TYPE_P (context));
3485 if (!MAYBE_CLASS_TYPE_P (context))
3487 if (complain & tf_error)
3488 error ("%q#T is not a class", context);
3489 return error_mark_node;
3492 /* When the CONTEXT is a dependent type, NAME could refer to a
3493 dependent base class of CONTEXT. But look inside it anyway
3494 if CONTEXT is a currently open scope, in case it refers to a
3495 member of the current instantiation or a non-dependent base;
3496 lookup will stop when we hit a dependent base. */
3497 if (!dependent_scope_p (context))
3498 /* We should only set WANT_TYPE when we're a nested typename type.
3499 Then we can give better diagnostics if we find a non-type. */
3500 t = lookup_field (context, name, 2, /*want_type=*/true);
3501 else
3502 t = NULL_TREE;
3504 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3505 return build_typename_type (context, name, fullname, tag_type);
3507 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3509 if (!t)
3511 if (complain & tf_error)
3512 error (want_template ? G_("no class template named %q#T in %q#T")
3513 : G_("no type named %q#T in %q#T"), name, context);
3514 return error_mark_node;
3517 /* Pull out the template from an injected-class-name (or multiple). */
3518 if (want_template)
3519 t = maybe_get_template_decl_from_type_decl (t);
3521 if (TREE_CODE (t) == TREE_LIST)
3523 if (complain & tf_error)
3525 error ("lookup of %qT in %qT is ambiguous", name, context);
3526 print_candidates (t);
3528 return error_mark_node;
3531 if (want_template && !DECL_TYPE_TEMPLATE_P (t))
3533 if (complain & tf_error)
3534 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3535 context, name, t);
3536 return error_mark_node;
3538 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3540 if (complain & tf_error)
3541 error ("%<typename %T::%D%> names %q#T, which is not a type",
3542 context, name, t);
3543 return error_mark_node;
3546 if (!perform_or_defer_access_check (TYPE_BINFO (context), t, t, complain))
3547 return error_mark_node;
3549 /* If we are currently parsing a template and if T is a typedef accessed
3550 through CONTEXT then we need to remember and check access of T at
3551 template instantiation time. */
3552 add_typedef_to_current_template_for_access_check (t, context, input_location);
3554 if (want_template)
3555 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3556 NULL_TREE, context,
3557 /*entering_scope=*/0,
3558 complain | tf_user);
3560 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3561 t = TREE_TYPE (t);
3563 maybe_record_typedef_use (t);
3565 return t;
3568 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3569 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3570 in which case error_mark_node is returned.
3572 If PARM_LIST is non-NULL, also make sure that the template parameter
3573 list of TEMPLATE_DECL matches.
3575 If COMPLAIN zero, don't complain about any errors that occur. */
3577 tree
3578 make_unbound_class_template (tree context, tree name, tree parm_list,
3579 tsubst_flags_t complain)
3581 tree t;
3582 tree d;
3584 if (TYPE_P (name))
3585 name = TYPE_IDENTIFIER (name);
3586 else if (DECL_P (name))
3587 name = DECL_NAME (name);
3588 gcc_assert (identifier_p (name));
3590 if (!dependent_type_p (context)
3591 || currently_open_class (context))
3593 tree tmpl = NULL_TREE;
3595 if (MAYBE_CLASS_TYPE_P (context))
3596 tmpl = lookup_field (context, name, 0, false);
3598 if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
3599 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
3601 if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl))
3603 if (complain & tf_error)
3604 error ("no class template named %q#T in %q#T", name, context);
3605 return error_mark_node;
3608 if (parm_list
3609 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3611 if (complain & tf_error)
3613 error ("template parameters do not match template %qD", tmpl);
3614 inform (DECL_SOURCE_LOCATION (tmpl),
3615 "%qD declared here", tmpl);
3617 return error_mark_node;
3620 if (!perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl,
3621 complain))
3622 return error_mark_node;
3624 return tmpl;
3627 /* Build the UNBOUND_CLASS_TEMPLATE. */
3628 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3629 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3630 TREE_TYPE (t) = NULL_TREE;
3631 SET_TYPE_STRUCTURAL_EQUALITY (t);
3633 /* Build the corresponding TEMPLATE_DECL. */
3634 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3635 TYPE_NAME (TREE_TYPE (d)) = d;
3636 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3637 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3638 DECL_ARTIFICIAL (d) = 1;
3639 DECL_TEMPLATE_PARMS (d) = parm_list;
3641 return t;
3646 /* Push the declarations of builtin types into the namespace.
3647 RID_INDEX is the index of the builtin type in the array
3648 RID_POINTERS. NAME is the name used when looking up the builtin
3649 type. TYPE is the _TYPE node for the builtin type. */
3651 void
3652 record_builtin_type (enum rid rid_index,
3653 const char* name,
3654 tree type)
3656 tree rname = NULL_TREE, tname = NULL_TREE;
3657 tree tdecl = NULL_TREE;
3659 if ((int) rid_index < (int) RID_MAX)
3660 rname = ridpointers[(int) rid_index];
3661 if (name)
3662 tname = get_identifier (name);
3664 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3665 eliminated. Built-in types should not be looked up name; their
3666 names are keywords that the parser can recognize. However, there
3667 is code in c-common.c that uses identifier_global_value to look
3668 up built-in types by name. */
3669 if (tname)
3671 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3672 DECL_ARTIFICIAL (tdecl) = 1;
3673 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3675 if (rname)
3677 if (!tdecl)
3679 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3680 DECL_ARTIFICIAL (tdecl) = 1;
3682 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3685 if (!TYPE_NAME (type))
3686 TYPE_NAME (type) = tdecl;
3688 if (tdecl)
3689 debug_hooks->type_decl (tdecl, 0);
3692 /* Record one of the standard Java types.
3693 * Declare it as having the given NAME.
3694 * If SIZE > 0, it is the size of one of the integral types;
3695 * otherwise it is the negative of the size of one of the other types. */
3697 static tree
3698 record_builtin_java_type (const char* name, int size)
3700 tree type, decl;
3701 if (size > 0)
3703 type = build_nonstandard_integer_type (size, 0);
3704 type = build_distinct_type_copy (type);
3706 else if (size > -32)
3708 tree stype;
3709 /* "__java_char" or ""__java_boolean". */
3710 type = build_nonstandard_integer_type (-size, 1);
3711 type = build_distinct_type_copy (type);
3712 /* Get the signed type cached and attached to the unsigned type,
3713 so it doesn't get garbage-collected at "random" times,
3714 causing potential codegen differences out of different UIDs
3715 and different alias set numbers. */
3716 stype = build_nonstandard_integer_type (-size, 0);
3717 stype = build_distinct_type_copy (stype);
3718 TREE_CHAIN (type) = stype;
3719 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3721 else
3722 { /* "__java_float" or ""__java_double". */
3723 type = make_node (REAL_TYPE);
3724 TYPE_PRECISION (type) = - size;
3725 layout_type (type);
3727 record_builtin_type (RID_MAX, name, type);
3728 decl = TYPE_NAME (type);
3730 /* Suppress generate debug symbol entries for these types,
3731 since for normal C++ they are just clutter.
3732 However, push_lang_context undoes this if extern "Java" is seen. */
3733 DECL_IGNORED_P (decl) = 1;
3735 TYPE_FOR_JAVA (type) = 1;
3736 return type;
3739 /* Push a type into the namespace so that the back ends ignore it. */
3741 static void
3742 record_unknown_type (tree type, const char* name)
3744 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3745 TYPE_DECL, get_identifier (name), type));
3746 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3747 DECL_IGNORED_P (decl) = 1;
3748 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3749 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3750 TYPE_ALIGN (type) = 1;
3751 TYPE_USER_ALIGN (type) = 0;
3752 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3755 /* A string for which we should create an IDENTIFIER_NODE at
3756 startup. */
3758 typedef struct predefined_identifier
3760 /* The name of the identifier. */
3761 const char *const name;
3762 /* The place where the IDENTIFIER_NODE should be stored. */
3763 tree *const node;
3764 /* Nonzero if this is the name of a constructor or destructor. */
3765 const int ctor_or_dtor_p;
3766 } predefined_identifier;
3768 /* Create all the predefined identifiers. */
3770 static void
3771 initialize_predefined_identifiers (void)
3773 const predefined_identifier *pid;
3775 /* A table of identifiers to create at startup. */
3776 static const predefined_identifier predefined_identifiers[] = {
3777 { "C++", &lang_name_cplusplus, 0 },
3778 { "C", &lang_name_c, 0 },
3779 { "Java", &lang_name_java, 0 },
3780 /* Some of these names have a trailing space so that it is
3781 impossible for them to conflict with names written by users. */
3782 { "__ct ", &ctor_identifier, 1 },
3783 { "__base_ctor ", &base_ctor_identifier, 1 },
3784 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3785 { "__dt ", &dtor_identifier, 1 },
3786 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3787 { "__base_dtor ", &base_dtor_identifier, 1 },
3788 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3789 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3790 { "nelts", &nelts_identifier, 0 },
3791 { THIS_NAME, &this_identifier, 0 },
3792 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3793 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3794 { "_vptr", &vptr_identifier, 0 },
3795 { "__vtt_parm", &vtt_parm_identifier, 0 },
3796 { "::", &global_scope_name, 0 },
3797 { "std", &std_identifier, 0 },
3798 { NULL, NULL, 0 }
3801 for (pid = predefined_identifiers; pid->name; ++pid)
3803 *pid->node = get_identifier (pid->name);
3804 if (pid->ctor_or_dtor_p)
3805 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3809 /* Create the predefined scalar types of C,
3810 and some nodes representing standard constants (0, 1, (void *)0).
3811 Initialize the global binding level.
3812 Make definitions for built-in primitive functions. */
3814 void
3815 cxx_init_decl_processing (void)
3817 tree void_ftype;
3818 tree void_ftype_ptr;
3820 /* Create all the identifiers we need. */
3821 initialize_predefined_identifiers ();
3823 /* Create the global variables. */
3824 push_to_top_level ();
3826 current_function_decl = NULL_TREE;
3827 current_binding_level = NULL;
3828 /* Enter the global namespace. */
3829 gcc_assert (global_namespace == NULL_TREE);
3830 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3831 void_type_node);
3832 DECL_CONTEXT (global_namespace) = build_translation_unit_decl (NULL_TREE);
3833 debug_hooks->register_main_translation_unit
3834 (DECL_CONTEXT (global_namespace));
3835 TREE_PUBLIC (global_namespace) = 1;
3836 begin_scope (sk_namespace, global_namespace);
3838 if (flag_visibility_ms_compat)
3839 default_visibility = VISIBILITY_HIDDEN;
3841 /* Initially, C. */
3842 current_lang_name = lang_name_c;
3844 /* Create the `std' namespace. */
3845 push_namespace (std_identifier);
3846 std_node = current_namespace;
3847 pop_namespace ();
3849 c_common_nodes_and_builtins ();
3851 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3852 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3853 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3854 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3855 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3856 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3857 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3858 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3860 integer_two_node = build_int_cst (NULL_TREE, 2);
3862 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3863 truthvalue_type_node = boolean_type_node;
3864 truthvalue_false_node = boolean_false_node;
3865 truthvalue_true_node = boolean_true_node;
3867 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3868 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE);
3869 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE);
3871 #if 0
3872 record_builtin_type (RID_MAX, NULL, string_type_node);
3873 #endif
3875 delta_type_node = ptrdiff_type_node;
3876 vtable_index_type = ptrdiff_type_node;
3878 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3879 void_ftype = build_function_type_list (void_type_node, NULL_TREE);
3880 void_ftype_ptr = build_function_type_list (void_type_node,
3881 ptr_type_node, NULL_TREE);
3882 void_ftype_ptr
3883 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3885 /* C++ extensions */
3887 unknown_type_node = make_node (LANG_TYPE);
3888 record_unknown_type (unknown_type_node, "unknown type");
3890 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3891 TREE_TYPE (unknown_type_node) = unknown_type_node;
3893 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3894 result. */
3895 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3896 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3898 init_list_type_node = make_node (LANG_TYPE);
3899 record_unknown_type (init_list_type_node, "init list");
3902 /* Make sure we get a unique function type, so we can give
3903 its pointer type a name. (This wins for gdb.) */
3904 tree vfunc_type = make_node (FUNCTION_TYPE);
3905 TREE_TYPE (vfunc_type) = integer_type_node;
3906 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3907 layout_type (vfunc_type);
3909 vtable_entry_type = build_pointer_type (vfunc_type);
3911 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3913 vtbl_type_node
3914 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3915 layout_type (vtbl_type_node);
3916 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3917 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3918 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3919 layout_type (vtbl_ptr_type_node);
3920 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3922 push_namespace (get_identifier ("__cxxabiv1"));
3923 abi_node = current_namespace;
3924 pop_namespace ();
3926 global_type_node = make_node (LANG_TYPE);
3927 record_unknown_type (global_type_node, "global type");
3929 /* Now, C++. */
3930 current_lang_name = lang_name_cplusplus;
3933 tree newattrs, extvisattr;
3934 tree newtype, deltype;
3935 tree ptr_ftype_sizetype;
3936 tree new_eh_spec;
3938 ptr_ftype_sizetype
3939 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE);
3940 if (cxx_dialect == cxx98)
3942 tree bad_alloc_id;
3943 tree bad_alloc_type_node;
3944 tree bad_alloc_decl;
3946 push_namespace (std_identifier);
3947 bad_alloc_id = get_identifier ("bad_alloc");
3948 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3949 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3950 bad_alloc_decl
3951 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3952 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3953 pop_namespace ();
3955 new_eh_spec
3956 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
3958 else
3959 new_eh_spec = noexcept_false_spec;
3961 /* Ensure attribs.c is initialized. */
3962 init_attributes ();
3963 extvisattr = build_tree_list (get_identifier ("externally_visible"),
3964 NULL_TREE);
3965 newattrs = tree_cons (get_identifier ("alloc_size"),
3966 build_tree_list (NULL_TREE, integer_one_node),
3967 extvisattr);
3968 newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs);
3969 newtype = build_exception_variant (newtype, new_eh_spec);
3970 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
3971 deltype = build_exception_variant (deltype, empty_except_spec);
3972 tree opnew = push_cp_library_fn (NEW_EXPR, newtype, 0);
3973 DECL_IS_MALLOC (opnew) = 1;
3974 DECL_IS_OPERATOR_NEW (opnew) = 1;
3975 opnew = push_cp_library_fn (VEC_NEW_EXPR, newtype, 0);
3976 DECL_IS_MALLOC (opnew) = 1;
3977 DECL_IS_OPERATOR_NEW (opnew) = 1;
3978 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
3979 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
3980 if (flag_sized_deallocation)
3982 /* Also push the sized deallocation variants:
3983 void operator delete(void*, std::size_t) throw();
3984 void operator delete[](void*, std::size_t) throw(); */
3985 tree void_ftype_ptr_size
3986 = build_function_type_list (void_type_node, ptr_type_node,
3987 size_type_node, NULL_TREE);
3988 deltype = cp_build_type_attribute_variant (void_ftype_ptr_size,
3989 extvisattr);
3990 deltype = build_exception_variant (deltype, empty_except_spec);
3991 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
3992 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
3995 nullptr_type_node = make_node (NULLPTR_TYPE);
3996 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
3997 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode));
3998 TYPE_UNSIGNED (nullptr_type_node) = 1;
3999 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode);
4000 SET_TYPE_MODE (nullptr_type_node, ptr_mode);
4001 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node);
4002 nullptr_node = build_int_cst (nullptr_type_node, 0);
4005 abort_fndecl
4006 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype,
4007 ECF_NORETURN | ECF_NOTHROW);
4009 /* Perform other language dependent initializations. */
4010 init_class_processing ();
4011 init_rtti_processing ();
4012 init_template_processing ();
4014 if (flag_exceptions)
4015 init_exception_processing ();
4017 if (! supports_one_only ())
4018 flag_weak = 0;
4020 make_fname_decl = cp_make_fname_decl;
4021 start_fname_decls ();
4023 /* Show we use EH for cleanups. */
4024 if (flag_exceptions)
4025 using_eh_for_cleanups ();
4028 /* Generate an initializer for a function naming variable from
4029 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4030 filled in with the type of the init. */
4032 tree
4033 cp_fname_init (const char* name, tree *type_p)
4035 tree domain = NULL_TREE;
4036 tree type;
4037 tree init = NULL_TREE;
4038 size_t length = 0;
4040 if (name)
4042 length = strlen (name);
4043 domain = build_index_type (size_int (length));
4044 init = build_string (length + 1, name);
4047 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
4048 type = build_cplus_array_type (type, domain);
4050 *type_p = type;
4052 if (init)
4053 TREE_TYPE (init) = type;
4054 else
4055 init = error_mark_node;
4057 return init;
4060 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4061 the decl, LOC is the location to give the decl, NAME is the
4062 initialization string and TYPE_DEP indicates whether NAME depended
4063 on the type of the function. We make use of that to detect
4064 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4065 at the point of first use, so we mustn't push the decl now. */
4067 static tree
4068 cp_make_fname_decl (location_t loc, tree id, int type_dep)
4070 const char *const name = (type_dep && processing_template_decl
4071 ? NULL : fname_as_string (type_dep));
4072 tree type;
4073 tree init = cp_fname_init (name, &type);
4074 tree decl = build_decl (loc, VAR_DECL, id, type);
4076 if (name)
4077 free (CONST_CAST (char *, name));
4079 /* As we're using pushdecl_with_scope, we must set the context. */
4080 DECL_CONTEXT (decl) = current_function_decl;
4082 TREE_STATIC (decl) = 1;
4083 TREE_READONLY (decl) = 1;
4084 DECL_ARTIFICIAL (decl) = 1;
4086 TREE_USED (decl) = 1;
4088 if (current_function_decl)
4090 cp_binding_level *b = current_binding_level;
4091 if (b->kind == sk_function_parms)
4092 return error_mark_node;
4093 while (b->level_chain->kind != sk_function_parms)
4094 b = b->level_chain;
4095 pushdecl_with_scope (decl, b, /*is_friend=*/false);
4096 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
4097 LOOKUP_ONLYCONVERTING);
4099 else
4101 DECL_THIS_STATIC (decl) = true;
4102 pushdecl_top_level_and_finish (decl, init);
4105 return decl;
4108 static tree
4109 builtin_function_1 (tree decl, tree context, bool is_global)
4111 tree id = DECL_NAME (decl);
4112 const char *name = IDENTIFIER_POINTER (id);
4114 retrofit_lang_decl (decl);
4116 DECL_ARTIFICIAL (decl) = 1;
4117 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
4118 SET_DECL_LANGUAGE (decl, lang_c);
4119 /* Runtime library routines are, by definition, available in an
4120 external shared object. */
4121 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4122 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4124 DECL_CONTEXT (decl) = context;
4126 if (is_global)
4127 pushdecl_top_level (decl);
4128 else
4129 pushdecl (decl);
4131 /* A function in the user's namespace should have an explicit
4132 declaration before it is used. Mark the built-in function as
4133 anticipated but not actually declared. */
4134 if (name[0] != '_' || name[1] != '_')
4135 DECL_ANTICIPATED (decl) = 1;
4136 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
4138 size_t len = strlen (name);
4140 /* Treat __*_chk fortification functions as anticipated as well,
4141 unless they are __builtin_*. */
4142 if (len > strlen ("___chk")
4143 && memcmp (name + len - strlen ("_chk"),
4144 "_chk", strlen ("_chk") + 1) == 0)
4145 DECL_ANTICIPATED (decl) = 1;
4148 return decl;
4151 tree
4152 cxx_builtin_function (tree decl)
4154 tree id = DECL_NAME (decl);
4155 const char *name = IDENTIFIER_POINTER (id);
4156 /* All builtins that don't begin with an '_' should additionally
4157 go in the 'std' namespace. */
4158 if (name[0] != '_')
4160 tree decl2 = copy_node(decl);
4161 push_namespace (std_identifier);
4162 builtin_function_1 (decl2, std_node, false);
4163 pop_namespace ();
4166 return builtin_function_1 (decl, NULL_TREE, false);
4169 /* Like cxx_builtin_function, but guarantee the function is added to the global
4170 scope. This is to allow function specific options to add new machine
4171 dependent builtins when the target ISA changes via attribute((target(...)))
4172 which saves space on program startup if the program does not use non-generic
4173 ISAs. */
4175 tree
4176 cxx_builtin_function_ext_scope (tree decl)
4179 tree id = DECL_NAME (decl);
4180 const char *name = IDENTIFIER_POINTER (id);
4181 /* All builtins that don't begin with an '_' should additionally
4182 go in the 'std' namespace. */
4183 if (name[0] != '_')
4185 tree decl2 = copy_node(decl);
4186 push_namespace (std_identifier);
4187 builtin_function_1 (decl2, std_node, true);
4188 pop_namespace ();
4191 return builtin_function_1 (decl, NULL_TREE, true);
4194 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4195 function. Not called directly. */
4197 static tree
4198 build_library_fn (tree name, enum tree_code operator_code, tree type,
4199 int ecf_flags)
4201 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
4202 DECL_EXTERNAL (fn) = 1;
4203 TREE_PUBLIC (fn) = 1;
4204 DECL_ARTIFICIAL (fn) = 1;
4205 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
4206 SET_DECL_LANGUAGE (fn, lang_c);
4207 /* Runtime library routines are, by definition, available in an
4208 external shared object. */
4209 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
4210 DECL_VISIBILITY_SPECIFIED (fn) = 1;
4211 set_call_expr_flags (fn, ecf_flags);
4212 return fn;
4215 /* Returns the _DECL for a library function with C++ linkage. */
4217 static tree
4218 build_cp_library_fn (tree name, enum tree_code operator_code, tree type,
4219 int ecf_flags)
4221 tree fn = build_library_fn (name, operator_code, type, ecf_flags);
4222 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
4223 SET_DECL_LANGUAGE (fn, lang_cplusplus);
4224 return fn;
4227 /* Like build_library_fn, but takes a C string instead of an
4228 IDENTIFIER_NODE. */
4230 tree
4231 build_library_fn_ptr (const char* name, tree type, int ecf_flags)
4233 return build_library_fn (get_identifier (name), ERROR_MARK, type, ecf_flags);
4236 /* Like build_cp_library_fn, but takes a C string instead of an
4237 IDENTIFIER_NODE. */
4239 tree
4240 build_cp_library_fn_ptr (const char* name, tree type, int ecf_flags)
4242 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type,
4243 ecf_flags);
4246 /* Like build_library_fn, but also pushes the function so that we will
4247 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4248 may throw exceptions listed in RAISES. */
4250 tree
4251 push_library_fn (tree name, tree type, tree raises, int ecf_flags)
4253 tree fn;
4255 if (raises)
4256 type = build_exception_variant (type, raises);
4258 fn = build_library_fn (name, ERROR_MARK, type, ecf_flags);
4259 pushdecl_top_level (fn);
4260 return fn;
4263 /* Like build_cp_library_fn, but also pushes the function so that it
4264 will be found by normal lookup. */
4266 static tree
4267 push_cp_library_fn (enum tree_code operator_code, tree type,
4268 int ecf_flags)
4270 tree fn = build_cp_library_fn (ansi_opname (operator_code),
4271 operator_code,
4272 type, ecf_flags);
4273 pushdecl (fn);
4274 if (flag_tm)
4275 apply_tm_attr (fn, get_identifier ("transaction_safe"));
4276 return fn;
4279 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4280 a FUNCTION_TYPE. */
4282 tree
4283 push_void_library_fn (tree name, tree parmtypes, int ecf_flags)
4285 tree type = build_function_type (void_type_node, parmtypes);
4286 return push_library_fn (name, type, NULL_TREE, ecf_flags);
4289 /* Like push_library_fn, but also note that this function throws
4290 and does not return. Used for __throw_foo and the like. */
4292 tree
4293 push_throw_library_fn (tree name, tree type)
4295 tree fn = push_library_fn (name, type, NULL_TREE, ECF_NORETURN);
4296 return fn;
4299 /* When we call finish_struct for an anonymous union, we create
4300 default copy constructors and such. But, an anonymous union
4301 shouldn't have such things; this function undoes the damage to the
4302 anonymous union type T.
4304 (The reason that we create the synthesized methods is that we don't
4305 distinguish `union { int i; }' from `typedef union { int i; } U'.
4306 The first is an anonymous union; the second is just an ordinary
4307 union type.) */
4309 void
4310 fixup_anonymous_aggr (tree t)
4312 tree *q;
4314 /* Wipe out memory of synthesized methods. */
4315 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
4316 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
4317 TYPE_HAS_COPY_CTOR (t) = 0;
4318 TYPE_HAS_CONST_COPY_CTOR (t) = 0;
4319 TYPE_HAS_COPY_ASSIGN (t) = 0;
4320 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0;
4322 /* Splice the implicitly generated functions out of the TYPE_METHODS
4323 list. */
4324 q = &TYPE_METHODS (t);
4325 while (*q)
4327 if (DECL_ARTIFICIAL (*q))
4328 *q = TREE_CHAIN (*q);
4329 else
4330 q = &DECL_CHAIN (*q);
4333 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4334 if (TYPE_METHODS (t))
4336 tree decl = TYPE_MAIN_DECL (t);
4338 if (TREE_CODE (t) != UNION_TYPE)
4339 error_at (DECL_SOURCE_LOCATION (decl),
4340 "an anonymous struct cannot have function members");
4341 else
4342 error_at (DECL_SOURCE_LOCATION (decl),
4343 "an anonymous union cannot have function members");
4346 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4347 assignment operators (because they cannot have these methods themselves).
4348 For anonymous unions this is already checked because they are not allowed
4349 in any union, otherwise we have to check it. */
4350 if (TREE_CODE (t) != UNION_TYPE)
4352 tree field, type;
4354 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4355 if (TREE_CODE (field) == FIELD_DECL)
4357 type = TREE_TYPE (field);
4358 if (CLASS_TYPE_P (type))
4360 if (TYPE_NEEDS_CONSTRUCTING (type))
4361 error ("member %q+#D with constructor not allowed "
4362 "in anonymous aggregate", field);
4363 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4364 error ("member %q+#D with destructor not allowed "
4365 "in anonymous aggregate", field);
4366 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
4367 error ("member %q+#D with copy assignment operator "
4368 "not allowed in anonymous aggregate", field);
4374 /* Warn for an attribute located at LOCATION that appertains to the
4375 class type CLASS_TYPE that has not been properly placed after its
4376 class-key, in it class-specifier. */
4378 void
4379 warn_misplaced_attr_for_class_type (source_location location,
4380 tree class_type)
4382 gcc_assert (OVERLOAD_TYPE_P (class_type));
4384 if (warning_at (location, OPT_Wattributes,
4385 "attribute ignored in declaration "
4386 "of %q#T", class_type))
4387 inform (location,
4388 "attribute for %q#T must follow the %qs keyword",
4389 class_type, class_key_or_enum_as_string (class_type));
4392 /* Make sure that a declaration with no declarator is well-formed, i.e.
4393 just declares a tagged type or anonymous union.
4395 Returns the type declared; or NULL_TREE if none. */
4397 tree
4398 check_tag_decl (cp_decl_specifier_seq *declspecs,
4399 bool explicit_type_instantiation_p)
4401 int saw_friend = decl_spec_seq_has_spec_p (declspecs, ds_friend);
4402 int saw_typedef = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
4403 /* If a class, struct, or enum type is declared by the DECLSPECS
4404 (i.e, if a class-specifier, enum-specifier, or non-typename
4405 elaborated-type-specifier appears in the DECLSPECS),
4406 DECLARED_TYPE is set to the corresponding type. */
4407 tree declared_type = NULL_TREE;
4408 bool error_p = false;
4410 if (declspecs->multiple_types_p)
4411 error ("multiple types in one declaration");
4412 else if (declspecs->redefined_builtin_type)
4414 if (!in_system_header_at (input_location))
4415 permerror (declspecs->locations[ds_redefined_builtin_type_spec],
4416 "redeclaration of C++ built-in type %qT",
4417 declspecs->redefined_builtin_type);
4418 return NULL_TREE;
4421 if (declspecs->type
4422 && TYPE_P (declspecs->type)
4423 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
4424 && MAYBE_CLASS_TYPE_P (declspecs->type))
4425 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
4426 declared_type = declspecs->type;
4427 else if (declspecs->type == error_mark_node)
4428 error_p = true;
4429 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
4430 permerror (input_location, "declaration does not declare anything");
4431 else if (declared_type != NULL_TREE && type_uses_auto (declared_type))
4433 error ("%<auto%> can only be specified for variables "
4434 "or function declarations");
4435 return error_mark_node;
4437 /* Check for an anonymous union. */
4438 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
4439 && TYPE_ANONYMOUS_P (declared_type))
4441 /* 7/3 In a simple-declaration, the optional init-declarator-list
4442 can be omitted only when declaring a class (clause 9) or
4443 enumeration (7.2), that is, when the decl-specifier-seq contains
4444 either a class-specifier, an elaborated-type-specifier with
4445 a class-key (9.1), or an enum-specifier. In these cases and
4446 whenever a class-specifier or enum-specifier is present in the
4447 decl-specifier-seq, the identifiers in these specifiers are among
4448 the names being declared by the declaration (as class-name,
4449 enum-names, or enumerators, depending on the syntax). In such
4450 cases, and except for the declaration of an unnamed bit-field (9.6),
4451 the decl-specifier-seq shall introduce one or more names into the
4452 program, or shall redeclare a name introduced by a previous
4453 declaration. [Example:
4454 enum { }; // ill-formed
4455 typedef class { }; // ill-formed
4456 --end example] */
4457 if (saw_typedef)
4459 error ("missing type-name in typedef-declaration");
4460 return NULL_TREE;
4462 /* Anonymous unions are objects, so they can have specifiers. */;
4463 SET_ANON_AGGR_TYPE_P (declared_type);
4465 if (TREE_CODE (declared_type) != UNION_TYPE
4466 && !in_system_header_at (input_location))
4467 pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
4470 else
4472 if (decl_spec_seq_has_spec_p (declspecs, ds_inline))
4473 error_at (declspecs->locations[ds_inline],
4474 "%<inline%> can only be specified for functions");
4475 else if (decl_spec_seq_has_spec_p (declspecs, ds_virtual))
4476 error_at (declspecs->locations[ds_virtual],
4477 "%<virtual%> can only be specified for functions");
4478 else if (saw_friend
4479 && (!current_class_type
4480 || current_scope () != current_class_type))
4481 error_at (declspecs->locations[ds_friend],
4482 "%<friend%> can only be specified inside a class");
4483 else if (decl_spec_seq_has_spec_p (declspecs, ds_explicit))
4484 error_at (declspecs->locations[ds_explicit],
4485 "%<explicit%> can only be specified for constructors");
4486 else if (declspecs->storage_class)
4487 error_at (declspecs->locations[ds_storage_class],
4488 "a storage class can only be specified for objects "
4489 "and functions");
4490 else if (decl_spec_seq_has_spec_p (declspecs, ds_const))
4491 error_at (declspecs->locations[ds_const],
4492 "%<const%> can only be specified for objects and "
4493 "functions");
4494 else if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
4495 error_at (declspecs->locations[ds_volatile],
4496 "%<volatile%> can only be specified for objects and "
4497 "functions");
4498 else if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
4499 error_at (declspecs->locations[ds_restrict],
4500 "%<__restrict%> can only be specified for objects and "
4501 "functions");
4502 else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
4503 error_at (declspecs->locations[ds_thread],
4504 "%<__thread%> can only be specified for objects "
4505 "and functions");
4506 else if (saw_typedef)
4507 warning_at (declspecs->locations[ds_typedef], 0,
4508 "%<typedef%> was ignored in this declaration");
4509 else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr))
4510 error_at (declspecs->locations[ds_constexpr],
4511 "%<constexpr%> cannot be used for type declarations");
4514 if (declspecs->attributes && warn_attributes && declared_type)
4516 location_t loc;
4517 if (!CLASS_TYPE_P (declared_type)
4518 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type))
4519 /* For a non-template class, use the name location. */
4520 loc = location_of (declared_type);
4521 else
4522 /* For a template class (an explicit instantiation), use the
4523 current location. */
4524 loc = input_location;
4526 if (explicit_type_instantiation_p)
4527 /* [dcl.attr.grammar]/4:
4529 No attribute-specifier-seq shall appertain to an explicit
4530 instantiation. */
4532 if (warning_at (loc, OPT_Wattributes,
4533 "attribute ignored in explicit instantiation %q#T",
4534 declared_type))
4535 inform (loc,
4536 "no attribute can be applied to "
4537 "an explicit instantiation");
4539 else
4540 warn_misplaced_attr_for_class_type (loc, declared_type);
4543 return declared_type;
4546 /* Called when a declaration is seen that contains no names to declare.
4547 If its type is a reference to a structure, union or enum inherited
4548 from a containing scope, shadow that tag name for the current scope
4549 with a forward reference.
4550 If its type defines a new named structure or union
4551 or defines an enum, it is valid but we need not do anything here.
4552 Otherwise, it is an error.
4554 C++: may have to grok the declspecs to learn about static,
4555 complain for anonymous unions.
4557 Returns the TYPE declared -- or NULL_TREE if none. */
4559 tree
4560 shadow_tag (cp_decl_specifier_seq *declspecs)
4562 tree t = check_tag_decl (declspecs,
4563 /*explicit_type_instantiation_p=*/false);
4565 if (!t)
4566 return NULL_TREE;
4568 if (maybe_process_partial_specialization (t) == error_mark_node)
4569 return NULL_TREE;
4571 /* This is where the variables in an anonymous union are
4572 declared. An anonymous union declaration looks like:
4573 union { ... } ;
4574 because there is no declarator after the union, the parser
4575 sends that declaration here. */
4576 if (ANON_AGGR_TYPE_P (t))
4578 fixup_anonymous_aggr (t);
4580 if (TYPE_FIELDS (t))
4582 tree decl = grokdeclarator (/*declarator=*/NULL,
4583 declspecs, NORMAL, 0, NULL);
4584 finish_anon_union (decl);
4588 return t;
4591 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4593 tree
4594 groktypename (cp_decl_specifier_seq *type_specifiers,
4595 const cp_declarator *declarator,
4596 bool is_template_arg)
4598 tree attrs;
4599 tree type;
4600 enum decl_context context
4601 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
4602 attrs = type_specifiers->attributes;
4603 type_specifiers->attributes = NULL_TREE;
4604 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
4605 if (attrs && type != error_mark_node)
4607 if (CLASS_TYPE_P (type))
4608 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
4609 "outside of definition", type);
4610 else if (MAYBE_CLASS_TYPE_P (type))
4611 /* A template type parameter or other dependent type. */
4612 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
4613 "type %qT without an associated declaration", type);
4614 else
4615 cplus_decl_attributes (&type, attrs, 0);
4617 return type;
4620 /* Process a DECLARATOR for a function-scope variable declaration,
4621 namespace-scope variable declaration, or function declaration.
4622 (Function definitions go through start_function; class member
4623 declarations appearing in the body of the class go through
4624 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4625 If an error occurs, the error_mark_node is returned instead.
4627 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4628 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4629 for an explicitly defaulted function, or SD_DELETED for an explicitly
4630 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4631 implicitly initialized via a default constructor. ATTRIBUTES and
4632 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4634 The scope represented by the context of the returned DECL is pushed
4635 (if it is not the global namespace) and is assigned to
4636 *PUSHED_SCOPE_P. The caller is then responsible for calling
4637 pop_scope on *PUSHED_SCOPE_P if it is set. */
4639 tree
4640 start_decl (const cp_declarator *declarator,
4641 cp_decl_specifier_seq *declspecs,
4642 int initialized,
4643 tree attributes,
4644 tree prefix_attributes,
4645 tree *pushed_scope_p)
4647 tree decl;
4648 tree context;
4649 bool was_public;
4650 int flags;
4651 bool alias;
4653 *pushed_scope_p = NULL_TREE;
4655 /* An object declared as __attribute__((deprecated)) suppresses
4656 warnings of uses of other deprecated items. */
4657 if (lookup_attribute ("deprecated", attributes))
4658 deprecated_state = DEPRECATED_SUPPRESS;
4660 attributes = chainon (attributes, prefix_attributes);
4662 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4663 &attributes);
4665 deprecated_state = DEPRECATED_NORMAL;
4667 if (decl == NULL_TREE || VOID_TYPE_P (decl)
4668 || decl == error_mark_node)
4669 return error_mark_node;
4671 context = CP_DECL_CONTEXT (decl);
4672 if (context != global_namespace)
4673 *pushed_scope_p = push_scope (context);
4675 /* Is it valid for this decl to have an initializer at all?
4676 If not, set INITIALIZED to zero, which will indirectly
4677 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4678 if (initialized
4679 && TREE_CODE (decl) == TYPE_DECL)
4681 error ("typedef %qD is initialized (use decltype instead)", decl);
4682 return error_mark_node;
4685 if (initialized)
4687 if (! toplevel_bindings_p ()
4688 && DECL_EXTERNAL (decl))
4689 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4690 decl);
4691 DECL_EXTERNAL (decl) = 0;
4692 if (toplevel_bindings_p ())
4693 TREE_STATIC (decl) = 1;
4695 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0;
4697 if (alias && TREE_CODE (decl) == FUNCTION_DECL)
4698 record_key_method_defined (decl);
4700 /* If this is a typedef that names the class for linkage purposes
4701 (7.1.3p8), apply any attributes directly to the type. */
4702 if (TREE_CODE (decl) == TYPE_DECL
4703 && OVERLOAD_TYPE_P (TREE_TYPE (decl))
4704 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4705 flags = ATTR_FLAG_TYPE_IN_PLACE;
4706 else
4707 flags = 0;
4709 /* Set attributes here so if duplicate decl, will have proper attributes. */
4710 cplus_decl_attributes (&decl, attributes, flags);
4712 /* Dllimported symbols cannot be defined. Static data members (which
4713 can be initialized in-class and dllimported) go through grokfield,
4714 not here, so we don't need to exclude those decls when checking for
4715 a definition. */
4716 if (initialized && DECL_DLLIMPORT_P (decl))
4718 error ("definition of %q#D is marked %<dllimport%>", decl);
4719 DECL_DLLIMPORT_P (decl) = 0;
4722 /* If #pragma weak was used, mark the decl weak now. */
4723 if (!processing_template_decl)
4724 maybe_apply_pragma_weak (decl);
4726 if (TREE_CODE (decl) == FUNCTION_DECL
4727 && DECL_DECLARED_INLINE_P (decl)
4728 && DECL_UNINLINABLE (decl)
4729 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4730 warning (0, "inline function %q+D given attribute noinline", decl);
4732 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context)))
4734 bool this_tmpl = (processing_template_decl
4735 > template_class_depth (context));
4736 if (VAR_P (decl))
4738 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4739 if (field == NULL_TREE
4740 || !(VAR_P (field) || variable_template_p (field)))
4741 error ("%q+#D is not a static data member of %q#T", decl, context);
4742 else if (variable_template_p (field) && !this_tmpl)
4744 if (DECL_LANG_SPECIFIC (decl)
4745 && DECL_TEMPLATE_SPECIALIZATION (decl))
4746 /* OK, specialization was already checked. */;
4747 else
4749 error_at (DECL_SOURCE_LOCATION (decl),
4750 "non-member-template declaration of %qD", decl);
4751 inform (DECL_SOURCE_LOCATION (field), "does not match "
4752 "member template declaration here");
4753 return error_mark_node;
4756 else
4758 if (variable_template_p (field))
4759 field = DECL_TEMPLATE_RESULT (field);
4761 if (DECL_CONTEXT (field) != context)
4763 if (!same_type_p (DECL_CONTEXT (field), context))
4764 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4765 "to be defined as %<%T::%D%>",
4766 DECL_CONTEXT (field), DECL_NAME (decl),
4767 context, DECL_NAME (decl));
4768 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4770 /* Static data member are tricky; an in-class initialization
4771 still doesn't provide a definition, so the in-class
4772 declaration will have DECL_EXTERNAL set, but will have an
4773 initialization. Thus, duplicate_decls won't warn
4774 about this situation, and so we check here. */
4775 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4776 error ("duplicate initialization of %qD", decl);
4777 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4778 decl = field;
4779 if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr)
4780 && !DECL_DECLARED_CONSTEXPR_P (field))
4781 error ("%qD declared %<constexpr%> outside its class", field);
4784 else
4786 tree field = check_classfn (context, decl,
4787 this_tmpl
4788 ? current_template_parms
4789 : NULL_TREE);
4790 if (field && field != error_mark_node
4791 && duplicate_decls (decl, field,
4792 /*newdecl_is_friend=*/false))
4793 decl = field;
4796 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4797 DECL_IN_AGGR_P (decl) = 0;
4798 /* Do not mark DECL as an explicit specialization if it was not
4799 already marked as an instantiation; a declaration should
4800 never be marked as a specialization unless we know what
4801 template is being specialized. */
4802 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4804 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4805 if (TREE_CODE (decl) == FUNCTION_DECL)
4806 DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
4807 && DECL_DECLARED_INLINE_P (decl));
4808 else
4809 DECL_COMDAT (decl) = false;
4811 /* [temp.expl.spec] An explicit specialization of a static data
4812 member of a template is a definition if the declaration
4813 includes an initializer; otherwise, it is a declaration.
4815 We check for processing_specialization so this only applies
4816 to the new specialization syntax. */
4817 if (!initialized && processing_specialization)
4818 DECL_EXTERNAL (decl) = 1;
4821 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
4822 /* Aliases are definitions. */
4823 && !alias)
4824 permerror (input_location, "declaration of %q#D outside of class is not definition",
4825 decl);
4828 was_public = TREE_PUBLIC (decl);
4830 /* Enter this declaration into the symbol table. Don't push the plain
4831 VAR_DECL for a variable template. */
4832 if (!template_parm_scope_p ()
4833 || TREE_CODE (decl) != VAR_DECL)
4834 decl = maybe_push_decl (decl);
4836 if (processing_template_decl)
4837 decl = push_template_decl (decl);
4838 if (decl == error_mark_node)
4839 return error_mark_node;
4841 if (VAR_P (decl)
4842 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4843 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4845 /* This is a const variable with implicit 'static'. Set
4846 DECL_THIS_STATIC so we can tell it from variables that are
4847 !TREE_PUBLIC because of the anonymous namespace. */
4848 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)) || errorcount);
4849 DECL_THIS_STATIC (decl) = 1;
4852 if (current_function_decl && VAR_P (decl)
4853 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
4855 bool ok = false;
4856 if (DECL_THREAD_LOCAL_P (decl))
4857 error ("%qD declared %<thread_local%> in %<constexpr%> function",
4858 decl);
4859 else if (TREE_STATIC (decl))
4860 error ("%qD declared %<static%> in %<constexpr%> function", decl);
4861 else
4862 ok = true;
4863 if (!ok)
4864 cp_function_chain->invalid_constexpr = true;
4867 if (!processing_template_decl && VAR_P (decl))
4868 start_decl_1 (decl, initialized);
4870 return decl;
4873 /* Process the declaration of a variable DECL. INITIALIZED is true
4874 iff DECL is explicitly initialized. (INITIALIZED is false if the
4875 variable is initialized via an implicitly-called constructor.)
4876 This function must be called for ordinary variables (including, for
4877 example, implicit instantiations of templates), but must not be
4878 called for template declarations. */
4880 void
4881 start_decl_1 (tree decl, bool initialized)
4883 tree type;
4884 bool complete_p;
4885 bool aggregate_definition_p;
4887 gcc_assert (!processing_template_decl);
4889 if (error_operand_p (decl))
4890 return;
4892 gcc_assert (VAR_P (decl));
4894 type = TREE_TYPE (decl);
4895 complete_p = COMPLETE_TYPE_P (type);
4896 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4898 /* If an explicit initializer is present, or if this is a definition
4899 of an aggregate, then we need a complete type at this point.
4900 (Scalars are always complete types, so there is nothing to
4901 check.) This code just sets COMPLETE_P; errors (if necessary)
4902 are issued below. */
4903 if ((initialized || aggregate_definition_p)
4904 && !complete_p
4905 && COMPLETE_TYPE_P (complete_type (type)))
4907 complete_p = true;
4908 /* We will not yet have set TREE_READONLY on DECL if the type
4909 was "const", but incomplete, before this point. But, now, we
4910 have a complete type, so we can try again. */
4911 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4914 if (initialized)
4915 /* Is it valid for this decl to have an initializer at all? */
4917 /* Don't allow initializations for incomplete types except for
4918 arrays which might be completed by the initialization. */
4919 if (complete_p)
4920 ; /* A complete type is ok. */
4921 else if (type_uses_auto (type))
4922 ; /* An auto type is ok. */
4923 else if (TREE_CODE (type) != ARRAY_TYPE)
4925 error ("variable %q#D has initializer but incomplete type", decl);
4926 type = TREE_TYPE (decl) = error_mark_node;
4928 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4930 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4931 error ("elements of array %q#D have incomplete type", decl);
4932 /* else we already gave an error in start_decl. */
4935 else if (aggregate_definition_p && !complete_p)
4937 if (type_uses_auto (type))
4938 error ("declaration of %q#D has no initializer", decl);
4939 else
4940 error ("aggregate %q#D has incomplete type and cannot be defined",
4941 decl);
4942 /* Change the type so that assemble_variable will give
4943 DECL an rtl we can live with: (mem (const_int 0)). */
4944 type = TREE_TYPE (decl) = error_mark_node;
4947 /* Create a new scope to hold this declaration if necessary.
4948 Whether or not a new scope is necessary cannot be determined
4949 until after the type has been completed; if the type is a
4950 specialization of a class template it is not until after
4951 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4952 will be set correctly. */
4953 maybe_push_cleanup_level (type);
4956 /* Handle initialization of references. DECL, TYPE, and INIT have the
4957 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4958 but will be set to a new CLEANUP_STMT if a temporary is created
4959 that must be destroyed subsequently.
4961 Returns an initializer expression to use to initialize DECL, or
4962 NULL if the initialization can be performed statically.
4964 Quotes on semantics can be found in ARM 8.4.3. */
4966 static tree
4967 grok_reference_init (tree decl, tree type, tree init, int flags)
4969 if (init == NULL_TREE)
4971 if ((DECL_LANG_SPECIFIC (decl) == 0
4972 || DECL_IN_AGGR_P (decl) == 0)
4973 && ! DECL_THIS_EXTERN (decl))
4974 error ("%qD declared as reference but not initialized", decl);
4975 return NULL_TREE;
4978 if (TREE_CODE (init) == TREE_LIST)
4979 init = build_x_compound_expr_from_list (init, ELK_INIT,
4980 tf_warning_or_error);
4982 tree ttype = TREE_TYPE (type);
4983 if (TREE_CODE (ttype) != ARRAY_TYPE
4984 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4985 /* Note: default conversion is only called in very special cases. */
4986 init = decay_conversion (init, tf_warning_or_error);
4988 /* check_initializer handles this for non-reference variables, but for
4989 references we need to do it here or the initializer will get the
4990 incomplete array type and confuse later calls to
4991 cp_complete_array_type. */
4992 if (TREE_CODE (ttype) == ARRAY_TYPE
4993 && TYPE_DOMAIN (ttype) == NULL_TREE
4994 && (BRACE_ENCLOSED_INITIALIZER_P (init)
4995 || TREE_CODE (init) == STRING_CST))
4997 cp_complete_array_type (&ttype, init, false);
4998 if (ttype != TREE_TYPE (type))
4999 type = cp_build_reference_type (ttype, TYPE_REF_IS_RVALUE (type));
5002 /* Convert INIT to the reference type TYPE. This may involve the
5003 creation of a temporary, whose lifetime must be the same as that
5004 of the reference. If so, a DECL_EXPR for the temporary will be
5005 added just after the DECL_EXPR for DECL. That's why we don't set
5006 DECL_INITIAL for local references (instead assigning to them
5007 explicitly); we need to allow the temporary to be initialized
5008 first. */
5009 return initialize_reference (type, init, flags,
5010 tf_warning_or_error);
5013 /* Designated initializers in arrays are not supported in GNU C++.
5014 The parser cannot detect this error since it does not know whether
5015 a given brace-enclosed initializer is for a class type or for an
5016 array. This function checks that CE does not use a designated
5017 initializer. If it does, an error is issued. Returns true if CE
5018 is valid, i.e., does not have a designated initializer. */
5020 static bool
5021 check_array_designated_initializer (constructor_elt *ce,
5022 unsigned HOST_WIDE_INT index)
5024 /* Designated initializers for array elements are not supported. */
5025 if (ce->index)
5027 /* The parser only allows identifiers as designated
5028 initializers. */
5029 if (ce->index == error_mark_node)
5031 error ("name used in a GNU-style designated "
5032 "initializer for an array");
5033 return false;
5035 else if (identifier_p (ce->index))
5037 error ("name %qD used in a GNU-style designated "
5038 "initializer for an array", ce->index);
5039 return false;
5042 tree ce_index = build_expr_type_conversion (WANT_INT | WANT_ENUM,
5043 ce->index, true);
5044 if (ce_index
5045 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index))
5046 && (TREE_CODE (ce_index = maybe_constant_value (ce_index))
5047 == INTEGER_CST))
5049 /* A C99 designator is OK if it matches the current index. */
5050 if (wi::eq_p (ce_index, index))
5051 return true;
5052 else
5053 sorry ("non-trivial designated initializers not supported");
5055 else
5056 error ("C99 designator %qE is not an integral constant-expression",
5057 ce->index);
5059 return false;
5062 return true;
5065 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5066 array until we finish parsing the initializer. If that's the
5067 situation we're in, update DECL accordingly. */
5069 static void
5070 maybe_deduce_size_from_array_init (tree decl, tree init)
5072 tree type = TREE_TYPE (decl);
5074 if (TREE_CODE (type) == ARRAY_TYPE
5075 && TYPE_DOMAIN (type) == NULL_TREE
5076 && TREE_CODE (decl) != TYPE_DECL)
5078 /* do_default is really a C-ism to deal with tentative definitions.
5079 But let's leave it here to ease the eventual merge. */
5080 int do_default = !DECL_EXTERNAL (decl);
5081 tree initializer = init ? init : DECL_INITIAL (decl);
5082 int failure = 0;
5084 /* Check that there are no designated initializers in INIT, as
5085 those are not supported in GNU C++, and as the middle-end
5086 will crash if presented with a non-numeric designated
5087 initializer. */
5088 if (initializer && BRACE_ENCLOSED_INITIALIZER_P (initializer))
5090 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initializer);
5091 constructor_elt *ce;
5092 HOST_WIDE_INT i;
5093 FOR_EACH_VEC_SAFE_ELT (v, i, ce)
5094 if (!check_array_designated_initializer (ce, i))
5095 failure = 1;
5098 if (!failure)
5100 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
5101 do_default);
5102 if (failure == 1)
5104 error ("initializer fails to determine size of %qD", decl);
5106 else if (failure == 2)
5108 if (do_default)
5110 error ("array size missing in %qD", decl);
5112 /* If a `static' var's size isn't known, make it extern as
5113 well as static, so it does not get allocated. If it's not
5114 `static', then don't mark it extern; finish_incomplete_decl
5115 will give it a default size and it will get allocated. */
5116 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
5117 DECL_EXTERNAL (decl) = 1;
5119 else if (failure == 3)
5121 error ("zero-size array %qD", decl);
5125 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
5127 relayout_decl (decl);
5131 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5132 any appropriate error messages regarding the layout. */
5134 static void
5135 layout_var_decl (tree decl)
5137 tree type;
5139 type = TREE_TYPE (decl);
5140 if (type == error_mark_node)
5141 return;
5143 /* If we haven't already laid out this declaration, do so now.
5144 Note that we must not call complete type for an external object
5145 because it's type might involve templates that we are not
5146 supposed to instantiate yet. (And it's perfectly valid to say
5147 `extern X x' for some incomplete type `X'.) */
5148 if (!DECL_EXTERNAL (decl))
5149 complete_type (type);
5150 if (!DECL_SIZE (decl)
5151 && TREE_TYPE (decl) != error_mark_node
5152 && (COMPLETE_TYPE_P (type)
5153 || (TREE_CODE (type) == ARRAY_TYPE
5154 && !TYPE_DOMAIN (type)
5155 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
5156 layout_decl (decl, 0);
5158 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
5160 /* An automatic variable with an incomplete type: that is an error.
5161 Don't talk about array types here, since we took care of that
5162 message in grokdeclarator. */
5163 error ("storage size of %qD isn%'t known", decl);
5164 TREE_TYPE (decl) = error_mark_node;
5166 #if 0
5167 /* Keep this code around in case we later want to control debug info
5168 based on whether a type is "used". (jason 1999-11-11) */
5170 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
5171 /* Let debugger know it should output info for this type. */
5172 note_debug_info_needed (ttype);
5174 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
5175 note_debug_info_needed (DECL_CONTEXT (decl));
5176 #endif
5178 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
5179 && DECL_SIZE (decl) != NULL_TREE
5180 && ! TREE_CONSTANT (DECL_SIZE (decl)))
5182 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
5183 constant_expression_warning (DECL_SIZE (decl));
5184 else
5186 error ("storage size of %qD isn%'t constant", decl);
5187 TREE_TYPE (decl) = error_mark_node;
5192 /* If a local static variable is declared in an inline function, or if
5193 we have a weak definition, we must endeavor to create only one
5194 instance of the variable at link-time. */
5196 void
5197 maybe_commonize_var (tree decl)
5199 /* Static data in a function with comdat linkage also has comdat
5200 linkage. */
5201 if (TREE_STATIC (decl)
5202 /* Don't mess with __FUNCTION__. */
5203 && ! DECL_ARTIFICIAL (decl)
5204 && DECL_FUNCTION_SCOPE_P (decl)
5205 && vague_linkage_p (DECL_CONTEXT (decl)))
5207 if (flag_weak)
5209 /* With weak symbols, we simply make the variable COMDAT;
5210 that will cause copies in multiple translations units to
5211 be merged. */
5212 comdat_linkage (decl);
5214 else
5216 if (DECL_INITIAL (decl) == NULL_TREE
5217 || DECL_INITIAL (decl) == error_mark_node)
5219 /* Without weak symbols, we can use COMMON to merge
5220 uninitialized variables. */
5221 TREE_PUBLIC (decl) = 1;
5222 DECL_COMMON (decl) = 1;
5224 else
5226 /* While for initialized variables, we must use internal
5227 linkage -- which means that multiple copies will not
5228 be merged. */
5229 TREE_PUBLIC (decl) = 0;
5230 DECL_COMMON (decl) = 0;
5231 if (warning_at (DECL_SOURCE_LOCATION (decl), 0,
5232 "sorry: semantics of inline function static "
5233 "data %q#D are wrong (you%'ll wind up "
5234 "with multiple copies)", decl))
5235 inform (DECL_SOURCE_LOCATION (decl),
5236 "you can work around this by removing the initializer");
5242 /* Issue an error message if DECL is an uninitialized const variable. */
5244 static void
5245 check_for_uninitialized_const_var (tree decl)
5247 tree type = strip_array_types (TREE_TYPE (decl));
5249 /* ``Unless explicitly declared extern, a const object does not have
5250 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5251 7.1.6 */
5252 if (VAR_P (decl)
5253 && TREE_CODE (type) != REFERENCE_TYPE
5254 && (CP_TYPE_CONST_P (type) || var_in_constexpr_fn (decl))
5255 && !DECL_INITIAL (decl))
5257 tree field = default_init_uninitialized_part (type);
5258 if (!field)
5259 return;
5261 if (CP_TYPE_CONST_P (type))
5262 permerror (DECL_SOURCE_LOCATION (decl),
5263 "uninitialized const %qD", decl);
5264 else
5266 error_at (DECL_SOURCE_LOCATION (decl),
5267 "uninitialized variable %qD in %<constexpr%> function",
5268 decl);
5269 cp_function_chain->invalid_constexpr = true;
5272 if (CLASS_TYPE_P (type))
5274 tree defaulted_ctor;
5276 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
5277 "%q#T has no user-provided default constructor", type);
5278 defaulted_ctor = in_class_defaulted_default_constructor (type);
5279 if (defaulted_ctor)
5280 inform (DECL_SOURCE_LOCATION (defaulted_ctor),
5281 "constructor is not user-provided because it is "
5282 "explicitly defaulted in the class body");
5283 inform (0, "and the implicitly-defined constructor does not "
5284 "initialize %q+#D", field);
5289 /* Structure holding the current initializer being processed by reshape_init.
5290 CUR is a pointer to the current element being processed, END is a pointer
5291 after the last element present in the initializer. */
5292 typedef struct reshape_iterator_t
5294 constructor_elt *cur;
5295 constructor_elt *end;
5296 } reshape_iter;
5298 static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t);
5300 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5301 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5302 initialized. If there are no more such fields, the return value
5303 will be NULL. */
5305 tree
5306 next_initializable_field (tree field)
5308 while (field
5309 && (TREE_CODE (field) != FIELD_DECL
5310 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
5311 || DECL_ARTIFICIAL (field)))
5312 field = DECL_CHAIN (field);
5314 return field;
5317 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5318 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5319 INTEGER_CST representing the size of the array minus one (the maximum index),
5320 or NULL_TREE if the array was declared without specifying the size. D is
5321 the iterator within the constructor. */
5323 static tree
5324 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d,
5325 tsubst_flags_t complain)
5327 tree new_init;
5328 bool sized_array_p = (max_index && TREE_CONSTANT (max_index));
5329 unsigned HOST_WIDE_INT max_index_cst = 0;
5330 unsigned HOST_WIDE_INT index;
5332 /* The initializer for an array is always a CONSTRUCTOR. */
5333 new_init = build_constructor (init_list_type_node, NULL);
5335 if (sized_array_p)
5337 /* Minus 1 is used for zero sized arrays. */
5338 if (integer_all_onesp (max_index))
5339 return new_init;
5341 if (tree_fits_uhwi_p (max_index))
5342 max_index_cst = tree_to_uhwi (max_index);
5343 /* sizetype is sign extended, not zero extended. */
5344 else
5345 max_index_cst = tree_to_uhwi (fold_convert (size_type_node, max_index));
5348 /* Loop until there are no more initializers. */
5349 for (index = 0;
5350 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
5351 ++index)
5353 tree elt_init;
5354 constructor_elt *old_cur = d->cur;
5356 check_array_designated_initializer (d->cur, index);
5357 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false,
5358 complain);
5359 if (elt_init == error_mark_node)
5360 return error_mark_node;
5361 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
5362 size_int (index), elt_init);
5363 if (!TREE_CONSTANT (elt_init))
5364 TREE_CONSTANT (new_init) = false;
5366 /* This can happen with an invalid initializer (c++/54501). */
5367 if (d->cur == old_cur && !sized_array_p)
5368 break;
5371 return new_init;
5374 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5375 Parameters are the same of reshape_init_r. */
5377 static tree
5378 reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain)
5380 tree max_index = NULL_TREE;
5382 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
5384 if (TYPE_DOMAIN (type))
5385 max_index = array_type_nelts (type);
5387 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5390 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5391 Parameters are the same of reshape_init_r. */
5393 static tree
5394 reshape_init_vector (tree type, reshape_iter *d, tsubst_flags_t complain)
5396 tree max_index = NULL_TREE;
5398 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
5400 if (COMPOUND_LITERAL_P (d->cur->value))
5402 tree value = d->cur->value;
5403 if (!same_type_p (TREE_TYPE (value), type))
5405 if (complain & tf_error)
5406 error ("invalid type %qT as initializer for a vector of type %qT",
5407 TREE_TYPE (d->cur->value), type);
5408 value = error_mark_node;
5410 ++d->cur;
5411 return value;
5414 /* For a vector, we initialize it as an array of the appropriate size. */
5415 if (TREE_CODE (type) == VECTOR_TYPE)
5416 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1);
5418 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5421 /* Subroutine of reshape_init_r, processes the initializers for classes
5422 or union. Parameters are the same of reshape_init_r. */
5424 static tree
5425 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
5426 tsubst_flags_t complain)
5428 tree field;
5429 tree new_init;
5431 gcc_assert (CLASS_TYPE_P (type));
5433 /* The initializer for a class is always a CONSTRUCTOR. */
5434 new_init = build_constructor (init_list_type_node, NULL);
5435 field = next_initializable_field (TYPE_FIELDS (type));
5437 if (!field)
5439 /* [dcl.init.aggr]
5441 An initializer for an aggregate member that is an
5442 empty class shall have the form of an empty
5443 initializer-list {}. */
5444 if (!first_initializer_p)
5446 if (complain & tf_error)
5447 error ("initializer for %qT must be brace-enclosed", type);
5448 return error_mark_node;
5450 return new_init;
5453 /* Loop through the initializable fields, gathering initializers. */
5454 while (d->cur != d->end)
5456 tree field_init;
5457 constructor_elt *old_cur = d->cur;
5459 /* Handle designated initializers, as an extension. */
5460 if (d->cur->index)
5462 if (d->cur->index == error_mark_node)
5463 return error_mark_node;
5465 if (TREE_CODE (d->cur->index) == FIELD_DECL)
5466 /* We already reshaped this. */
5467 gcc_assert (d->cur->index == field);
5468 else if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
5469 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
5470 else
5472 if (complain & tf_error)
5473 error ("%<[%E] =%> used in a GNU-style designated initializer"
5474 " for class %qT", d->cur->index, type);
5475 return error_mark_node;
5478 if (!field || TREE_CODE (field) != FIELD_DECL)
5480 if (complain & tf_error)
5481 error ("%qT has no non-static data member named %qD", type,
5482 d->cur->index);
5483 return error_mark_node;
5487 /* If we processed all the member of the class, we are done. */
5488 if (!field)
5489 break;
5491 field_init = reshape_init_r (TREE_TYPE (field), d,
5492 /*first_initializer_p=*/false, complain);
5493 if (field_init == error_mark_node)
5494 return error_mark_node;
5496 if (d->cur == old_cur && d->cur->index)
5498 /* This can happen with an invalid initializer for a flexible
5499 array member (c++/54441). */
5500 if (complain & tf_error)
5501 error ("invalid initializer for %q#D", field);
5502 return error_mark_node;
5505 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
5507 /* [dcl.init.aggr]
5509 When a union is initialized with a brace-enclosed
5510 initializer, the braces shall only contain an
5511 initializer for the first member of the union. */
5512 if (TREE_CODE (type) == UNION_TYPE)
5513 break;
5515 field = next_initializable_field (DECL_CHAIN (field));
5518 return new_init;
5521 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5522 designators are not valid; either complain or return true to indicate
5523 that reshape_init_r should return error_mark_node. */
5525 static bool
5526 has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
5528 if (d->cur->index)
5530 if (complain & tf_error)
5531 error ("C99 designator %qE outside aggregate initializer",
5532 d->cur->index);
5533 else
5534 return true;
5536 return false;
5539 /* Subroutine of reshape_init, which processes a single initializer (part of
5540 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5541 iterator within the CONSTRUCTOR which points to the initializer to process.
5542 FIRST_INITIALIZER_P is true if this is the first initializer of the
5543 outermost CONSTRUCTOR node. */
5545 static tree
5546 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
5547 tsubst_flags_t complain)
5549 tree init = d->cur->value;
5551 if (error_operand_p (init))
5552 return error_mark_node;
5554 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
5555 && has_designator_problem (d, complain))
5556 return error_mark_node;
5558 if (TREE_CODE (type) == COMPLEX_TYPE)
5560 /* A complex type can be initialized from one or two initializers,
5561 but braces are not elided. */
5562 d->cur++;
5563 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5565 if (CONSTRUCTOR_NELTS (init) > 2)
5567 if (complain & tf_error)
5568 error ("too many initializers for %qT", type);
5569 else
5570 return error_mark_node;
5573 else if (first_initializer_p && d->cur != d->end)
5575 vec<constructor_elt, va_gc> *v = 0;
5576 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
5577 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
5578 if (has_designator_problem (d, complain))
5579 return error_mark_node;
5580 d->cur++;
5581 init = build_constructor (init_list_type_node, v);
5583 return init;
5586 /* A non-aggregate type is always initialized with a single
5587 initializer. */
5588 if (!CP_AGGREGATE_TYPE_P (type))
5590 /* It is invalid to initialize a non-aggregate type with a
5591 brace-enclosed initializer before C++0x.
5592 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5593 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5594 a CONSTRUCTOR (with a record type). */
5595 if (TREE_CODE (init) == CONSTRUCTOR
5596 /* Don't complain about a capture-init. */
5597 && !CONSTRUCTOR_IS_DIRECT_INIT (init)
5598 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
5600 if (SCALAR_TYPE_P (type))
5602 if (cxx_dialect < cxx11
5603 /* Isn't value-initialization. */
5604 || CONSTRUCTOR_NELTS (init) > 0)
5606 if (complain & tf_error)
5607 error ("braces around scalar initializer for type %qT",
5608 type);
5609 init = error_mark_node;
5612 else
5613 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5616 d->cur++;
5617 return init;
5620 /* "If T is a class type and the initializer list has a single element of
5621 type cv U, where U is T or a class derived from T, the object is
5622 initialized from that element." Even if T is an aggregate. */
5623 if (cxx_dialect >= cxx11 && (CLASS_TYPE_P (type) || VECTOR_TYPE_P (type))
5624 && first_initializer_p
5625 && d->end - d->cur == 1
5626 && reference_related_p (type, TREE_TYPE (init)))
5628 d->cur++;
5629 return init;
5632 /* [dcl.init.aggr]
5634 All implicit type conversions (clause _conv_) are considered when
5635 initializing the aggregate member with an initializer from an
5636 initializer-list. If the initializer can initialize a member,
5637 the member is initialized. Otherwise, if the member is itself a
5638 non-empty subaggregate, brace elision is assumed and the
5639 initializer is considered for the initialization of the first
5640 member of the subaggregate. */
5641 if (TREE_CODE (init) != CONSTRUCTOR
5642 /* But don't try this for the first initializer, since that would be
5643 looking through the outermost braces; A a2 = { a1 }; is not a
5644 valid aggregate initialization. */
5645 && !first_initializer_p
5646 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
5647 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL,
5648 complain)))
5650 d->cur++;
5651 return init;
5654 /* [dcl.init.string]
5656 A char array (whether plain char, signed char, or unsigned char)
5657 can be initialized by a string-literal (optionally enclosed in
5658 braces); a wchar_t array can be initialized by a wide
5659 string-literal (optionally enclosed in braces). */
5660 if (TREE_CODE (type) == ARRAY_TYPE
5661 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
5663 tree str_init = init;
5665 /* Strip one level of braces if and only if they enclose a single
5666 element (as allowed by [dcl.init.string]). */
5667 if (!first_initializer_p
5668 && TREE_CODE (str_init) == CONSTRUCTOR
5669 && vec_safe_length (CONSTRUCTOR_ELTS (str_init)) == 1)
5671 str_init = (*CONSTRUCTOR_ELTS (str_init))[0].value;
5674 /* If it's a string literal, then it's the initializer for the array
5675 as a whole. Otherwise, continue with normal initialization for
5676 array types (one value per array element). */
5677 if (TREE_CODE (str_init) == STRING_CST)
5679 if (has_designator_problem (d, complain))
5680 return error_mark_node;
5681 d->cur++;
5682 return str_init;
5686 /* The following cases are about aggregates. If we are not within a full
5687 initializer already, and there is not a CONSTRUCTOR, it means that there
5688 is a missing set of braces (that is, we are processing the case for
5689 which reshape_init exists). */
5690 if (!first_initializer_p)
5692 if (TREE_CODE (init) == CONSTRUCTOR)
5694 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
5695 /* There is no need to reshape pointer-to-member function
5696 initializers, as they are always constructed correctly
5697 by the front end. */
5699 else if (COMPOUND_LITERAL_P (init))
5700 /* For a nested compound literal, there is no need to reshape since
5701 brace elision is not allowed. Even if we decided to allow it,
5702 we should add a call to reshape_init in finish_compound_literal,
5703 before calling digest_init, so changing this code would still
5704 not be necessary. */
5705 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
5706 else
5708 ++d->cur;
5709 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5710 return reshape_init (type, init, complain);
5714 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
5715 type);
5718 /* Dispatch to specialized routines. */
5719 if (CLASS_TYPE_P (type))
5720 return reshape_init_class (type, d, first_initializer_p, complain);
5721 else if (TREE_CODE (type) == ARRAY_TYPE)
5722 return reshape_init_array (type, d, complain);
5723 else if (TREE_CODE (type) == VECTOR_TYPE)
5724 return reshape_init_vector (type, d, complain);
5725 else
5726 gcc_unreachable();
5729 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5730 brace-enclosed aggregate initializer.
5732 INIT is the CONSTRUCTOR containing the list of initializers describing
5733 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5734 It may not presently match the shape of the TYPE; for example:
5736 struct S { int a; int b; };
5737 struct S a[] = { 1, 2, 3, 4 };
5739 Here INIT will hold a vector of four elements, rather than a
5740 vector of two elements, each itself a vector of two elements. This
5741 routine transforms INIT from the former form into the latter. The
5742 revised CONSTRUCTOR node is returned. */
5744 tree
5745 reshape_init (tree type, tree init, tsubst_flags_t complain)
5747 vec<constructor_elt, va_gc> *v;
5748 reshape_iter d;
5749 tree new_init;
5751 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5753 v = CONSTRUCTOR_ELTS (init);
5755 /* An empty constructor does not need reshaping, and it is always a valid
5756 initializer. */
5757 if (vec_safe_is_empty (v))
5758 return init;
5760 /* Recurse on this CONSTRUCTOR. */
5761 d.cur = &(*v)[0];
5762 d.end = d.cur + v->length ();
5764 new_init = reshape_init_r (type, &d, true, complain);
5765 if (new_init == error_mark_node)
5766 return error_mark_node;
5768 /* Make sure all the element of the constructor were used. Otherwise,
5769 issue an error about exceeding initializers. */
5770 if (d.cur != d.end)
5772 if (complain & tf_error)
5773 error ("too many initializers for %qT", type);
5774 else
5775 return error_mark_node;
5778 return new_init;
5781 /* Verify array initializer. Returns true if errors have been reported. */
5783 bool
5784 check_array_initializer (tree decl, tree type, tree init)
5786 tree element_type = TREE_TYPE (type);
5788 /* The array type itself need not be complete, because the
5789 initializer may tell us how many elements are in the array.
5790 But, the elements of the array must be complete. */
5791 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5793 if (decl)
5794 error ("elements of array %q#D have incomplete type", decl);
5795 else
5796 error ("elements of array %q#T have incomplete type", type);
5797 return true;
5799 /* A compound literal can't have variable size. */
5800 if (init && !decl
5801 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5802 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5804 error ("variable-sized compound literal");
5805 return true;
5807 return false;
5810 /* Subroutine of check_initializer; args are passed down from that function.
5811 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5813 static tree
5814 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5817 gcc_assert (stmts_are_full_exprs_p ());
5818 return build_aggr_init (decl, init, flags, tf_warning_or_error);
5821 /* Verify INIT (the initializer for DECL), and record the
5822 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5823 grok_reference_init.
5825 If the return value is non-NULL, it is an expression that must be
5826 evaluated dynamically to initialize DECL. */
5828 static tree
5829 check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups)
5831 tree type = TREE_TYPE (decl);
5832 tree init_code = NULL;
5833 tree core_type;
5835 /* Things that are going to be initialized need to have complete
5836 type. */
5837 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5839 if (DECL_HAS_VALUE_EXPR_P (decl))
5841 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5842 it doesn't have storage to be initialized. */
5843 gcc_assert (init == NULL_TREE);
5844 return NULL_TREE;
5847 if (type == error_mark_node)
5848 /* We will have already complained. */
5849 return NULL_TREE;
5851 if (TREE_CODE (type) == ARRAY_TYPE)
5853 if (check_array_initializer (decl, type, init))
5854 return NULL_TREE;
5856 else if (!COMPLETE_TYPE_P (type))
5858 error ("%q#D has incomplete type", decl);
5859 TREE_TYPE (decl) = error_mark_node;
5860 return NULL_TREE;
5862 else
5863 /* There is no way to make a variable-sized class type in GNU C++. */
5864 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5866 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5868 int init_len = vec_safe_length (CONSTRUCTOR_ELTS (init));
5869 if (SCALAR_TYPE_P (type))
5871 if (init_len == 0)
5873 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5874 init = build_zero_init (type, NULL_TREE, false);
5876 else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
5878 error ("scalar object %qD requires one element in initializer",
5879 decl);
5880 TREE_TYPE (decl) = error_mark_node;
5881 return NULL_TREE;
5886 if (TREE_CODE (decl) == CONST_DECL)
5888 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5890 DECL_INITIAL (decl) = init;
5892 gcc_assert (init != NULL_TREE);
5893 init = NULL_TREE;
5895 else if (!init && DECL_REALLY_EXTERN (decl))
5897 else if (init || type_build_ctor_call (type)
5898 || TREE_CODE (type) == REFERENCE_TYPE)
5900 if (TREE_CODE (type) == REFERENCE_TYPE)
5902 init = grok_reference_init (decl, type, init, flags);
5903 flags |= LOOKUP_ALREADY_DIGESTED;
5905 else if (!init)
5906 check_for_uninitialized_const_var (decl);
5907 /* Do not reshape constructors of vectors (they don't need to be
5908 reshaped. */
5909 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
5911 if (is_std_init_list (type))
5913 init = perform_implicit_conversion (type, init,
5914 tf_warning_or_error);
5915 flags |= LOOKUP_ALREADY_DIGESTED;
5917 else if (TYPE_NON_AGGREGATE_CLASS (type))
5919 /* Don't reshape if the class has constructors. */
5920 if (cxx_dialect == cxx98)
5921 error ("in C++98 %qD must be initialized by constructor, "
5922 "not by %<{...}%>",
5923 decl);
5925 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5927 error ("opaque vector types cannot be initialized");
5928 init = error_mark_node;
5930 else
5932 init = reshape_init (type, init, tf_warning_or_error);
5933 flags |= LOOKUP_NO_NARROWING;
5936 else if (TREE_CODE (init) == TREE_LIST
5937 && TREE_TYPE (init) != unknown_type_node
5938 && !MAYBE_CLASS_TYPE_P (type))
5940 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5942 /* We get here with code like `int a (2);' */
5943 init = build_x_compound_expr_from_list (init, ELK_INIT,
5944 tf_warning_or_error);
5947 /* If DECL has an array type without a specific bound, deduce the
5948 array size from the initializer. */
5949 maybe_deduce_size_from_array_init (decl, init);
5950 type = TREE_TYPE (decl);
5951 if (type == error_mark_node)
5952 return NULL_TREE;
5954 if ((type_build_ctor_call (type) || CLASS_TYPE_P (type))
5955 && !(flags & LOOKUP_ALREADY_DIGESTED)
5956 && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
5957 && CP_AGGREGATE_TYPE_P (type)
5958 && (CLASS_TYPE_P (type)
5959 || !TYPE_NEEDS_CONSTRUCTING (type)
5960 || type_has_extended_temps (type))))
5962 init_code = build_aggr_init_full_exprs (decl, init, flags);
5964 /* A constructor call is a non-trivial initializer even if
5965 it isn't explicitly written. */
5966 if (TREE_SIDE_EFFECTS (init_code))
5967 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = true;
5969 /* If this is a constexpr initializer, expand_default_init will
5970 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5971 case, pull the initializer back out and pass it down into
5972 store_init_value. */
5973 while (TREE_CODE (init_code) == EXPR_STMT
5974 || TREE_CODE (init_code) == CONVERT_EXPR)
5975 init_code = TREE_OPERAND (init_code, 0);
5976 if (TREE_CODE (init_code) == INIT_EXPR)
5978 init = TREE_OPERAND (init_code, 1);
5979 init_code = NULL_TREE;
5980 /* Don't call digest_init; it's unnecessary and will complain
5981 about aggregate initialization of non-aggregate classes. */
5982 flags |= LOOKUP_ALREADY_DIGESTED;
5984 else if (DECL_DECLARED_CONSTEXPR_P (decl))
5986 /* Declared constexpr, but no suitable initializer; massage
5987 init appropriately so we can pass it into store_init_value
5988 for the error. */
5989 if (CLASS_TYPE_P (type)
5990 && (!init || TREE_CODE (init) == TREE_LIST))
5992 init = build_functional_cast (type, init, tf_none);
5993 if (TREE_CODE (init) == TARGET_EXPR)
5994 TARGET_EXPR_DIRECT_INIT_P (init) = true;
5996 init_code = NULL_TREE;
5998 else
5999 init = NULL_TREE;
6002 if (init && TREE_CODE (init) != TREE_VEC)
6004 /* In aggregate initialization of a variable, each element
6005 initialization is a full-expression because there is no
6006 enclosing expression. */
6007 gcc_assert (stmts_are_full_exprs_p ());
6009 init_code = store_init_value (decl, init, cleanups, flags);
6011 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
6012 && DECL_INITIAL (decl)
6013 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
6014 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
6015 warning (0, "array %qD initialized by parenthesized string literal %qE",
6016 decl, DECL_INITIAL (decl));
6017 init = NULL;
6020 else
6022 if (CLASS_TYPE_P (core_type = strip_array_types (type))
6023 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
6024 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
6025 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
6026 /*complain=*/true);
6028 check_for_uninitialized_const_var (decl);
6031 if (init && init != error_mark_node)
6032 init_code = build2 (INIT_EXPR, type, decl, init);
6034 if (init_code)
6036 /* We might have set these in cp_finish_decl. */
6037 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = false;
6038 TREE_CONSTANT (decl) = false;
6041 if (init_code && DECL_IN_AGGR_P (decl))
6043 static int explained = 0;
6045 if (cxx_dialect < cxx11)
6046 error ("initializer invalid for static member with constructor");
6047 else
6048 error ("non-constant in-class initialization invalid for static "
6049 "member %qD", decl);
6050 if (!explained)
6052 inform (input_location,
6053 "(an out of class initialization is required)");
6054 explained = 1;
6056 return NULL_TREE;
6059 return init_code;
6062 /* If DECL is not a local variable, give it RTL. */
6064 static void
6065 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
6067 int toplev = toplevel_bindings_p ();
6068 int defer_p;
6070 /* Set the DECL_ASSEMBLER_NAME for the object. */
6071 if (asmspec)
6073 /* The `register' keyword, when used together with an
6074 asm-specification, indicates that the variable should be
6075 placed in a particular register. */
6076 if (VAR_P (decl) && DECL_REGISTER (decl))
6078 set_user_assembler_name (decl, asmspec);
6079 DECL_HARD_REGISTER (decl) = 1;
6081 else
6083 if (TREE_CODE (decl) == FUNCTION_DECL
6084 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
6085 set_builtin_user_assembler_name (decl, asmspec);
6086 set_user_assembler_name (decl, asmspec);
6090 /* Handle non-variables up front. */
6091 if (!VAR_P (decl))
6093 rest_of_decl_compilation (decl, toplev, at_eof);
6094 return;
6097 /* If we see a class member here, it should be a static data
6098 member. */
6099 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
6101 gcc_assert (TREE_STATIC (decl));
6102 /* An in-class declaration of a static data member should be
6103 external; it is only a declaration, and not a definition. */
6104 if (init == NULL_TREE)
6105 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
6108 /* We don't create any RTL for local variables. */
6109 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6110 return;
6112 /* We defer emission of local statics until the corresponding
6113 DECL_EXPR is expanded. */
6114 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
6116 /* Defer template instantiations. */
6117 if (DECL_LANG_SPECIFIC (decl)
6118 && DECL_IMPLICIT_INSTANTIATION (decl))
6119 defer_p = 1;
6121 /* If we're not deferring, go ahead and assemble the variable. */
6122 if (!defer_p)
6123 rest_of_decl_compilation (decl, toplev, at_eof);
6126 /* walk_tree helper for wrap_temporary_cleanups, below. */
6128 static tree
6129 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
6131 /* Stop at types or full-expression boundaries. */
6132 if (TYPE_P (*stmt_p)
6133 || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR)
6135 *walk_subtrees = 0;
6136 return NULL_TREE;
6139 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
6141 tree guard = (tree)data;
6142 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
6144 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
6145 /* Tell honor_protect_cleanup_actions to handle this as a separate
6146 cleanup. */
6147 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
6149 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
6152 return NULL_TREE;
6155 /* We're initializing a local variable which has a cleanup GUARD. If there
6156 are any temporaries used in the initializer INIT of this variable, we
6157 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6158 variable will be cleaned up properly if one of them throws.
6160 Unfortunately, there's no way to express this properly in terms of
6161 nesting, as the regions for the temporaries overlap the region for the
6162 variable itself; if there are two temporaries, the variable needs to be
6163 the first thing destroyed if either of them throws. However, we only
6164 want to run the variable's cleanup if it actually got constructed. So
6165 we need to guard the temporary cleanups with the variable's cleanup if
6166 they are run on the normal path, but not if they are run on the
6167 exceptional path. We implement this by telling
6168 honor_protect_cleanup_actions to strip the variable cleanup from the
6169 exceptional path. */
6171 static void
6172 wrap_temporary_cleanups (tree init, tree guard)
6174 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
6177 /* Generate code to initialize DECL (a local variable). */
6179 static void
6180 initialize_local_var (tree decl, tree init)
6182 tree type = TREE_TYPE (decl);
6183 tree cleanup;
6184 int already_used;
6186 gcc_assert (VAR_P (decl)
6187 || TREE_CODE (decl) == RESULT_DECL);
6188 gcc_assert (!TREE_STATIC (decl));
6190 if (DECL_SIZE (decl) == NULL_TREE)
6192 /* If we used it already as memory, it must stay in memory. */
6193 DECL_INITIAL (decl) = NULL_TREE;
6194 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
6195 return;
6198 if (type == error_mark_node)
6199 return;
6201 /* Compute and store the initial value. */
6202 already_used = TREE_USED (decl) || TREE_USED (type);
6203 if (TREE_USED (type))
6204 DECL_READ_P (decl) = 1;
6206 /* Generate a cleanup, if necessary. */
6207 cleanup = cxx_maybe_build_cleanup (decl, tf_warning_or_error);
6209 /* Perform the initialization. */
6210 if (init)
6212 tree rinit = (TREE_CODE (init) == INIT_EXPR
6213 ? TREE_OPERAND (init, 1) : NULL_TREE);
6214 if (rinit && !TREE_SIDE_EFFECTS (rinit))
6216 /* Stick simple initializers in DECL_INITIAL so that
6217 -Wno-init-self works (c++/34772). */
6218 gcc_assert (TREE_OPERAND (init, 0) == decl);
6219 DECL_INITIAL (decl) = rinit;
6221 if (warn_init_self && TREE_CODE (type) == REFERENCE_TYPE)
6223 STRIP_NOPS (rinit);
6224 if (rinit == decl)
6225 warning_at (DECL_SOURCE_LOCATION (decl),
6226 OPT_Winit_self,
6227 "reference %qD is initialized with itself", decl);
6230 else
6232 int saved_stmts_are_full_exprs_p;
6234 /* If we're only initializing a single object, guard the
6235 destructors of any temporaries used in its initializer with
6236 its destructor. This isn't right for arrays because each
6237 element initialization is a full-expression. */
6238 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
6239 wrap_temporary_cleanups (init, cleanup);
6241 gcc_assert (building_stmt_list_p ());
6242 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
6243 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
6244 finish_expr_stmt (init);
6245 current_stmt_tree ()->stmts_are_full_exprs_p =
6246 saved_stmts_are_full_exprs_p;
6250 /* Set this to 0 so we can tell whether an aggregate which was
6251 initialized was ever used. Don't do this if it has a
6252 destructor, so we don't complain about the 'resource
6253 allocation is initialization' idiom. Now set
6254 attribute((unused)) on types so decls of that type will be
6255 marked used. (see TREE_USED, above.) */
6256 if (TYPE_NEEDS_CONSTRUCTING (type)
6257 && ! already_used
6258 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
6259 && DECL_NAME (decl))
6260 TREE_USED (decl) = 0;
6261 else if (already_used)
6262 TREE_USED (decl) = 1;
6264 if (cleanup)
6265 finish_decl_cleanup (decl, cleanup);
6268 /* DECL is a VAR_DECL for a compiler-generated variable with static
6269 storage duration (like a virtual table) whose initializer is a
6270 compile-time constant. Initialize the variable and provide it to the
6271 back end. */
6273 void
6274 initialize_artificial_var (tree decl, vec<constructor_elt, va_gc> *v)
6276 tree init;
6277 gcc_assert (DECL_ARTIFICIAL (decl));
6278 init = build_constructor (TREE_TYPE (decl), v);
6279 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
6280 DECL_INITIAL (decl) = init;
6281 DECL_INITIALIZED_P (decl) = 1;
6282 determine_visibility (decl);
6283 layout_var_decl (decl);
6284 maybe_commonize_var (decl);
6285 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
6288 /* INIT is the initializer for a variable, as represented by the
6289 parser. Returns true iff INIT is type-dependent. */
6291 static bool
6292 type_dependent_init_p (tree init)
6294 if (TREE_CODE (init) == TREE_LIST)
6295 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6296 return any_type_dependent_elements_p (init);
6297 else if (TREE_CODE (init) == CONSTRUCTOR)
6298 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6300 vec<constructor_elt, va_gc> *elts;
6301 size_t nelts;
6302 size_t i;
6304 elts = CONSTRUCTOR_ELTS (init);
6305 nelts = vec_safe_length (elts);
6306 for (i = 0; i < nelts; ++i)
6307 if (type_dependent_init_p ((*elts)[i].value))
6308 return true;
6310 else
6311 /* It must be a simple expression, e.g., int i = 3; */
6312 return type_dependent_expression_p (init);
6314 return false;
6317 /* INIT is the initializer for a variable, as represented by the
6318 parser. Returns true iff INIT is value-dependent. */
6320 static bool
6321 value_dependent_init_p (tree init)
6323 if (TREE_CODE (init) == TREE_LIST)
6324 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6325 return any_value_dependent_elements_p (init);
6326 else if (TREE_CODE (init) == CONSTRUCTOR)
6327 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6329 vec<constructor_elt, va_gc> *elts;
6330 size_t nelts;
6331 size_t i;
6333 elts = CONSTRUCTOR_ELTS (init);
6334 nelts = vec_safe_length (elts);
6335 for (i = 0; i < nelts; ++i)
6336 if (value_dependent_init_p ((*elts)[i].value))
6337 return true;
6339 else
6340 /* It must be a simple expression, e.g., int i = 3; */
6341 return value_dependent_expression_p (init);
6343 return false;
6346 /* Finish processing of a declaration;
6347 install its line number and initial value.
6348 If the length of an array type is not known before,
6349 it must be determined now, from the initial value, or it is an error.
6351 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6352 true, then INIT is an integral constant expression.
6354 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6355 if the (init) syntax was used. */
6357 void
6358 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
6359 tree asmspec_tree, int flags)
6361 tree type;
6362 vec<tree, va_gc> *cleanups = NULL;
6363 const char *asmspec = NULL;
6364 int was_readonly = 0;
6365 bool var_definition_p = false;
6366 tree auto_node;
6368 if (decl == error_mark_node)
6369 return;
6370 else if (! decl)
6372 if (init)
6373 error ("assignment (not initialization) in declaration");
6374 return;
6377 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
6378 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6379 gcc_assert (TREE_CODE (decl) != PARM_DECL);
6381 type = TREE_TYPE (decl);
6382 if (type == error_mark_node)
6383 return;
6385 /* If a name was specified, get the string. */
6386 if (at_namespace_scope_p ())
6387 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
6388 if (asmspec_tree && asmspec_tree != error_mark_node)
6389 asmspec = TREE_STRING_POINTER (asmspec_tree);
6391 if (current_class_type
6392 && CP_DECL_CONTEXT (decl) == current_class_type
6393 && TYPE_BEING_DEFINED (current_class_type)
6394 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type)
6395 && (DECL_INITIAL (decl) || init))
6396 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
6398 if (TREE_CODE (decl) != FUNCTION_DECL
6399 && (auto_node = type_uses_auto (type)))
6401 tree d_init;
6402 if (init == NULL_TREE)
6404 if (DECL_LANG_SPECIFIC (decl)
6405 && DECL_TEMPLATE_INSTANTIATION (decl)
6406 && !DECL_TEMPLATE_INSTANTIATED (decl))
6408 /* init is null because we're deferring instantiating the
6409 initializer until we need it. Well, we need it now. */
6410 instantiate_decl (decl, /*defer_ok*/true, /*expl*/false);
6411 return;
6414 error ("declaration of %q#D has no initializer", decl);
6415 TREE_TYPE (decl) = error_mark_node;
6416 return;
6418 d_init = init;
6419 if (TREE_CODE (d_init) == TREE_LIST)
6420 d_init = build_x_compound_expr_from_list (d_init, ELK_INIT,
6421 tf_warning_or_error);
6422 d_init = resolve_nondeduced_context (d_init);
6423 type = TREE_TYPE (decl) = do_auto_deduction (type, d_init,
6424 auto_node);
6425 if (type == error_mark_node)
6426 return;
6427 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
6430 if (!ensure_literal_type_for_constexpr_object (decl))
6431 DECL_DECLARED_CONSTEXPR_P (decl) = 0;
6433 if (VAR_P (decl)
6434 && DECL_CLASS_SCOPE_P (decl)
6435 && DECL_INITIALIZED_IN_CLASS_P (decl))
6436 check_static_variable_definition (decl, type);
6438 if (init && TREE_CODE (decl) == FUNCTION_DECL)
6440 tree clone;
6441 if (init == ridpointers[(int)RID_DELETE])
6443 /* FIXME check this is 1st decl. */
6444 DECL_DELETED_FN (decl) = 1;
6445 DECL_DECLARED_INLINE_P (decl) = 1;
6446 DECL_INITIAL (decl) = error_mark_node;
6447 FOR_EACH_CLONE (clone, decl)
6449 DECL_DELETED_FN (clone) = 1;
6450 DECL_DECLARED_INLINE_P (clone) = 1;
6451 DECL_INITIAL (clone) = error_mark_node;
6453 init = NULL_TREE;
6455 else if (init == ridpointers[(int)RID_DEFAULT])
6457 if (defaultable_fn_check (decl))
6458 DECL_DEFAULTED_FN (decl) = 1;
6459 else
6460 DECL_INITIAL (decl) = NULL_TREE;
6464 if (init && VAR_P (decl))
6466 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
6467 /* If DECL is a reference, then we want to know whether init is a
6468 reference constant; init_const_expr_p as passed tells us whether
6469 it's an rvalue constant. */
6470 if (TREE_CODE (type) == REFERENCE_TYPE)
6471 init_const_expr_p = potential_constant_expression (init);
6472 if (init_const_expr_p)
6474 /* Set these flags now for templates. We'll update the flags in
6475 store_init_value for instantiations. */
6476 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
6477 if (decl_maybe_constant_var_p (decl))
6478 TREE_CONSTANT (decl) = 1;
6482 if (processing_template_decl)
6484 bool type_dependent_p;
6486 /* Add this declaration to the statement-tree. */
6487 if (at_function_scope_p ())
6488 add_decl_expr (decl);
6490 type_dependent_p = dependent_type_p (type);
6492 if (check_for_bare_parameter_packs (init))
6494 init = NULL_TREE;
6495 DECL_INITIAL (decl) = NULL_TREE;
6498 /* Generally, initializers in templates are expanded when the
6499 template is instantiated. But, if DECL is a variable constant
6500 then it can be used in future constant expressions, so its value
6501 must be available. */
6503 if (!VAR_P (decl) || dependent_type_p (type))
6504 /* We can't do anything if the decl has dependent type. */;
6505 else if (init
6506 && init_const_expr_p
6507 && !type_dependent_p
6508 && TREE_CODE (type) != REFERENCE_TYPE
6509 && decl_maybe_constant_var_p (decl)
6510 && !type_dependent_init_p (init)
6511 && !value_dependent_init_p (init))
6513 /* This variable seems to be a non-dependent constant, so process
6514 its initializer. If check_initializer returns non-null the
6515 initialization wasn't constant after all. */
6516 tree init_code;
6517 cleanups = make_tree_vector ();
6518 init_code = check_initializer (decl, init, flags, &cleanups);
6519 if (init_code == NULL_TREE)
6520 init = NULL_TREE;
6521 release_tree_vector (cleanups);
6523 else if (!DECL_PRETTY_FUNCTION_P (decl))
6525 /* Deduce array size even if the initializer is dependent. */
6526 maybe_deduce_size_from_array_init (decl, init);
6527 /* And complain about multiple initializers. */
6528 if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init)
6529 && !MAYBE_CLASS_TYPE_P (type))
6530 init = build_x_compound_expr_from_list (init, ELK_INIT,
6531 tf_warning_or_error);
6534 if (init)
6535 DECL_INITIAL (decl) = init;
6536 return;
6539 /* Just store non-static data member initializers for later. */
6540 if (init && TREE_CODE (decl) == FIELD_DECL)
6541 DECL_INITIAL (decl) = init;
6543 /* Take care of TYPE_DECLs up front. */
6544 if (TREE_CODE (decl) == TYPE_DECL)
6546 if (type != error_mark_node
6547 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
6549 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6550 warning (0, "shadowing previous type declaration of %q#D", decl);
6551 set_identifier_type_value (DECL_NAME (decl), decl);
6554 /* If we have installed this as the canonical typedef for this
6555 type, and that type has not been defined yet, delay emitting
6556 the debug information for it, as we will emit it later. */
6557 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
6558 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
6559 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6561 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl),
6562 at_eof);
6563 return;
6566 /* A reference will be modified here, as it is initialized. */
6567 if (! DECL_EXTERNAL (decl)
6568 && TREE_READONLY (decl)
6569 && TREE_CODE (type) == REFERENCE_TYPE)
6571 was_readonly = 1;
6572 TREE_READONLY (decl) = 0;
6575 if (VAR_P (decl))
6577 /* If this is a local variable that will need a mangled name,
6578 register it now. We must do this before processing the
6579 initializer for the variable, since the initialization might
6580 require a guard variable, and since the mangled name of the
6581 guard variable will depend on the mangled name of this
6582 variable. */
6583 if (DECL_FUNCTION_SCOPE_P (decl)
6584 && TREE_STATIC (decl)
6585 && !DECL_ARTIFICIAL (decl))
6587 push_local_name (decl);
6588 if (DECL_CONSTRUCTOR_P (current_function_decl)
6589 || DECL_DESTRUCTOR_P (current_function_decl))
6590 /* Normally local_decls is populated during GIMPLE lowering,
6591 but [cd]tors are never actually compiled directly. We need
6592 to put statics on the list so we can deal with the label
6593 address extension. FIXME. */
6594 add_local_decl (cfun, decl);
6597 /* Convert the initializer to the type of DECL, if we have not
6598 already initialized DECL. */
6599 if (!DECL_INITIALIZED_P (decl)
6600 /* If !DECL_EXTERNAL then DECL is being defined. In the
6601 case of a static data member initialized inside the
6602 class-specifier, there can be an initializer even if DECL
6603 is *not* defined. */
6604 && (!DECL_EXTERNAL (decl) || init))
6606 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6608 tree jclass
6609 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6610 /* Allow libjava/prims.cc define primitive classes. */
6611 if (init != NULL_TREE
6612 || jclass == NULL_TREE
6613 || TREE_CODE (jclass) != TYPE_DECL
6614 || !POINTER_TYPE_P (TREE_TYPE (jclass))
6615 || !same_type_ignoring_top_level_qualifiers_p
6616 (type, TREE_TYPE (TREE_TYPE (jclass))))
6617 error ("Java object %qD not allocated with %<new%>", decl);
6618 init = NULL_TREE;
6620 cleanups = make_tree_vector ();
6621 init = check_initializer (decl, init, flags, &cleanups);
6623 /* Handle:
6625 [dcl.init]
6627 The memory occupied by any object of static storage
6628 duration is zero-initialized at program startup before
6629 any other initialization takes place.
6631 We cannot create an appropriate initializer until after
6632 the type of DECL is finalized. If DECL_INITIAL is set,
6633 then the DECL is statically initialized, and any
6634 necessary zero-initialization has already been performed. */
6635 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
6636 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
6637 /*nelts=*/NULL_TREE,
6638 /*static_storage_p=*/true);
6639 /* Remember that the initialization for this variable has
6640 taken place. */
6641 DECL_INITIALIZED_P (decl) = 1;
6642 /* This declaration is the definition of this variable,
6643 unless we are initializing a static data member within
6644 the class specifier. */
6645 if (!DECL_EXTERNAL (decl))
6646 var_definition_p = true;
6648 /* If the variable has an array type, lay out the type, even if
6649 there is no initializer. It is valid to index through the
6650 array, and we must get TYPE_ALIGN set correctly on the array
6651 type. */
6652 else if (TREE_CODE (type) == ARRAY_TYPE)
6653 layout_type (type);
6655 if (TREE_STATIC (decl)
6656 && !at_function_scope_p ()
6657 && current_function_decl == NULL)
6658 /* So decl is a global variable or a static member of a
6659 non local class. Record the types it uses
6660 so that we can decide later to emit debug info for them. */
6661 record_types_used_by_current_var_decl (decl);
6663 else if (TREE_CODE (decl) == FIELD_DECL
6664 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6665 error ("non-static data member %qD has Java class type", decl);
6667 /* Add this declaration to the statement-tree. This needs to happen
6668 after the call to check_initializer so that the DECL_EXPR for a
6669 reference temp is added before the DECL_EXPR for the reference itself. */
6670 if (DECL_FUNCTION_SCOPE_P (decl))
6672 /* If we're building a variable sized type, and we might be
6673 reachable other than via the top of the current binding
6674 level, then create a new BIND_EXPR so that we deallocate
6675 the object at the right time. */
6676 if (VAR_P (decl)
6677 && DECL_SIZE (decl)
6678 && !TREE_CONSTANT (DECL_SIZE (decl))
6679 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
6681 tree bind;
6682 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
6683 TREE_SIDE_EFFECTS (bind) = 1;
6684 add_stmt (bind);
6685 BIND_EXPR_BODY (bind) = push_stmt_list ();
6687 add_decl_expr (decl);
6690 /* Let the middle end know about variables and functions -- but not
6691 static data members in uninstantiated class templates. */
6692 if (VAR_OR_FUNCTION_DECL_P (decl))
6694 if (VAR_P (decl))
6696 layout_var_decl (decl);
6697 maybe_commonize_var (decl);
6700 /* This needs to happen after the linkage is set. */
6701 determine_visibility (decl);
6703 if (var_definition_p && TREE_STATIC (decl))
6705 /* If a TREE_READONLY variable needs initialization
6706 at runtime, it is no longer readonly and we need to
6707 avoid MEM_READONLY_P being set on RTL created for it. */
6708 if (init)
6710 if (TREE_READONLY (decl))
6711 TREE_READONLY (decl) = 0;
6712 was_readonly = 0;
6714 else if (was_readonly)
6715 TREE_READONLY (decl) = 1;
6717 /* Likewise if it needs destruction. */
6718 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6719 TREE_READONLY (decl) = 0;
6722 make_rtl_for_nonlocal_decl (decl, init, asmspec);
6724 /* Check for abstractness of the type. Notice that there is no
6725 need to strip array types here since the check for those types
6726 is already done within create_array_type_for_decl. */
6727 abstract_virtuals_error (decl, type);
6729 if (TREE_TYPE (decl) == error_mark_node)
6730 /* No initialization required. */
6732 else if (TREE_CODE (decl) == FUNCTION_DECL)
6734 if (init)
6736 if (init == ridpointers[(int)RID_DEFAULT])
6738 /* An out-of-class default definition is defined at
6739 the point where it is explicitly defaulted. */
6740 if (DECL_DELETED_FN (decl))
6741 maybe_explain_implicit_delete (decl);
6742 else if (DECL_INITIAL (decl) == error_mark_node)
6743 synthesize_method (decl);
6745 else
6746 error ("function %q#D is initialized like a variable", decl);
6748 /* else no initialization required. */
6750 else if (DECL_EXTERNAL (decl)
6751 && ! (DECL_LANG_SPECIFIC (decl)
6752 && DECL_NOT_REALLY_EXTERN (decl)))
6754 if (init)
6755 DECL_INITIAL (decl) = init;
6757 /* A variable definition. */
6758 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6759 /* Initialize the local variable. */
6760 initialize_local_var (decl, init);
6762 /* If a variable is defined, and then a subsequent
6763 definition with external linkage is encountered, we will
6764 get here twice for the same variable. We want to avoid
6765 calling expand_static_init more than once. For variables
6766 that are not static data members, we can call
6767 expand_static_init only when we actually process the
6768 initializer. It is not legal to redeclare a static data
6769 member, so this issue does not arise in that case. */
6770 else if (var_definition_p && TREE_STATIC (decl))
6771 expand_static_init (decl, init);
6774 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6775 reference, insert it in the statement-tree now. */
6776 if (cleanups)
6778 unsigned i; tree t;
6779 FOR_EACH_VEC_ELT (*cleanups, i, t)
6780 push_cleanup (decl, t, false);
6781 release_tree_vector (cleanups);
6784 if (was_readonly)
6785 TREE_READONLY (decl) = 1;
6787 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
6790 /* Returns a declaration for a VAR_DECL as if:
6792 extern "C" TYPE NAME;
6794 had been seen. Used to create compiler-generated global
6795 variables. */
6797 static tree
6798 declare_global_var (tree name, tree type)
6800 tree decl;
6802 push_to_top_level ();
6803 decl = build_decl (input_location, VAR_DECL, name, type);
6804 TREE_PUBLIC (decl) = 1;
6805 DECL_EXTERNAL (decl) = 1;
6806 DECL_ARTIFICIAL (decl) = 1;
6807 /* If the user has explicitly declared this variable (perhaps
6808 because the code we are compiling is part of a low-level runtime
6809 library), then it is possible that our declaration will be merged
6810 with theirs by pushdecl. */
6811 decl = pushdecl (decl);
6812 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
6813 pop_from_top_level ();
6815 return decl;
6818 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6819 if "__cxa_atexit" is not being used) corresponding to the function
6820 to be called when the program exits. */
6822 static tree
6823 get_atexit_fn_ptr_type (void)
6825 tree fn_type;
6827 if (!atexit_fn_ptr_type_node)
6829 tree arg_type;
6830 if (flag_use_cxa_atexit
6831 && !targetm.cxx.use_atexit_for_cxa_atexit ())
6832 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6833 arg_type = ptr_type_node;
6834 else
6835 /* The parameter to "atexit" is "void (*)(void)". */
6836 arg_type = NULL_TREE;
6838 fn_type = build_function_type_list (void_type_node,
6839 arg_type, NULL_TREE);
6840 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
6843 return atexit_fn_ptr_type_node;
6846 /* Returns a pointer to the `atexit' function. Note that if
6847 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6848 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6850 static tree
6851 get_atexit_node (void)
6853 tree atexit_fndecl;
6854 tree fn_type;
6855 tree fn_ptr_type;
6856 const char *name;
6857 bool use_aeabi_atexit;
6859 if (atexit_node)
6860 return atexit_node;
6862 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6864 /* The declaration for `__cxa_atexit' is:
6866 int __cxa_atexit (void (*)(void *), void *, void *)
6868 We build up the argument types and then the function type
6869 itself. */
6870 tree argtype0, argtype1, argtype2;
6872 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
6873 /* First, build the pointer-to-function type for the first
6874 argument. */
6875 fn_ptr_type = get_atexit_fn_ptr_type ();
6876 /* Then, build the rest of the argument types. */
6877 argtype2 = ptr_type_node;
6878 if (use_aeabi_atexit)
6880 argtype1 = fn_ptr_type;
6881 argtype0 = ptr_type_node;
6883 else
6885 argtype1 = ptr_type_node;
6886 argtype0 = fn_ptr_type;
6888 /* And the final __cxa_atexit type. */
6889 fn_type = build_function_type_list (integer_type_node,
6890 argtype0, argtype1, argtype2,
6891 NULL_TREE);
6892 if (use_aeabi_atexit)
6893 name = "__aeabi_atexit";
6894 else
6895 name = "__cxa_atexit";
6897 else
6899 /* The declaration for `atexit' is:
6901 int atexit (void (*)());
6903 We build up the argument types and then the function type
6904 itself. */
6905 fn_ptr_type = get_atexit_fn_ptr_type ();
6906 /* Build the final atexit type. */
6907 fn_type = build_function_type_list (integer_type_node,
6908 fn_ptr_type, NULL_TREE);
6909 name = "atexit";
6912 /* Now, build the function declaration. */
6913 push_lang_context (lang_name_c);
6914 atexit_fndecl = build_library_fn_ptr (name, fn_type, ECF_LEAF | ECF_NOTHROW);
6915 mark_used (atexit_fndecl);
6916 pop_lang_context ();
6917 atexit_node = decay_conversion (atexit_fndecl, tf_warning_or_error);
6919 return atexit_node;
6922 /* Like get_atexit_node, but for thread-local cleanups. */
6924 static tree
6925 get_thread_atexit_node (void)
6927 /* The declaration for `__cxa_thread_atexit' is:
6929 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6930 tree fn_type = build_function_type_list (integer_type_node,
6931 get_atexit_fn_ptr_type (),
6932 ptr_type_node, ptr_type_node,
6933 NULL_TREE);
6935 /* Now, build the function declaration. */
6936 tree atexit_fndecl = build_library_fn_ptr ("__cxa_thread_atexit", fn_type,
6937 ECF_LEAF | ECF_NOTHROW);
6938 return decay_conversion (atexit_fndecl, tf_warning_or_error);
6941 /* Returns the __dso_handle VAR_DECL. */
6943 static tree
6944 get_dso_handle_node (void)
6946 if (dso_handle_node)
6947 return dso_handle_node;
6949 /* Declare the variable. */
6950 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6951 ptr_type_node);
6953 #ifdef HAVE_GAS_HIDDEN
6954 if (dso_handle_node != error_mark_node)
6956 DECL_VISIBILITY (dso_handle_node) = VISIBILITY_HIDDEN;
6957 DECL_VISIBILITY_SPECIFIED (dso_handle_node) = 1;
6959 #endif
6961 return dso_handle_node;
6964 /* Begin a new function with internal linkage whose job will be simply
6965 to destroy some particular variable. */
6967 static GTY(()) int start_cleanup_cnt;
6969 static tree
6970 start_cleanup_fn (void)
6972 char name[32];
6973 tree fntype;
6974 tree fndecl;
6975 bool use_cxa_atexit = flag_use_cxa_atexit
6976 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6978 push_to_top_level ();
6980 /* No need to mangle this. */
6981 push_lang_context (lang_name_c);
6983 /* Build the name of the function. */
6984 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6985 /* Build the function declaration. */
6986 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6987 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6988 /* It's a function with internal linkage, generated by the
6989 compiler. */
6990 TREE_PUBLIC (fndecl) = 0;
6991 DECL_ARTIFICIAL (fndecl) = 1;
6992 /* Make the function `inline' so that it is only emitted if it is
6993 actually needed. It is unlikely that it will be inlined, since
6994 it is only called via a function pointer, but we avoid unnecessary
6995 emissions this way. */
6996 DECL_DECLARED_INLINE_P (fndecl) = 1;
6997 DECL_INTERFACE_KNOWN (fndecl) = 1;
6998 /* Build the parameter. */
6999 if (use_cxa_atexit)
7001 tree parmdecl;
7003 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
7004 DECL_CONTEXT (parmdecl) = fndecl;
7005 TREE_USED (parmdecl) = 1;
7006 DECL_READ_P (parmdecl) = 1;
7007 DECL_ARGUMENTS (fndecl) = parmdecl;
7010 pushdecl (fndecl);
7011 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
7013 pop_lang_context ();
7015 return current_function_decl;
7018 /* Finish the cleanup function begun by start_cleanup_fn. */
7020 static void
7021 end_cleanup_fn (void)
7023 expand_or_defer_fn (finish_function (0));
7025 pop_from_top_level ();
7028 /* Generate code to handle the destruction of DECL, an object with
7029 static storage duration. */
7031 tree
7032 register_dtor_fn (tree decl)
7034 tree cleanup;
7035 tree addr;
7036 tree compound_stmt;
7037 tree fcall;
7038 tree type;
7039 bool ob_parm, dso_parm, use_dtor;
7040 tree arg0, arg1, arg2;
7041 tree atex_node;
7043 type = TREE_TYPE (decl);
7044 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7045 return void_node;
7047 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7048 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7049 destructor to "__cxa_atexit"; we don't have to build a temporary
7050 function to do the cleanup. */
7051 dso_parm = (flag_use_cxa_atexit
7052 && !targetm.cxx.use_atexit_for_cxa_atexit ());
7053 ob_parm = (DECL_THREAD_LOCAL_P (decl) || dso_parm);
7054 use_dtor = ob_parm && CLASS_TYPE_P (type);
7055 if (use_dtor)
7057 int idx;
7059 /* Find the destructor. */
7060 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
7061 gcc_assert (idx >= 0);
7062 cleanup = (*CLASSTYPE_METHOD_VEC (type))[idx];
7063 /* Make sure it is accessible. */
7064 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup,
7065 tf_warning_or_error);
7067 else
7069 /* Call build_cleanup before we enter the anonymous function so
7070 that any access checks will be done relative to the current
7071 scope, rather than the scope of the anonymous function. */
7072 build_cleanup (decl);
7074 /* Now start the function. */
7075 cleanup = start_cleanup_fn ();
7077 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7078 to the original function, rather than the anonymous one. That
7079 will make the back end think that nested functions are in use,
7080 which causes confusion. */
7081 push_deferring_access_checks (dk_no_check);
7082 fcall = build_cleanup (decl);
7083 pop_deferring_access_checks ();
7085 /* Create the body of the anonymous function. */
7086 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
7087 finish_expr_stmt (fcall);
7088 finish_compound_stmt (compound_stmt);
7089 end_cleanup_fn ();
7092 /* Call atexit with the cleanup function. */
7093 mark_used (cleanup);
7094 cleanup = build_address (cleanup);
7096 if (DECL_THREAD_LOCAL_P (decl))
7097 atex_node = get_thread_atexit_node ();
7098 else
7099 atex_node = get_atexit_node ();
7101 if (use_dtor)
7103 /* We must convert CLEANUP to the type that "__cxa_atexit"
7104 expects. */
7105 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
7106 /* "__cxa_atexit" will pass the address of DECL to the
7107 cleanup function. */
7108 mark_used (decl);
7109 addr = build_address (decl);
7110 /* The declared type of the parameter to "__cxa_atexit" is
7111 "void *". For plain "T*", we could just let the
7112 machinery in cp_build_function_call convert it -- but if the
7113 type is "cv-qualified T *", then we need to convert it
7114 before passing it in, to avoid spurious errors. */
7115 addr = build_nop (ptr_type_node, addr);
7117 else
7118 /* Since the cleanup functions we build ignore the address
7119 they're given, there's no reason to pass the actual address
7120 in, and, in general, it's cheaper to pass NULL than any
7121 other value. */
7122 addr = null_pointer_node;
7124 if (dso_parm)
7125 arg2 = cp_build_addr_expr (get_dso_handle_node (),
7126 tf_warning_or_error);
7127 else if (ob_parm)
7128 /* Just pass NULL to the dso handle parm if we don't actually
7129 have a DSO handle on this target. */
7130 arg2 = null_pointer_node;
7131 else
7132 arg2 = NULL_TREE;
7134 if (ob_parm)
7136 if (!DECL_THREAD_LOCAL_P (decl)
7137 && targetm.cxx.use_aeabi_atexit ())
7139 arg1 = cleanup;
7140 arg0 = addr;
7142 else
7144 arg1 = addr;
7145 arg0 = cleanup;
7148 else
7150 arg0 = cleanup;
7151 arg1 = NULL_TREE;
7153 return cp_build_function_call_nary (atex_node, tf_warning_or_error,
7154 arg0, arg1, arg2, NULL_TREE);
7157 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7158 is its initializer. Generate code to handle the construction
7159 and destruction of DECL. */
7161 static void
7162 expand_static_init (tree decl, tree init)
7164 gcc_assert (VAR_P (decl));
7165 gcc_assert (TREE_STATIC (decl));
7167 /* Some variables require no dynamic initialization. */
7168 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
7170 /* Make sure the destructor is callable. */
7171 cxx_maybe_build_cleanup (decl, tf_warning_or_error);
7172 if (!init)
7173 return;
7176 if (DECL_THREAD_LOCAL_P (decl) && DECL_GNU_TLS_P (decl)
7177 && !DECL_FUNCTION_SCOPE_P (decl))
7179 if (init)
7180 error ("non-local variable %qD declared %<__thread%> "
7181 "needs dynamic initialization", decl);
7182 else
7183 error ("non-local variable %qD declared %<__thread%> "
7184 "has a non-trivial destructor", decl);
7185 static bool informed;
7186 if (!informed)
7188 inform (DECL_SOURCE_LOCATION (decl),
7189 "C++11 %<thread_local%> allows dynamic initialization "
7190 "and destruction");
7191 informed = true;
7193 return;
7196 if (DECL_FUNCTION_SCOPE_P (decl))
7198 /* Emit code to perform this initialization but once. */
7199 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
7200 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
7201 tree guard, guard_addr;
7202 tree flag, begin;
7203 /* We don't need thread-safety code for thread-local vars. */
7204 bool thread_guard = (flag_threadsafe_statics
7205 && !DECL_THREAD_LOCAL_P (decl));
7207 /* Emit code to perform this initialization but once. This code
7208 looks like:
7210 static <type> guard;
7211 if (!__atomic_load (guard.first_byte)) {
7212 if (__cxa_guard_acquire (&guard)) {
7213 bool flag = false;
7214 try {
7215 // Do initialization.
7216 flag = true; __cxa_guard_release (&guard);
7217 // Register variable for destruction at end of program.
7218 } catch {
7219 if (!flag) __cxa_guard_abort (&guard);
7223 Note that the `flag' variable is only set to 1 *after* the
7224 initialization is complete. This ensures that an exception,
7225 thrown during the construction, will cause the variable to
7226 reinitialized when we pass through this code again, as per:
7228 [stmt.dcl]
7230 If the initialization exits by throwing an exception, the
7231 initialization is not complete, so it will be tried again
7232 the next time control enters the declaration.
7234 This process should be thread-safe, too; multiple threads
7235 should not be able to initialize the variable more than
7236 once. */
7238 /* Create the guard variable. */
7239 guard = get_guard (decl);
7241 /* Begin the conditional initialization. */
7242 if_stmt = begin_if_stmt ();
7244 finish_if_stmt_cond (get_guard_cond (guard, thread_guard), if_stmt);
7245 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
7247 if (thread_guard)
7249 tree vfntype = NULL_TREE;
7250 tree acquire_name, release_name, abort_name;
7251 tree acquire_fn, release_fn, abort_fn;
7252 guard_addr = build_address (guard);
7254 acquire_name = get_identifier ("__cxa_guard_acquire");
7255 release_name = get_identifier ("__cxa_guard_release");
7256 abort_name = get_identifier ("__cxa_guard_abort");
7257 acquire_fn = identifier_global_value (acquire_name);
7258 release_fn = identifier_global_value (release_name);
7259 abort_fn = identifier_global_value (abort_name);
7260 if (!acquire_fn)
7261 acquire_fn = push_library_fn
7262 (acquire_name, build_function_type_list (integer_type_node,
7263 TREE_TYPE (guard_addr),
7264 NULL_TREE),
7265 NULL_TREE, ECF_NOTHROW | ECF_LEAF);
7266 if (!release_fn || !abort_fn)
7267 vfntype = build_function_type_list (void_type_node,
7268 TREE_TYPE (guard_addr),
7269 NULL_TREE);
7270 if (!release_fn)
7271 release_fn = push_library_fn (release_name, vfntype, NULL_TREE,
7272 ECF_NOTHROW | ECF_LEAF);
7273 if (!abort_fn)
7274 abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE,
7275 ECF_NOTHROW | ECF_LEAF);
7277 inner_if_stmt = begin_if_stmt ();
7278 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
7279 inner_if_stmt);
7281 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
7282 begin = get_target_expr (boolean_false_node);
7283 flag = TARGET_EXPR_SLOT (begin);
7285 TARGET_EXPR_CLEANUP (begin)
7286 = build3 (COND_EXPR, void_type_node, flag,
7287 void_node,
7288 build_call_n (abort_fn, 1, guard_addr));
7289 CLEANUP_EH_ONLY (begin) = 1;
7291 /* Do the initialization itself. */
7292 init = add_stmt_to_compound (begin, init);
7293 init = add_stmt_to_compound
7294 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
7295 init = add_stmt_to_compound
7296 (init, build_call_n (release_fn, 1, guard_addr));
7298 else
7299 init = add_stmt_to_compound (init, set_guard (guard));
7301 /* Use atexit to register a function for destroying this static
7302 variable. */
7303 init = add_stmt_to_compound (init, register_dtor_fn (decl));
7305 finish_expr_stmt (init);
7307 if (thread_guard)
7309 finish_compound_stmt (inner_then_clause);
7310 finish_then_clause (inner_if_stmt);
7311 finish_if_stmt (inner_if_stmt);
7314 finish_compound_stmt (then_clause);
7315 finish_then_clause (if_stmt);
7316 finish_if_stmt (if_stmt);
7318 else if (DECL_THREAD_LOCAL_P (decl))
7319 tls_aggregates = tree_cons (init, decl, tls_aggregates);
7320 else
7321 static_aggregates = tree_cons (init, decl, static_aggregates);
7325 /* Make TYPE a complete type based on INITIAL_VALUE.
7326 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7327 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7328 3 if the initializer list is empty (in pedantic mode). */
7331 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
7333 int failure;
7334 tree type, elt_type;
7336 /* Don't get confused by a CONSTRUCTOR for some other type. */
7337 if (initial_value && TREE_CODE (initial_value) == CONSTRUCTOR
7338 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value))
7339 return 1;
7341 if (initial_value)
7343 unsigned HOST_WIDE_INT i;
7344 tree value;
7346 /* An array of character type can be initialized from a
7347 brace-enclosed string constant.
7349 FIXME: this code is duplicated from reshape_init. Probably
7350 we should just call reshape_init here? */
7351 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
7352 && TREE_CODE (initial_value) == CONSTRUCTOR
7353 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value)))
7355 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value);
7356 tree value = (*v)[0].value;
7358 if (TREE_CODE (value) == STRING_CST
7359 && v->length () == 1)
7360 initial_value = value;
7363 /* If any of the elements are parameter packs, we can't actually
7364 complete this type now because the array size is dependent. */
7365 if (TREE_CODE (initial_value) == CONSTRUCTOR)
7367 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
7368 i, value)
7370 if (PACK_EXPANSION_P (value))
7371 return 0;
7376 failure = complete_array_type (ptype, initial_value, do_default);
7378 /* We can create the array before the element type is complete, which
7379 means that we didn't have these two bits set in the original type
7380 either. In completing the type, we are expected to propagate these
7381 bits. See also complete_type which does the same thing for arrays
7382 of fixed size. */
7383 type = *ptype;
7384 if (TYPE_DOMAIN (type))
7386 elt_type = TREE_TYPE (type);
7387 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
7388 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7389 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
7392 return failure;
7395 /* As above, but either give an error or reject zero-size arrays, depending
7396 on COMPLAIN. */
7399 cp_complete_array_type_or_error (tree *ptype, tree initial_value,
7400 bool do_default, tsubst_flags_t complain)
7402 int failure;
7403 bool sfinae = !(complain & tf_error);
7404 /* In SFINAE context we can't be lenient about zero-size arrays. */
7405 if (sfinae)
7406 ++pedantic;
7407 failure = cp_complete_array_type (ptype, initial_value, do_default);
7408 if (sfinae)
7409 --pedantic;
7410 if (failure)
7412 if (sfinae)
7413 /* Not an error. */;
7414 else if (failure == 1)
7415 error ("initializer fails to determine size of %qT", *ptype);
7416 else if (failure == 2)
7418 if (do_default)
7419 error ("array size missing in %qT", *ptype);
7421 else if (failure == 3)
7422 error ("zero-size array %qT", *ptype);
7423 *ptype = error_mark_node;
7425 return failure;
7428 /* Return zero if something is declared to be a member of type
7429 CTYPE when in the context of CUR_TYPE. STRING is the error
7430 message to print in that case. Otherwise, quietly return 1. */
7432 static int
7433 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
7435 if (ctype && ctype != cur_type)
7437 if (flags == DTOR_FLAG)
7438 error ("destructor for alien class %qT cannot be a member", ctype);
7439 else
7440 error ("constructor for alien class %qT cannot be a member", ctype);
7441 return 0;
7443 return 1;
7446 /* Subroutine of `grokdeclarator'. */
7448 /* Generate errors possibly applicable for a given set of specifiers.
7449 This is for ARM $7.1.2. */
7451 static void
7452 bad_specifiers (tree object,
7453 enum bad_spec_place type,
7454 int virtualp,
7455 int quals,
7456 int inlinep,
7457 int friendp,
7458 int raises)
7460 switch (type)
7462 case BSP_VAR:
7463 if (virtualp)
7464 error ("%qD declared as a %<virtual%> variable", object);
7465 if (inlinep)
7466 error ("%qD declared as an %<inline%> variable", object);
7467 if (quals)
7468 error ("%<const%> and %<volatile%> function specifiers on "
7469 "%qD invalid in variable declaration", object);
7470 break;
7471 case BSP_PARM:
7472 if (virtualp)
7473 error ("%qD declared as a %<virtual%> parameter", object);
7474 if (inlinep)
7475 error ("%qD declared as an %<inline%> parameter", object);
7476 if (quals)
7477 error ("%<const%> and %<volatile%> function specifiers on "
7478 "%qD invalid in parameter declaration", object);
7479 break;
7480 case BSP_TYPE:
7481 if (virtualp)
7482 error ("%qD declared as a %<virtual%> type", object);
7483 if (inlinep)
7484 error ("%qD declared as an %<inline%> type", object);
7485 if (quals)
7486 error ("%<const%> and %<volatile%> function specifiers on "
7487 "%qD invalid in type declaration", object);
7488 break;
7489 case BSP_FIELD:
7490 if (virtualp)
7491 error ("%qD declared as a %<virtual%> field", object);
7492 if (inlinep)
7493 error ("%qD declared as an %<inline%> field", object);
7494 if (quals)
7495 error ("%<const%> and %<volatile%> function specifiers on "
7496 "%qD invalid in field declaration", object);
7497 break;
7498 default:
7499 gcc_unreachable();
7501 if (friendp)
7502 error ("%q+D declared as a friend", object);
7503 if (raises
7504 && (TREE_CODE (object) == TYPE_DECL
7505 || (!TYPE_PTRFN_P (TREE_TYPE (object))
7506 && !TYPE_REFFN_P (TREE_TYPE (object))
7507 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
7508 error ("%q+D declared with an exception specification", object);
7511 /* DECL is a member function or static data member and is presently
7512 being defined. Check that the definition is taking place in a
7513 valid namespace. */
7515 static void
7516 check_class_member_definition_namespace (tree decl)
7518 /* These checks only apply to member functions and static data
7519 members. */
7520 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
7521 /* We check for problems with specializations in pt.c in
7522 check_specialization_namespace, where we can issue better
7523 diagnostics. */
7524 if (processing_specialization)
7525 return;
7526 /* There are no restrictions on the placement of
7527 explicit instantiations. */
7528 if (processing_explicit_instantiation)
7529 return;
7530 /* [class.mfct]
7532 A member function definition that appears outside of the
7533 class definition shall appear in a namespace scope enclosing
7534 the class definition.
7536 [class.static.data]
7538 The definition for a static data member shall appear in a
7539 namespace scope enclosing the member's class definition. */
7540 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
7541 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
7542 decl, DECL_CONTEXT (decl));
7545 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7546 METHOD_TYPE for a non-static member function; QUALS are the
7547 cv-qualifiers that apply to the function. */
7549 tree
7550 build_this_parm (tree type, cp_cv_quals quals)
7552 tree this_type;
7553 tree qual_type;
7554 tree parm;
7555 cp_cv_quals this_quals;
7557 if (CLASS_TYPE_P (type))
7559 this_type
7560 = cp_build_qualified_type (type, quals & ~TYPE_QUAL_RESTRICT);
7561 this_type = build_pointer_type (this_type);
7563 else
7564 this_type = type_of_this_parm (type);
7565 /* The `this' parameter is implicitly `const'; it cannot be
7566 assigned to. */
7567 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
7568 qual_type = cp_build_qualified_type (this_type, this_quals);
7569 parm = build_artificial_parm (this_identifier, qual_type);
7570 cp_apply_type_quals_to_decl (this_quals, parm);
7571 return parm;
7574 /* DECL is a static member function. Complain if it was declared
7575 with function-cv-quals. */
7577 static void
7578 check_static_quals (tree decl, cp_cv_quals quals)
7580 if (quals != TYPE_UNQUALIFIED)
7581 error ("static member function %q#D declared with type qualifiers",
7582 decl);
7585 /* Helper function. Replace the temporary this parameter injected
7586 during cp_finish_omp_declare_simd with the real this parameter. */
7588 static tree
7589 declare_simd_adjust_this (tree *tp, int *walk_subtrees, void *data)
7591 tree this_parm = (tree) data;
7592 if (TREE_CODE (*tp) == PARM_DECL
7593 && DECL_NAME (*tp) == this_identifier
7594 && *tp != this_parm)
7595 *tp = this_parm;
7596 else if (TYPE_P (*tp))
7597 *walk_subtrees = 0;
7598 return NULL_TREE;
7601 /* CTYPE is class type, or null if non-class.
7602 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7603 or METHOD_TYPE.
7604 DECLARATOR is the function's name.
7605 PARMS is a chain of PARM_DECLs for the function.
7606 VIRTUALP is truthvalue of whether the function is virtual or not.
7607 FLAGS are to be passed through to `grokclassfn'.
7608 QUALS are qualifiers indicating whether the function is `const'
7609 or `volatile'.
7610 RAISES is a list of exceptions that this function can raise.
7611 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7612 not look, and -1 if we should not call `grokclassfn' at all.
7614 SFK is the kind of special function (if any) for the new function.
7616 Returns `NULL_TREE' if something goes wrong, after issuing
7617 applicable error messages. */
7619 static tree
7620 grokfndecl (tree ctype,
7621 tree type,
7622 tree declarator,
7623 tree parms,
7624 tree orig_declarator,
7625 int virtualp,
7626 enum overload_flags flags,
7627 cp_cv_quals quals,
7628 cp_ref_qualifier rqual,
7629 tree raises,
7630 int check,
7631 int friendp,
7632 int publicp,
7633 int inlinep,
7634 bool deletedp,
7635 special_function_kind sfk,
7636 bool funcdef_flag,
7637 int template_count,
7638 tree in_namespace,
7639 tree* attrlist,
7640 location_t location)
7642 tree decl;
7643 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
7644 tree t;
7646 if (rqual)
7647 type = build_ref_qualified_type (type, rqual);
7648 if (raises)
7649 type = build_exception_variant (type, raises);
7651 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
7653 /* If we have an explicit location, use it, otherwise use whatever
7654 build_lang_decl used (probably input_location). */
7655 if (location != UNKNOWN_LOCATION)
7656 DECL_SOURCE_LOCATION (decl) = location;
7658 if (TREE_CODE (type) == METHOD_TYPE)
7660 tree parm;
7661 parm = build_this_parm (type, quals);
7662 DECL_CHAIN (parm) = parms;
7663 parms = parm;
7665 DECL_ARGUMENTS (decl) = parms;
7666 for (t = parms; t; t = DECL_CHAIN (t))
7667 DECL_CONTEXT (t) = decl;
7668 /* Propagate volatile out from type to decl. */
7669 if (TYPE_VOLATILE (type))
7670 TREE_THIS_VOLATILE (decl) = 1;
7672 /* Setup decl according to sfk. */
7673 switch (sfk)
7675 case sfk_constructor:
7676 case sfk_copy_constructor:
7677 case sfk_move_constructor:
7678 DECL_CONSTRUCTOR_P (decl) = 1;
7679 break;
7680 case sfk_destructor:
7681 DECL_DESTRUCTOR_P (decl) = 1;
7682 break;
7683 default:
7684 break;
7687 /* If pointers to member functions use the least significant bit to
7688 indicate whether a function is virtual, ensure a pointer
7689 to this function will have that bit clear. */
7690 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
7691 && TREE_CODE (type) == METHOD_TYPE
7692 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
7693 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
7695 if (friendp
7696 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7698 if (funcdef_flag)
7699 error
7700 ("defining explicit specialization %qD in friend declaration",
7701 orig_declarator);
7702 else
7704 tree fns = TREE_OPERAND (orig_declarator, 0);
7705 tree args = TREE_OPERAND (orig_declarator, 1);
7707 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7709 /* Something like `template <class T> friend void f<T>()'. */
7710 error ("invalid use of template-id %qD in declaration "
7711 "of primary template",
7712 orig_declarator);
7713 return NULL_TREE;
7717 /* A friend declaration of the form friend void f<>(). Record
7718 the information in the TEMPLATE_ID_EXPR. */
7719 SET_DECL_IMPLICIT_INSTANTIATION (decl);
7721 gcc_assert (identifier_p (fns) || TREE_CODE (fns) == OVERLOAD);
7722 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
7724 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7725 if (TREE_PURPOSE (t)
7726 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7728 error ("default arguments are not allowed in declaration "
7729 "of friend template specialization %qD",
7730 decl);
7731 return NULL_TREE;
7734 if (inlinep & 1)
7735 error ("%<inline%> is not allowed in declaration of friend "
7736 "template specialization %qD",
7737 decl);
7738 if (inlinep & 2)
7739 error ("%<constexpr%> is not allowed in declaration of friend "
7740 "template specialization %qD",
7741 decl);
7742 if (inlinep)
7743 return NULL_TREE;
7747 /* If this decl has namespace scope, set that up. */
7748 if (in_namespace)
7749 set_decl_namespace (decl, in_namespace, friendp);
7750 else if (!ctype)
7751 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
7753 /* `main' and builtins have implicit 'C' linkage. */
7754 if ((MAIN_NAME_P (declarator)
7755 || (IDENTIFIER_LENGTH (declarator) > 10
7756 && IDENTIFIER_POINTER (declarator)[0] == '_'
7757 && IDENTIFIER_POINTER (declarator)[1] == '_'
7758 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0)
7759 || (targetcm.cxx_implicit_extern_c
7760 && targetcm.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator))))
7761 && current_lang_name == lang_name_cplusplus
7762 && ctype == NULL_TREE
7763 && DECL_FILE_SCOPE_P (decl))
7764 SET_DECL_LANGUAGE (decl, lang_c);
7766 /* Should probably propagate const out from type to decl I bet (mrs). */
7767 if (staticp)
7769 DECL_STATIC_FUNCTION_P (decl) = 1;
7770 DECL_CONTEXT (decl) = ctype;
7773 if (deletedp)
7774 DECL_DELETED_FN (decl) = 1;
7776 if (ctype)
7778 DECL_CONTEXT (decl) = ctype;
7779 if (funcdef_flag)
7780 check_class_member_definition_namespace (decl);
7783 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7785 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7786 error ("cannot declare %<::main%> to be a template");
7787 if (inlinep & 1)
7788 error ("cannot declare %<::main%> to be inline");
7789 if (inlinep & 2)
7790 error ("cannot declare %<::main%> to be constexpr");
7791 if (!publicp)
7792 error ("cannot declare %<::main%> to be static");
7793 inlinep = 0;
7794 publicp = 1;
7797 /* Members of anonymous types and local classes have no linkage; make
7798 them internal. If a typedef is made later, this will be changed. */
7799 if (ctype && (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype))
7800 || decl_function_context (TYPE_MAIN_DECL (ctype))))
7801 publicp = 0;
7803 if (publicp && cxx_dialect == cxx98)
7805 /* [basic.link]: A name with no linkage (notably, the name of a class
7806 or enumeration declared in a local scope) shall not be used to
7807 declare an entity with linkage.
7809 DR 757 relaxes this restriction for C++0x. */
7810 no_linkage_error (decl);
7813 TREE_PUBLIC (decl) = publicp;
7814 if (! publicp)
7816 DECL_INTERFACE_KNOWN (decl) = 1;
7817 DECL_NOT_REALLY_EXTERN (decl) = 1;
7820 /* If the declaration was declared inline, mark it as such. */
7821 if (inlinep)
7823 DECL_DECLARED_INLINE_P (decl) = 1;
7824 if (publicp)
7825 DECL_COMDAT (decl) = 1;
7827 if (inlinep & 2)
7828 DECL_DECLARED_CONSTEXPR_P (decl) = true;
7830 DECL_EXTERNAL (decl) = 1;
7831 if (TREE_CODE (type) == FUNCTION_TYPE)
7833 if (quals)
7835 error (ctype
7836 ? G_("static member function %qD cannot have cv-qualifier")
7837 : G_("non-member function %qD cannot have cv-qualifier"),
7838 decl);
7839 quals = TYPE_UNQUALIFIED;
7842 if (rqual)
7844 error (ctype
7845 ? G_("static member function %qD cannot have ref-qualifier")
7846 : G_("non-member function %qD cannot have ref-qualifier"),
7847 decl);
7848 rqual = REF_QUAL_NONE;
7852 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
7853 && !grok_op_properties (decl, /*complain=*/true))
7854 return NULL_TREE;
7855 else if (UDLIT_OPER_P (DECL_NAME (decl)))
7857 bool long_long_unsigned_p;
7858 bool long_double_p;
7859 const char *suffix = NULL;
7860 /* [over.literal]/6: Literal operators shall not have C linkage. */
7861 if (DECL_LANGUAGE (decl) == lang_c)
7863 error ("literal operator with C linkage");
7864 return NULL_TREE;
7867 if (DECL_NAMESPACE_SCOPE_P (decl))
7869 if (!check_literal_operator_args (decl, &long_long_unsigned_p,
7870 &long_double_p))
7872 error ("%qD has invalid argument list", decl);
7873 return NULL_TREE;
7876 suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl));
7877 if (long_long_unsigned_p)
7879 if (cpp_interpret_int_suffix (parse_in, suffix, strlen (suffix)))
7880 warning (0, "integer suffix %<%s%>"
7881 " shadowed by implementation", suffix);
7883 else if (long_double_p)
7885 if (cpp_interpret_float_suffix (parse_in, suffix, strlen (suffix)))
7886 warning (0, "floating point suffix %<%s%>"
7887 " shadowed by implementation", suffix);
7890 else
7892 error ("%qD must be a non-member function", decl);
7893 return NULL_TREE;
7897 if (funcdef_flag)
7898 /* Make the init_value nonzero so pushdecl knows this is not
7899 tentative. error_mark_node is replaced later with the BLOCK. */
7900 DECL_INITIAL (decl) = error_mark_node;
7902 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
7903 TREE_NOTHROW (decl) = 1;
7905 if (flag_openmp || flag_cilkplus)
7907 /* Adjust "omp declare simd" attributes. */
7908 tree ods = lookup_attribute ("omp declare simd", *attrlist);
7909 if (ods)
7911 tree attr;
7912 for (attr = ods; attr;
7913 attr = lookup_attribute ("omp declare simd", TREE_CHAIN (attr)))
7915 if (TREE_CODE (type) == METHOD_TYPE)
7916 walk_tree (&TREE_VALUE (attr), declare_simd_adjust_this,
7917 DECL_ARGUMENTS (decl), NULL);
7918 if (TREE_VALUE (attr) != NULL_TREE)
7920 tree cl = TREE_VALUE (TREE_VALUE (attr));
7921 cl = c_omp_declare_simd_clauses_to_numbers
7922 (DECL_ARGUMENTS (decl), cl);
7923 if (cl)
7924 TREE_VALUE (TREE_VALUE (attr)) = cl;
7925 else
7926 TREE_VALUE (attr) = NULL_TREE;
7932 /* Caller will do the rest of this. */
7933 if (check < 0)
7934 return decl;
7936 if (ctype != NULL_TREE)
7937 grokclassfn (ctype, decl, flags);
7939 /* 12.4/3 */
7940 if (cxx_dialect >= cxx11
7941 && DECL_DESTRUCTOR_P (decl)
7942 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl))
7943 && !processing_template_decl)
7944 deduce_noexcept_on_destructor (decl);
7946 decl = check_explicit_specialization (orig_declarator, decl,
7947 template_count,
7948 2 * funcdef_flag +
7949 4 * (friendp != 0));
7950 if (decl == error_mark_node)
7951 return NULL_TREE;
7953 if (DECL_STATIC_FUNCTION_P (decl))
7954 check_static_quals (decl, quals);
7956 if (attrlist)
7958 cplus_decl_attributes (&decl, *attrlist, 0);
7959 *attrlist = NULL_TREE;
7962 /* Check main's type after attributes have been applied. */
7963 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7965 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
7966 integer_type_node))
7968 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
7969 tree newtype;
7970 error ("%<::main%> must return %<int%>");
7971 newtype = build_function_type (integer_type_node, oldtypeargs);
7972 TREE_TYPE (decl) = newtype;
7974 if (warn_main)
7975 check_main_parameter_types (decl);
7978 if (ctype != NULL_TREE
7979 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
7980 && check)
7982 tree old_decl = check_classfn (ctype, decl,
7983 (processing_template_decl
7984 > template_class_depth (ctype))
7985 ? current_template_parms
7986 : NULL_TREE);
7988 if (old_decl == error_mark_node)
7989 return NULL_TREE;
7991 if (old_decl)
7993 tree ok;
7994 tree pushed_scope;
7996 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
7997 /* Because grokfndecl is always supposed to return a
7998 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7999 here. We depend on our callers to figure out that its
8000 really a template that's being returned. */
8001 old_decl = DECL_TEMPLATE_RESULT (old_decl);
8003 if (DECL_STATIC_FUNCTION_P (old_decl)
8004 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
8006 /* Remove the `this' parm added by grokclassfn. */
8007 revert_static_member_fn (decl);
8008 check_static_quals (decl, quals);
8010 if (DECL_ARTIFICIAL (old_decl))
8012 error ("definition of implicitly-declared %qD", old_decl);
8013 return NULL_TREE;
8015 else if (DECL_DEFAULTED_FN (old_decl))
8017 error ("definition of explicitly-defaulted %q+D", decl);
8018 error ("%q+#D explicitly defaulted here", old_decl);
8019 return NULL_TREE;
8022 /* Since we've smashed OLD_DECL to its
8023 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8024 if (TREE_CODE (decl) == TEMPLATE_DECL)
8025 decl = DECL_TEMPLATE_RESULT (decl);
8027 /* Attempt to merge the declarations. This can fail, in
8028 the case of some invalid specialization declarations. */
8029 pushed_scope = push_scope (ctype);
8030 ok = duplicate_decls (decl, old_decl, friendp);
8031 if (pushed_scope)
8032 pop_scope (pushed_scope);
8033 if (!ok)
8035 error ("no %q#D member function declared in class %qT",
8036 decl, ctype);
8037 return NULL_TREE;
8039 if (ok == error_mark_node)
8040 return NULL_TREE;
8041 return old_decl;
8045 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8046 return NULL_TREE;
8048 if (ctype == NULL_TREE || check)
8049 return decl;
8051 if (virtualp)
8052 DECL_VIRTUAL_P (decl) = 1;
8054 return decl;
8057 /* decl is a FUNCTION_DECL.
8058 specifiers are the parsed virt-specifiers.
8060 Set flags to reflect the virt-specifiers.
8062 Returns decl. */
8064 static tree
8065 set_virt_specifiers (tree decl, cp_virt_specifiers specifiers)
8067 if (decl == NULL_TREE)
8068 return decl;
8069 if (specifiers & VIRT_SPEC_OVERRIDE)
8070 DECL_OVERRIDE_P (decl) = 1;
8071 if (specifiers & VIRT_SPEC_FINAL)
8072 DECL_FINAL_P (decl) = 1;
8073 return decl;
8076 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8077 the linkage that DECL will receive in the object file. */
8079 static void
8080 set_linkage_for_static_data_member (tree decl)
8082 /* A static data member always has static storage duration and
8083 external linkage. Note that static data members are forbidden in
8084 local classes -- the only situation in which a class has
8085 non-external linkage. */
8086 TREE_PUBLIC (decl) = 1;
8087 TREE_STATIC (decl) = 1;
8088 /* For non-template classes, static data members are always put
8089 out in exactly those files where they are defined, just as
8090 with ordinary namespace-scope variables. */
8091 if (!processing_template_decl)
8092 DECL_INTERFACE_KNOWN (decl) = 1;
8095 /* Create a VAR_DECL named NAME with the indicated TYPE.
8097 If SCOPE is non-NULL, it is the class type or namespace containing
8098 the variable. If SCOPE is NULL, the variable should is created in
8099 the innermost enclosing scope. */
8101 static tree
8102 grokvardecl (tree type,
8103 tree name,
8104 tree orig_declarator,
8105 const cp_decl_specifier_seq *declspecs,
8106 int initialized,
8107 int constp,
8108 int template_count,
8109 tree scope)
8111 tree decl;
8112 tree explicit_scope;
8114 gcc_assert (!name || identifier_p (name));
8116 /* Compute the scope in which to place the variable, but remember
8117 whether or not that scope was explicitly specified by the user. */
8118 explicit_scope = scope;
8119 if (!scope)
8121 /* An explicit "extern" specifier indicates a namespace-scope
8122 variable. */
8123 if (declspecs->storage_class == sc_extern)
8124 scope = current_decl_namespace ();
8125 else if (!at_function_scope_p ())
8126 scope = current_scope ();
8129 if (scope
8130 && (/* If the variable is a namespace-scope variable declared in a
8131 template, we need DECL_LANG_SPECIFIC. */
8132 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
8133 /* Similarly for namespace-scope variables with language linkage
8134 other than C++. */
8135 || (TREE_CODE (scope) == NAMESPACE_DECL
8136 && current_lang_name != lang_name_cplusplus)
8137 /* Similarly for static data members. */
8138 || TYPE_P (scope)
8139 /* Similarly for explicit specializations. */
8140 || (orig_declarator
8141 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)))
8142 decl = build_lang_decl (VAR_DECL, name, type);
8143 else
8144 decl = build_decl (input_location, VAR_DECL, name, type);
8146 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
8147 set_decl_namespace (decl, explicit_scope, 0);
8148 else
8149 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
8151 if (declspecs->storage_class == sc_extern)
8153 DECL_THIS_EXTERN (decl) = 1;
8154 DECL_EXTERNAL (decl) = !initialized;
8157 if (DECL_CLASS_SCOPE_P (decl))
8159 set_linkage_for_static_data_member (decl);
8160 /* This function is only called with out-of-class definitions. */
8161 DECL_EXTERNAL (decl) = 0;
8162 check_class_member_definition_namespace (decl);
8164 /* At top level, either `static' or no s.c. makes a definition
8165 (perhaps tentative), and absence of `static' makes it public. */
8166 else if (toplevel_bindings_p ())
8168 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
8169 && (DECL_THIS_EXTERN (decl) || ! constp));
8170 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8172 /* Not at top level, only `static' makes a static definition. */
8173 else
8175 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
8176 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8179 if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
8181 if (DECL_EXTERNAL (decl) || TREE_STATIC (decl))
8182 set_decl_tls_model (decl, decl_default_tls_model (decl));
8183 if (declspecs->gnu_thread_keyword_p)
8184 DECL_GNU_TLS_P (decl) = true;
8187 /* If the type of the decl has no linkage, make sure that we'll
8188 notice that in mark_used. */
8189 if (cxx_dialect > cxx98
8190 && decl_linkage (decl) != lk_none
8191 && DECL_LANG_SPECIFIC (decl) == NULL
8192 && !DECL_EXTERN_C_P (decl)
8193 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
8194 retrofit_lang_decl (decl);
8196 if (TREE_PUBLIC (decl))
8198 /* [basic.link]: A name with no linkage (notably, the name of a class
8199 or enumeration declared in a local scope) shall not be used to
8200 declare an entity with linkage.
8202 DR 757 relaxes this restriction for C++0x. */
8203 if (cxx_dialect < cxx11)
8204 no_linkage_error (decl);
8206 else
8207 DECL_INTERFACE_KNOWN (decl) = 1;
8209 // Handle explicit specializations and instantiations of variable templates.
8210 if (orig_declarator)
8211 decl = check_explicit_specialization (orig_declarator, decl,
8212 template_count, 0);
8214 return decl != error_mark_node ? decl : NULL_TREE;
8217 /* Create and return a canonical pointer to member function type, for
8218 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8220 tree
8221 build_ptrmemfunc_type (tree type)
8223 tree field, fields;
8224 tree t;
8226 if (type == error_mark_node)
8227 return type;
8229 /* Make sure that we always have the unqualified pointer-to-member
8230 type first. */
8231 if (cp_cv_quals quals = cp_type_quals (type))
8233 tree unqual = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8234 return cp_build_qualified_type (unqual, quals);
8237 /* If a canonical type already exists for this type, use it. We use
8238 this method instead of type_hash_canon, because it only does a
8239 simple equality check on the list of field members. */
8241 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8242 return t;
8244 t = make_node (RECORD_TYPE);
8246 /* Let the front end know this is a pointer to member function. */
8247 TYPE_PTRMEMFUNC_FLAG (t) = 1;
8249 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
8250 fields = field;
8252 field = build_decl (input_location, FIELD_DECL, delta_identifier,
8253 delta_type_node);
8254 DECL_CHAIN (field) = fields;
8255 fields = field;
8257 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
8259 /* Zap out the name so that the back end will give us the debugging
8260 information for this anonymous RECORD_TYPE. */
8261 TYPE_NAME (t) = NULL_TREE;
8263 /* Cache this pointer-to-member type so that we can find it again
8264 later. */
8265 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8267 if (TYPE_STRUCTURAL_EQUALITY_P (type))
8268 SET_TYPE_STRUCTURAL_EQUALITY (t);
8269 else if (TYPE_CANONICAL (type) != type)
8270 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
8272 return t;
8275 /* Create and return a pointer to data member type. */
8277 tree
8278 build_ptrmem_type (tree class_type, tree member_type)
8280 if (TREE_CODE (member_type) == METHOD_TYPE)
8282 cp_cv_quals quals = type_memfn_quals (member_type);
8283 cp_ref_qualifier rqual = type_memfn_rqual (member_type);
8284 member_type = build_memfn_type (member_type, class_type, quals, rqual);
8285 return build_ptrmemfunc_type (build_pointer_type (member_type));
8287 else
8289 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
8290 return build_offset_type (class_type, member_type);
8294 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8295 Check to see that the definition is valid. Issue appropriate error
8296 messages. Return 1 if the definition is particularly bad, or 0
8297 otherwise. */
8299 static int
8300 check_static_variable_definition (tree decl, tree type)
8302 /* Can't check yet if we don't know the type. */
8303 if (dependent_type_p (type))
8304 return 0;
8305 /* If DECL is declared constexpr, we'll do the appropriate checks
8306 in check_initializer. */
8307 if (DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
8308 return 0;
8309 else if (cxx_dialect >= cxx11 && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
8311 if (!COMPLETE_TYPE_P (type))
8312 error ("in-class initialization of static data member %q#D of "
8313 "incomplete type", decl);
8314 else if (literal_type_p (type))
8315 permerror (input_location,
8316 "%<constexpr%> needed for in-class initialization of "
8317 "static data member %q#D of non-integral type", decl);
8318 else
8319 error ("in-class initialization of static data member %q#D of "
8320 "non-literal type", decl);
8321 return 1;
8324 /* Motion 10 at San Diego: If a static const integral data member is
8325 initialized with an integral constant expression, the initializer
8326 may appear either in the declaration (within the class), or in
8327 the definition, but not both. If it appears in the class, the
8328 member is a member constant. The file-scope definition is always
8329 required. */
8330 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
8332 error ("invalid in-class initialization of static data member "
8333 "of non-integral type %qT",
8334 type);
8335 return 1;
8337 else if (!CP_TYPE_CONST_P (type))
8338 error ("ISO C++ forbids in-class initialization of non-const "
8339 "static member %qD",
8340 decl);
8341 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
8342 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids initialization of member constant "
8343 "%qD of non-integral type %qT", decl, type);
8345 return 0;
8348 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8349 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8350 expressions out into temporary variables so that walk_tree doesn't
8351 step into them (c++/15764). */
8353 static tree
8354 stabilize_save_expr_r (tree *expr_p, int *walk_subtrees, void *data)
8356 hash_set<tree> *pset = (hash_set<tree> *)data;
8357 tree expr = *expr_p;
8358 if (TREE_CODE (expr) == SAVE_EXPR)
8360 tree op = TREE_OPERAND (expr, 0);
8361 cp_walk_tree (&op, stabilize_save_expr_r, data, pset);
8362 if (TREE_SIDE_EFFECTS (op))
8363 TREE_OPERAND (expr, 0) = get_temp_regvar (TREE_TYPE (op), op);
8364 *walk_subtrees = 0;
8366 else if (!EXPR_P (expr) || !TREE_SIDE_EFFECTS (expr))
8367 *walk_subtrees = 0;
8368 return NULL;
8371 /* Entry point for the above. */
8373 static void
8374 stabilize_vla_size (tree size)
8376 hash_set<tree> pset;
8377 /* Break out any function calls into temporary variables. */
8378 cp_walk_tree (&size, stabilize_save_expr_r, &pset, &pset);
8381 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8382 not inside of SAVE_EXPR and fold them. */
8384 static tree
8385 fold_sizeof_expr_r (tree *expr_p, int *walk_subtrees, void *data)
8387 tree expr = *expr_p;
8388 if (TREE_CODE (expr) == SAVE_EXPR || TYPE_P (expr))
8389 *walk_subtrees = 0;
8390 else if (TREE_CODE (expr) == SIZEOF_EXPR)
8392 *(bool *)data = true;
8393 if (SIZEOF_EXPR_TYPE_P (expr))
8394 expr = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr, 0)),
8395 SIZEOF_EXPR, false);
8396 else if (TYPE_P (TREE_OPERAND (expr, 0)))
8397 expr = cxx_sizeof_or_alignof_type (TREE_OPERAND (expr, 0), SIZEOF_EXPR,
8398 false);
8399 else
8400 expr = cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr, 0), SIZEOF_EXPR,
8401 false);
8402 if (expr == error_mark_node)
8403 expr = size_one_node;
8404 *expr_p = expr;
8405 *walk_subtrees = 0;
8407 return NULL;
8410 /* Given the SIZE (i.e., number of elements) in an array, compute an
8411 appropriate index type for the array. If non-NULL, NAME is the
8412 name of the thing being declared. */
8414 tree
8415 compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
8417 tree itype;
8418 tree osize = size;
8420 if (error_operand_p (size))
8421 return error_mark_node;
8423 if (!type_dependent_expression_p (size))
8425 tree type = TREE_TYPE (size);
8427 mark_rvalue_use (size);
8429 if (cxx_dialect < cxx11 && TREE_CODE (size) == NOP_EXPR
8430 && TREE_SIDE_EFFECTS (size))
8431 /* In C++98, we mark a non-constant array bound with a magic
8432 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8433 else
8435 size = instantiate_non_dependent_expr_sfinae (size, complain);
8437 if (CLASS_TYPE_P (type)
8438 && CLASSTYPE_LITERAL_P (type))
8440 size = build_expr_type_conversion (WANT_INT, size, true);
8441 if (!size)
8443 if (!(complain & tf_error))
8444 return error_mark_node;
8445 if (name)
8446 error ("size of array %qD has non-integral type %qT",
8447 name, type);
8448 else
8449 error ("size of array has non-integral type %qT", type);
8450 size = integer_one_node;
8452 if (size == error_mark_node)
8453 return error_mark_node;
8454 type = TREE_TYPE (size);
8457 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
8458 size = maybe_constant_value (size);
8460 if (!TREE_CONSTANT (size))
8461 size = osize;
8464 if (error_operand_p (size))
8465 return error_mark_node;
8467 /* The array bound must be an integer type. */
8468 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
8470 if (!(complain & tf_error))
8471 return error_mark_node;
8472 if (name)
8473 error ("size of array %qD has non-integral type %qT", name, type);
8474 else
8475 error ("size of array has non-integral type %qT", type);
8476 size = integer_one_node;
8477 type = TREE_TYPE (size);
8481 /* A type is dependent if it is...an array type constructed from any
8482 dependent type or whose size is specified by a constant expression
8483 that is value-dependent. */
8484 /* We can only call value_dependent_expression_p on integral constant
8485 expressions; treat non-constant expressions as dependent, too. */
8486 if (processing_template_decl
8487 && (type_dependent_expression_p (size)
8488 || !TREE_CONSTANT (size) || value_dependent_expression_p (size)))
8490 /* We cannot do any checking for a SIZE that isn't known to be
8491 constant. Just build the index type and mark that it requires
8492 structural equality checks. */
8493 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8494 size, size_one_node));
8495 TYPE_DEPENDENT_P (itype) = 1;
8496 TYPE_DEPENDENT_P_VALID (itype) = 1;
8497 SET_TYPE_STRUCTURAL_EQUALITY (itype);
8498 return itype;
8501 /* Normally, the array-bound will be a constant. */
8502 if (TREE_CODE (size) == INTEGER_CST)
8504 /* Check to see if the array bound overflowed. Make that an
8505 error, no matter how generous we're being. */
8506 constant_expression_error (size);
8508 /* An array must have a positive number of elements. */
8509 if (tree_int_cst_lt (size, integer_zero_node))
8511 if (!(complain & tf_error))
8512 return error_mark_node;
8513 if (name)
8514 error ("size of array %qD is negative", name);
8515 else
8516 error ("size of array is negative");
8517 size = integer_one_node;
8519 /* As an extension we allow zero-sized arrays. */
8520 else if (integer_zerop (size))
8522 if (!(complain & tf_error))
8523 /* We must fail if performing argument deduction (as
8524 indicated by the state of complain), so that
8525 another substitution can be found. */
8526 return error_mark_node;
8527 else if (in_system_header_at (input_location))
8528 /* Allow them in system headers because glibc uses them. */;
8529 else if (name)
8530 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
8531 else
8532 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array");
8535 else if (TREE_CONSTANT (size)
8536 /* We don't allow VLAs at non-function scopes, or during
8537 tentative template substitution. */
8538 || !at_function_scope_p ()
8539 || !(complain & tf_error))
8541 if (!(complain & tf_error))
8542 return error_mark_node;
8543 /* `(int) &fn' is not a valid array bound. */
8544 if (name)
8545 error ("size of array %qD is not an integral constant-expression",
8546 name);
8547 else
8548 error ("size of array is not an integral constant-expression");
8549 size = integer_one_node;
8551 else if (pedantic && warn_vla != 0)
8553 if (name)
8554 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
8555 else
8556 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
8558 else if (warn_vla > 0)
8560 if (name)
8561 warning (OPT_Wvla,
8562 "variable length array %qD is used", name);
8563 else
8564 warning (OPT_Wvla,
8565 "variable length array is used");
8568 if (processing_template_decl && !TREE_CONSTANT (size))
8569 /* A variable sized array. */
8570 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
8571 else
8573 HOST_WIDE_INT saved_processing_template_decl;
8575 /* Compute the index of the largest element in the array. It is
8576 one less than the number of elements in the array. We save
8577 and restore PROCESSING_TEMPLATE_DECL so that computations in
8578 cp_build_binary_op will be appropriately folded. */
8579 saved_processing_template_decl = processing_template_decl;
8580 processing_template_decl = 0;
8581 itype = cp_build_binary_op (input_location,
8582 MINUS_EXPR,
8583 cp_convert (ssizetype, size, complain),
8584 cp_convert (ssizetype, integer_one_node,
8585 complain),
8586 complain);
8587 itype = fold (itype);
8588 processing_template_decl = saved_processing_template_decl;
8590 if (!TREE_CONSTANT (itype))
8592 /* A variable sized array. */
8593 itype = variable_size (itype);
8595 if (TREE_CODE (itype) != SAVE_EXPR)
8597 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8598 they might survive till gimplification. */
8599 tree newitype = itype;
8600 bool found = false;
8601 cp_walk_tree_without_duplicates (&newitype,
8602 fold_sizeof_expr_r, &found);
8603 if (found)
8604 itype = variable_size (fold (newitype));
8607 stabilize_vla_size (itype);
8609 if (flag_sanitize & SANITIZE_VLA
8610 && do_ubsan_in_current_function ())
8612 /* We have to add 1 -- in the ubsan routine we generate
8613 LE_EXPR rather than LT_EXPR. */
8614 tree t = fold_build2 (PLUS_EXPR, TREE_TYPE (itype), itype,
8615 build_one_cst (TREE_TYPE (itype)));
8616 t = ubsan_instrument_vla (input_location, t);
8617 finish_expr_stmt (t);
8620 /* Make sure that there was no overflow when creating to a signed
8621 index type. (For example, on a 32-bit machine, an array with
8622 size 2^32 - 1 is too big.) */
8623 else if (TREE_CODE (itype) == INTEGER_CST
8624 && TREE_OVERFLOW (itype))
8626 if (!(complain & tf_error))
8627 return error_mark_node;
8628 error ("overflow in array dimension");
8629 TREE_OVERFLOW (itype) = 0;
8633 /* Create and return the appropriate index type. */
8634 itype = build_index_type (itype);
8636 /* If the index type were dependent, we would have returned early, so
8637 remember that it isn't. */
8638 TYPE_DEPENDENT_P (itype) = 0;
8639 TYPE_DEPENDENT_P_VALID (itype) = 1;
8640 return itype;
8643 /* Returns the scope (if any) in which the entity declared by
8644 DECLARATOR will be located. If the entity was declared with an
8645 unqualified name, NULL_TREE is returned. */
8647 tree
8648 get_scope_of_declarator (const cp_declarator *declarator)
8650 while (declarator && declarator->kind != cdk_id)
8651 declarator = declarator->declarator;
8653 /* If the declarator-id is a SCOPE_REF, the scope in which the
8654 declaration occurs is the first operand. */
8655 if (declarator
8656 && declarator->u.id.qualifying_scope)
8657 return declarator->u.id.qualifying_scope;
8659 /* Otherwise, the declarator is not a qualified name; the entity will
8660 be declared in the current scope. */
8661 return NULL_TREE;
8664 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8665 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8666 with this type. */
8668 static tree
8669 create_array_type_for_decl (tree name, tree type, tree size)
8671 tree itype = NULL_TREE;
8673 /* If things have already gone awry, bail now. */
8674 if (type == error_mark_node || size == error_mark_node)
8675 return error_mark_node;
8677 /* 8.3.4/1: If the type of the identifier of D contains the auto
8678 type-specifier, the program is ill-formed. */
8679 if (type_uses_auto (type))
8681 error ("%qD declared as array of %qT", name, type);
8682 return error_mark_node;
8685 /* If there are some types which cannot be array elements,
8686 issue an error-message and return. */
8687 switch (TREE_CODE (type))
8689 case VOID_TYPE:
8690 if (name)
8691 error ("declaration of %qD as array of void", name);
8692 else
8693 error ("creating array of void");
8694 return error_mark_node;
8696 case FUNCTION_TYPE:
8697 if (name)
8698 error ("declaration of %qD as array of functions", name);
8699 else
8700 error ("creating array of functions");
8701 return error_mark_node;
8703 case REFERENCE_TYPE:
8704 if (name)
8705 error ("declaration of %qD as array of references", name);
8706 else
8707 error ("creating array of references");
8708 return error_mark_node;
8710 case METHOD_TYPE:
8711 if (name)
8712 error ("declaration of %qD as array of function members", name);
8713 else
8714 error ("creating array of function members");
8715 return error_mark_node;
8717 default:
8718 break;
8721 /* [dcl.array]
8723 The constant expressions that specify the bounds of the arrays
8724 can be omitted only for the first member of the sequence. */
8725 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
8727 if (name)
8728 error ("declaration of %qD as multidimensional array must "
8729 "have bounds for all dimensions except the first",
8730 name);
8731 else
8732 error ("multidimensional array must have bounds for all "
8733 "dimensions except the first");
8735 return error_mark_node;
8738 /* Figure out the index type for the array. */
8739 if (size)
8740 itype = compute_array_index_type (name, size, tf_warning_or_error);
8742 /* [dcl.array]
8743 T is called the array element type; this type shall not be [...] an
8744 abstract class type. */
8745 abstract_virtuals_error (name, type);
8747 return build_cplus_array_type (type, itype);
8750 /* Check that it's OK to declare a function with the indicated TYPE.
8751 SFK indicates the kind of special function (if any) that this
8752 function is. OPTYPE is the type given in a conversion operator
8753 declaration, or the class type for a constructor/destructor.
8754 Returns the actual return type of the function; that
8755 may be different than TYPE if an error occurs, or for certain
8756 special functions. */
8758 static tree
8759 check_special_function_return_type (special_function_kind sfk,
8760 tree type,
8761 tree optype)
8763 switch (sfk)
8765 case sfk_constructor:
8766 if (type)
8767 error ("return type specification for constructor invalid");
8769 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8770 type = build_pointer_type (optype);
8771 else
8772 type = void_type_node;
8773 break;
8775 case sfk_destructor:
8776 if (type)
8777 error ("return type specification for destructor invalid");
8778 /* We can't use the proper return type here because we run into
8779 problems with ambiguous bases and covariant returns.
8780 Java classes are left unchanged because (void *) isn't a valid
8781 Java type, and we don't want to change the Java ABI. */
8782 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8783 type = build_pointer_type (void_type_node);
8784 else
8785 type = void_type_node;
8786 break;
8788 case sfk_conversion:
8789 if (type)
8790 error ("return type specified for %<operator %T%>", optype);
8791 type = optype;
8792 break;
8794 default:
8795 gcc_unreachable ();
8798 return type;
8801 /* A variable or data member (whose unqualified name is IDENTIFIER)
8802 has been declared with the indicated TYPE. If the TYPE is not
8803 acceptable, issue an error message and return a type to use for
8804 error-recovery purposes. */
8806 tree
8807 check_var_type (tree identifier, tree type)
8809 if (VOID_TYPE_P (type))
8811 if (!identifier)
8812 error ("unnamed variable or field declared void");
8813 else if (identifier_p (identifier))
8815 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
8816 error ("variable or field %qE declared void", identifier);
8818 else
8819 error ("variable or field declared void");
8820 type = error_mark_node;
8823 return type;
8826 /* Given declspecs and a declarator (abstract or otherwise), determine
8827 the name and type of the object declared and construct a DECL node
8828 for it.
8830 DECLSPECS points to the representation of declaration-specifier
8831 sequence that precedes declarator.
8833 DECL_CONTEXT says which syntactic context this declaration is in:
8834 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8835 FUNCDEF for a function definition. Like NORMAL but a few different
8836 error messages in each case. Return value may be zero meaning
8837 this definition is too screwy to try to parse.
8838 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8839 handle member functions (which have FIELD context).
8840 Return value may be zero meaning this definition is too screwy to
8841 try to parse.
8842 PARM for a parameter declaration (either within a function prototype
8843 or before a function body). Make a PARM_DECL, or return void_type_node.
8844 TPARM for a template parameter declaration.
8845 CATCHPARM for a parameter declaration before a catch clause.
8846 TYPENAME if for a typename (in a cast or sizeof).
8847 Don't make a DECL node; just return the ..._TYPE node.
8848 FIELD for a struct or union field; make a FIELD_DECL.
8849 BITFIELD for a field with specified width.
8851 INITIALIZED is as for start_decl.
8853 ATTRLIST is a pointer to the list of attributes, which may be NULL
8854 if there are none; *ATTRLIST may be modified if attributes from inside
8855 the declarator should be applied to the declaration.
8857 When this function is called, scoping variables (such as
8858 CURRENT_CLASS_TYPE) should reflect the scope in which the
8859 declaration occurs, not the scope in which the new declaration will
8860 be placed. For example, on:
8862 void S::f() { ... }
8864 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8865 should not be `S'.
8867 Returns a DECL (if a declarator is present), a TYPE (if there is no
8868 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8869 error occurs. */
8871 tree
8872 grokdeclarator (const cp_declarator *declarator,
8873 cp_decl_specifier_seq *declspecs,
8874 enum decl_context decl_context,
8875 int initialized,
8876 tree* attrlist)
8878 tree type = NULL_TREE;
8879 int longlong = 0;
8880 int explicit_intN = 0;
8881 int virtualp, explicitp, friendp, inlinep, staticp;
8882 int explicit_int = 0;
8883 int explicit_char = 0;
8884 int defaulted_int = 0;
8886 tree typedef_decl = NULL_TREE;
8887 const char *name = NULL;
8888 tree typedef_type = NULL_TREE;
8889 /* True if this declarator is a function definition. */
8890 bool funcdef_flag = false;
8891 cp_declarator_kind innermost_code = cdk_error;
8892 int bitfield = 0;
8893 #if 0
8894 /* See the code below that used this. */
8895 tree decl_attr = NULL_TREE;
8896 #endif
8898 /* Keep track of what sort of function is being processed
8899 so that we can warn about default return values, or explicit
8900 return values which do not match prescribed defaults. */
8901 special_function_kind sfk = sfk_none;
8903 tree dname = NULL_TREE;
8904 tree ctor_return_type = NULL_TREE;
8905 enum overload_flags flags = NO_SPECIAL;
8906 /* cv-qualifiers that apply to the declarator, for a declaration of
8907 a member function. */
8908 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
8909 /* virt-specifiers that apply to the declarator, for a declaration of
8910 a member function. */
8911 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
8912 /* ref-qualifier that applies to the declarator, for a declaration of
8913 a member function. */
8914 cp_ref_qualifier rqual = REF_QUAL_NONE;
8915 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8916 int type_quals;
8917 tree raises = NULL_TREE;
8918 int template_count = 0;
8919 tree returned_attrs = NULL_TREE;
8920 tree parms = NULL_TREE;
8921 const cp_declarator *id_declarator;
8922 /* The unqualified name of the declarator; either an
8923 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8924 tree unqualified_id;
8925 /* The class type, if any, in which this entity is located,
8926 or NULL_TREE if none. Note that this value may be different from
8927 the current class type; for example if an attempt is made to declare
8928 "A::f" inside "B", this value will be "A". */
8929 tree ctype = current_class_type;
8930 /* The NAMESPACE_DECL for the namespace in which this entity is
8931 located. If an unqualified name is used to declare the entity,
8932 this value will be NULL_TREE, even if the entity is located at
8933 namespace scope. */
8934 tree in_namespace = NULL_TREE;
8935 cp_storage_class storage_class;
8936 bool unsigned_p, signed_p, short_p, long_p, thread_p;
8937 bool type_was_error_mark_node = false;
8938 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
8939 bool template_type_arg = false;
8940 bool template_parm_flag = false;
8941 bool typedef_p = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
8942 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr);
8943 bool late_return_type_p = false;
8944 bool array_parameter_p = false;
8945 source_location saved_loc = input_location;
8946 const char *errmsg;
8948 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed);
8949 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned);
8950 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short);
8951 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long);
8952 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long);
8953 explicit_intN = declspecs->explicit_intN_p;
8954 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread);
8956 if (decl_context == FUNCDEF)
8957 funcdef_flag = true, decl_context = NORMAL;
8958 else if (decl_context == MEMFUNCDEF)
8959 funcdef_flag = true, decl_context = FIELD;
8960 else if (decl_context == BITFIELD)
8961 bitfield = 1, decl_context = FIELD;
8962 else if (decl_context == TEMPLATE_TYPE_ARG)
8963 template_type_arg = true, decl_context = TYPENAME;
8964 else if (decl_context == TPARM)
8965 template_parm_flag = true, decl_context = PARM;
8967 if (initialized > 1)
8968 funcdef_flag = true;
8970 /* Look inside a declarator for the name being declared
8971 and get it as a string, for an error message. */
8972 for (id_declarator = declarator;
8973 id_declarator;
8974 id_declarator = id_declarator->declarator)
8976 if (id_declarator->kind != cdk_id)
8977 innermost_code = id_declarator->kind;
8979 switch (id_declarator->kind)
8981 case cdk_function:
8982 if (id_declarator->declarator
8983 && id_declarator->declarator->kind == cdk_id)
8985 sfk = id_declarator->declarator->u.id.sfk;
8986 if (sfk == sfk_destructor)
8987 flags = DTOR_FLAG;
8989 break;
8991 case cdk_id:
8993 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
8994 tree decl = id_declarator->u.id.unqualified_name;
8995 if (!decl)
8996 break;
8997 if (qualifying_scope)
8999 if (at_function_scope_p ())
9001 /* [dcl.meaning]
9003 A declarator-id shall not be qualified except
9004 for ...
9006 None of the cases are permitted in block
9007 scope. */
9008 if (qualifying_scope == global_namespace)
9009 error ("invalid use of qualified-name %<::%D%>",
9010 decl);
9011 else if (TYPE_P (qualifying_scope))
9012 error ("invalid use of qualified-name %<%T::%D%>",
9013 qualifying_scope, decl);
9014 else
9015 error ("invalid use of qualified-name %<%D::%D%>",
9016 qualifying_scope, decl);
9017 return error_mark_node;
9019 else if (TYPE_P (qualifying_scope))
9021 ctype = qualifying_scope;
9022 if (!MAYBE_CLASS_TYPE_P (ctype))
9024 error ("%q#T is not a class or a namespace", ctype);
9025 ctype = NULL_TREE;
9027 else if (innermost_code != cdk_function
9028 && current_class_type
9029 && !uniquely_derived_from_p (ctype,
9030 current_class_type))
9032 error ("invalid use of qualified-name %<%T::%D%>",
9033 qualifying_scope, decl);
9034 return error_mark_node;
9037 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
9038 in_namespace = qualifying_scope;
9040 switch (TREE_CODE (decl))
9042 case BIT_NOT_EXPR:
9044 tree type;
9046 if (innermost_code != cdk_function)
9048 error ("declaration of %qD as non-function", decl);
9049 return error_mark_node;
9051 else if (!qualifying_scope
9052 && !(current_class_type && at_class_scope_p ()))
9054 error ("declaration of %qD as non-member", decl);
9055 return error_mark_node;
9058 type = TREE_OPERAND (decl, 0);
9059 if (TYPE_P (type))
9060 type = constructor_name (type);
9061 name = identifier_to_locale (IDENTIFIER_POINTER (type));
9062 dname = decl;
9064 break;
9066 case TEMPLATE_ID_EXPR:
9068 tree fns = TREE_OPERAND (decl, 0);
9070 dname = fns;
9071 if (!identifier_p (dname))
9073 if (variable_template_p (dname))
9074 dname = DECL_NAME (dname);
9075 else
9077 gcc_assert (is_overloaded_fn (dname));
9078 dname = DECL_NAME (get_first_fn (dname));
9082 /* Fall through. */
9084 case IDENTIFIER_NODE:
9085 if (identifier_p (decl))
9086 dname = decl;
9088 if (C_IS_RESERVED_WORD (dname))
9090 error ("declarator-id missing; using reserved word %qD",
9091 dname);
9092 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
9094 else if (!IDENTIFIER_TYPENAME_P (dname))
9095 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
9096 else
9098 gcc_assert (flags == NO_SPECIAL);
9099 flags = TYPENAME_FLAG;
9100 ctor_return_type = TREE_TYPE (dname);
9101 sfk = sfk_conversion;
9102 if (is_typename_at_global_scope (dname))
9103 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
9104 else
9105 name = "<invalid operator>";
9107 break;
9109 default:
9110 gcc_unreachable ();
9112 break;
9115 case cdk_array:
9116 case cdk_pointer:
9117 case cdk_reference:
9118 case cdk_ptrmem:
9119 break;
9121 case cdk_error:
9122 return error_mark_node;
9124 default:
9125 gcc_unreachable ();
9127 if (id_declarator->kind == cdk_id)
9128 break;
9131 /* [dcl.fct.edf]
9133 The declarator in a function-definition shall have the form
9134 D1 ( parameter-declaration-clause) ... */
9135 if (funcdef_flag && innermost_code != cdk_function)
9137 error ("function definition does not declare parameters");
9138 return error_mark_node;
9141 if (flags == TYPENAME_FLAG
9142 && innermost_code != cdk_function
9143 && ! (ctype && !declspecs->any_specifiers_p))
9145 error ("declaration of %qD as non-function", dname);
9146 return error_mark_node;
9149 if (dname
9150 && identifier_p (dname)
9151 && UDLIT_OPER_P (dname)
9152 && innermost_code != cdk_function)
9154 error ("declaration of %qD as non-function", dname);
9155 return error_mark_node;
9158 if (dname && IDENTIFIER_OPNAME_P (dname))
9160 if (typedef_p)
9162 error ("declaration of %qD as %<typedef%>", dname);
9163 return error_mark_node;
9165 else if (decl_context == PARM || decl_context == CATCHPARM)
9167 error ("declaration of %qD as parameter", dname);
9168 return error_mark_node;
9172 /* Anything declared one level down from the top level
9173 must be one of the parameters of a function
9174 (because the body is at least two levels down). */
9176 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9177 by not allowing C++ class definitions to specify their parameters
9178 with xdecls (must be spec.d in the parmlist).
9180 Since we now wait to push a class scope until we are sure that
9181 we are in a legitimate method context, we must set oldcname
9182 explicitly (since current_class_name is not yet alive).
9184 We also want to avoid calling this a PARM if it is in a namespace. */
9186 if (decl_context == NORMAL && !toplevel_bindings_p ())
9188 cp_binding_level *b = current_binding_level;
9189 current_binding_level = b->level_chain;
9190 if (current_binding_level != 0 && toplevel_bindings_p ())
9191 decl_context = PARM;
9192 current_binding_level = b;
9195 if (name == NULL)
9196 name = decl_context == PARM ? "parameter" : "type name";
9198 if (constexpr_p && typedef_p)
9200 error ("%<constexpr%> cannot appear in a typedef declaration");
9201 return error_mark_node;
9204 /* If there were multiple types specified in the decl-specifier-seq,
9205 issue an error message. */
9206 if (declspecs->multiple_types_p)
9208 error ("two or more data types in declaration of %qs", name);
9209 return error_mark_node;
9212 if (declspecs->conflicting_specifiers_p)
9214 error ("conflicting specifiers in declaration of %qs", name);
9215 return error_mark_node;
9218 /* Extract the basic type from the decl-specifier-seq. */
9219 type = declspecs->type;
9220 if (type == error_mark_node)
9222 type = NULL_TREE;
9223 type_was_error_mark_node = true;
9225 /* If the entire declaration is itself tagged as deprecated then
9226 suppress reports of deprecated items. */
9227 if (type && TREE_DEPRECATED (type)
9228 && deprecated_state != DEPRECATED_SUPPRESS)
9229 warn_deprecated_use (type, NULL_TREE);
9230 if (type && TREE_CODE (type) == TYPE_DECL)
9232 typedef_decl = type;
9233 type = TREE_TYPE (typedef_decl);
9234 if (TREE_DEPRECATED (type)
9235 && DECL_ARTIFICIAL (typedef_decl)
9236 && deprecated_state != DEPRECATED_SUPPRESS)
9237 warn_deprecated_use (type, NULL_TREE);
9239 /* No type at all: default to `int', and set DEFAULTED_INT
9240 because it was not a user-defined typedef. */
9241 if (type == NULL_TREE)
9243 if (signed_p || unsigned_p || long_p || short_p)
9245 /* These imply 'int'. */
9246 type = integer_type_node;
9247 defaulted_int = 1;
9249 /* If we just have "complex", it is equivalent to "complex double". */
9250 else if (!longlong && !explicit_intN
9251 && decl_spec_seq_has_spec_p (declspecs, ds_complex))
9253 type = double_type_node;
9254 pedwarn (declspecs->locations[ds_complex], OPT_Wpedantic,
9255 "ISO C++ does not support plain %<complex%> meaning "
9256 "%<double complex%>");
9259 /* Gather flags. */
9260 explicit_int = declspecs->explicit_int_p;
9261 explicit_char = declspecs->explicit_char_p;
9263 #if 0
9264 /* See the code below that used this. */
9265 if (typedef_decl)
9266 decl_attr = DECL_ATTRIBUTES (typedef_decl);
9267 #endif
9268 typedef_type = type;
9271 if (sfk != sfk_conversion)
9272 ctor_return_type = ctype;
9274 if (sfk != sfk_none)
9275 type = check_special_function_return_type (sfk, type,
9276 ctor_return_type);
9277 else if (type == NULL_TREE)
9279 int is_main;
9281 explicit_int = -1;
9283 /* We handle `main' specially here, because 'main () { }' is so
9284 common. With no options, it is allowed. With -Wreturn-type,
9285 it is a warning. It is only an error with -pedantic-errors. */
9286 is_main = (funcdef_flag
9287 && dname && identifier_p (dname)
9288 && MAIN_NAME_P (dname)
9289 && ctype == NULL_TREE
9290 && in_namespace == NULL_TREE
9291 && current_namespace == global_namespace);
9293 if (type_was_error_mark_node)
9294 /* We've already issued an error, don't complain more. */;
9295 else if (in_system_header_at (input_location) || flag_ms_extensions)
9296 /* Allow it, sigh. */;
9297 else if (! is_main)
9298 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
9299 else if (pedantic)
9300 pedwarn (input_location, OPT_Wpedantic,
9301 "ISO C++ forbids declaration of %qs with no type", name);
9302 else
9303 warning (OPT_Wreturn_type,
9304 "ISO C++ forbids declaration of %qs with no type", name);
9306 type = integer_type_node;
9309 ctype = NULL_TREE;
9311 if (explicit_intN)
9313 if (! int_n_enabled_p[declspecs->int_n_idx])
9315 error ("%<__int%d%> is not supported by this target",
9316 int_n_data[declspecs->int_n_idx].bitsize);
9317 explicit_intN = false;
9319 else if (pedantic && ! in_system_header_at (input_location))
9320 pedwarn (input_location, OPT_Wpedantic,
9321 "ISO C++ does not support %<__int%d%> for %qs",
9322 int_n_data[declspecs->int_n_idx].bitsize, name);
9325 /* Now process the modifiers that were specified
9326 and check for invalid combinations. */
9328 /* Long double is a special combination. */
9329 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
9331 long_p = false;
9332 type = cp_build_qualified_type (long_double_type_node,
9333 cp_type_quals (type));
9336 /* Check all other uses of type modifiers. */
9338 if (unsigned_p || signed_p || long_p || short_p)
9340 int ok = 0;
9342 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
9343 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
9344 else if (signed_p && unsigned_p)
9345 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
9346 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
9347 error ("%<long long%> invalid for %qs", name);
9348 else if (long_p && TREE_CODE (type) == REAL_TYPE)
9349 error ("%<long%> invalid for %qs", name);
9350 else if (short_p && TREE_CODE (type) == REAL_TYPE)
9351 error ("%<short%> invalid for %qs", name);
9352 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
9353 error ("%<long%> or %<short%> invalid for %qs", name);
9354 else if ((long_p || short_p || explicit_char || explicit_int) && explicit_intN)
9355 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
9356 else if ((long_p || short_p) && explicit_char)
9357 error ("%<long%> or %<short%> specified with char for %qs", name);
9358 else if (long_p && short_p)
9359 error ("%<long%> and %<short%> specified together for %qs", name);
9360 else if (type == char16_type_node || type == char32_type_node)
9362 if (signed_p || unsigned_p)
9363 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
9364 else if (short_p || long_p)
9365 error ("%<short%> or %<long%> invalid for %qs", name);
9367 else
9369 ok = 1;
9370 if (!explicit_int && !defaulted_int && !explicit_char && !explicit_intN && pedantic)
9372 pedwarn (input_location, OPT_Wpedantic,
9373 "long, short, signed or unsigned used invalidly for %qs",
9374 name);
9375 if (flag_pedantic_errors)
9376 ok = 0;
9380 /* Discard the type modifiers if they are invalid. */
9381 if (! ok)
9383 unsigned_p = false;
9384 signed_p = false;
9385 long_p = false;
9386 short_p = false;
9387 longlong = 0;
9391 /* Decide whether an integer type is signed or not.
9392 Optionally treat bitfields as signed by default. */
9393 if (unsigned_p
9394 /* [class.bit]
9396 It is implementation-defined whether a plain (neither
9397 explicitly signed or unsigned) char, short, int, or long
9398 bit-field is signed or unsigned.
9400 Naturally, we extend this to long long as well. Note that
9401 this does not include wchar_t. */
9402 || (bitfield && !flag_signed_bitfields
9403 && !signed_p
9404 /* A typedef for plain `int' without `signed' can be
9405 controlled just like plain `int', but a typedef for
9406 `signed int' cannot be so controlled. */
9407 && !(typedef_decl
9408 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9409 && TREE_CODE (type) == INTEGER_TYPE
9410 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9412 if (explicit_intN)
9413 type = int_n_trees[declspecs->int_n_idx].unsigned_type;
9414 else if (longlong)
9415 type = long_long_unsigned_type_node;
9416 else if (long_p)
9417 type = long_unsigned_type_node;
9418 else if (short_p)
9419 type = short_unsigned_type_node;
9420 else if (type == char_type_node)
9421 type = unsigned_char_type_node;
9422 else if (typedef_decl)
9423 type = unsigned_type_for (type);
9424 else
9425 type = unsigned_type_node;
9427 else if (signed_p && type == char_type_node)
9428 type = signed_char_type_node;
9429 else if (explicit_intN)
9430 type = int_n_trees[declspecs->int_n_idx].signed_type;
9431 else if (longlong)
9432 type = long_long_integer_type_node;
9433 else if (long_p)
9434 type = long_integer_type_node;
9435 else if (short_p)
9436 type = short_integer_type_node;
9438 if (decl_spec_seq_has_spec_p (declspecs, ds_complex))
9440 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9441 error ("complex invalid for %qs", name);
9442 /* If a modifier is specified, the resulting complex is the complex
9443 form of TYPE. E.g, "complex short" is "complex short int". */
9444 else if (type == integer_type_node)
9445 type = complex_integer_type_node;
9446 else if (type == float_type_node)
9447 type = complex_float_type_node;
9448 else if (type == double_type_node)
9449 type = complex_double_type_node;
9450 else if (type == long_double_type_node)
9451 type = complex_long_double_type_node;
9452 else
9453 type = build_complex_type (type);
9456 type_quals = TYPE_UNQUALIFIED;
9457 if (decl_spec_seq_has_spec_p (declspecs, ds_const))
9458 type_quals |= TYPE_QUAL_CONST;
9459 if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
9460 type_quals |= TYPE_QUAL_VOLATILE;
9461 if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
9462 type_quals |= TYPE_QUAL_RESTRICT;
9463 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
9464 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9465 ctor_return_type);
9467 /* If we're using the injected-class-name to form a compound type or a
9468 declaration, replace it with the underlying class so we don't get
9469 redundant typedefs in the debug output. But if we are returning the
9470 type unchanged, leave it alone so that it's available to
9471 maybe_get_template_decl_from_type_decl. */
9472 if (CLASS_TYPE_P (type)
9473 && DECL_SELF_REFERENCE_P (TYPE_NAME (type))
9474 && type == TREE_TYPE (TYPE_NAME (type))
9475 && (declarator || type_quals))
9476 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
9478 type_quals |= cp_type_quals (type);
9479 type = cp_build_qualified_type_real
9480 (type, type_quals, ((((typedef_decl && !DECL_ARTIFICIAL (typedef_decl))
9481 || declspecs->decltype_p)
9482 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
9483 /* We might have ignored or rejected some of the qualifiers. */
9484 type_quals = cp_type_quals (type);
9486 staticp = 0;
9487 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline);
9488 virtualp = decl_spec_seq_has_spec_p (declspecs, ds_virtual);
9489 explicitp = decl_spec_seq_has_spec_p (declspecs, ds_explicit);
9491 storage_class = declspecs->storage_class;
9492 if (storage_class == sc_static)
9493 staticp = 1 + (decl_context == FIELD);
9495 if (virtualp && staticp == 2)
9497 error ("member %qD cannot be declared both virtual and static", dname);
9498 storage_class = sc_none;
9499 staticp = 0;
9501 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
9503 /* Issue errors about use of storage classes for parameters. */
9504 if (decl_context == PARM)
9506 if (typedef_p)
9508 error ("typedef declaration invalid in parameter declaration");
9509 return error_mark_node;
9511 else if (template_parm_flag && storage_class != sc_none)
9513 error ("storage class specified for template parameter %qs", name);
9514 return error_mark_node;
9516 else if (storage_class == sc_static
9517 || storage_class == sc_extern
9518 || thread_p)
9519 error ("storage class specifiers invalid in parameter declarations");
9521 /* Function parameters cannot be constexpr. If we saw one, moan
9522 and pretend it wasn't there. */
9523 if (constexpr_p)
9525 error ("a parameter cannot be declared %<constexpr%>");
9526 constexpr_p = 0;
9530 /* Give error if `virtual' is used outside of class declaration. */
9531 if (virtualp
9532 && (current_class_name == NULL_TREE || decl_context != FIELD))
9534 error_at (declspecs->locations[ds_virtual],
9535 "%<virtual%> outside class declaration");
9536 virtualp = 0;
9539 /* Static anonymous unions are dealt with here. */
9540 if (staticp && decl_context == TYPENAME
9541 && declspecs->type
9542 && ANON_AGGR_TYPE_P (declspecs->type))
9543 decl_context = FIELD;
9545 /* Warn about storage classes that are invalid for certain
9546 kinds of declarations (parameters, typenames, etc.). */
9547 if (thread_p
9548 && ((storage_class
9549 && storage_class != sc_extern
9550 && storage_class != sc_static)
9551 || typedef_p))
9553 error ("multiple storage classes in declaration of %qs", name);
9554 thread_p = false;
9556 if (decl_context != NORMAL
9557 && ((storage_class != sc_none
9558 && storage_class != sc_mutable)
9559 || thread_p))
9561 if ((decl_context == PARM || decl_context == CATCHPARM)
9562 && (storage_class == sc_register
9563 || storage_class == sc_auto))
9565 else if (typedef_p)
9567 else if (decl_context == FIELD
9568 /* C++ allows static class elements. */
9569 && storage_class == sc_static)
9570 /* C++ also allows inlines and signed and unsigned elements,
9571 but in those cases we don't come in here. */
9573 else
9575 if (decl_context == FIELD)
9576 error ("storage class specified for %qs", name);
9577 else
9579 if (decl_context == PARM || decl_context == CATCHPARM)
9580 error ("storage class specified for parameter %qs", name);
9581 else
9582 error ("storage class specified for typename");
9584 if (storage_class == sc_register
9585 || storage_class == sc_auto
9586 || storage_class == sc_extern
9587 || thread_p)
9588 storage_class = sc_none;
9591 else if (storage_class == sc_extern && funcdef_flag
9592 && ! toplevel_bindings_p ())
9593 error ("nested function %qs declared %<extern%>", name);
9594 else if (toplevel_bindings_p ())
9596 if (storage_class == sc_auto)
9597 error ("top-level declaration of %qs specifies %<auto%>", name);
9599 else if (thread_p
9600 && storage_class != sc_extern
9601 && storage_class != sc_static)
9603 if (declspecs->gnu_thread_keyword_p)
9604 pedwarn (input_location, 0, "function-scope %qs implicitly auto and "
9605 "declared %<__thread%>", name);
9607 /* When thread_local is applied to a variable of block scope the
9608 storage-class-specifier static is implied if it does not appear
9609 explicitly. */
9610 storage_class = declspecs->storage_class = sc_static;
9611 staticp = 1;
9614 if (storage_class && friendp)
9616 error ("storage class specifiers invalid in friend function declarations");
9617 storage_class = sc_none;
9618 staticp = 0;
9621 if (!id_declarator)
9622 unqualified_id = NULL_TREE;
9623 else
9625 unqualified_id = id_declarator->u.id.unqualified_name;
9626 switch (TREE_CODE (unqualified_id))
9628 case BIT_NOT_EXPR:
9629 unqualified_id = TREE_OPERAND (unqualified_id, 0);
9630 if (TYPE_P (unqualified_id))
9631 unqualified_id = constructor_name (unqualified_id);
9632 break;
9634 case IDENTIFIER_NODE:
9635 case TEMPLATE_ID_EXPR:
9636 break;
9638 default:
9639 gcc_unreachable ();
9643 if (declspecs->std_attributes)
9645 /* Apply the c++11 attributes to the type preceding them. */
9646 input_location = declspecs->locations[ds_std_attribute];
9647 decl_attributes (&type, declspecs->std_attributes, 0);
9648 input_location = saved_loc;
9651 /* Determine the type of the entity declared by recurring on the
9652 declarator. */
9653 for (; declarator; declarator = declarator->declarator)
9655 const cp_declarator *inner_declarator;
9656 tree attrs;
9658 if (type == error_mark_node)
9659 return error_mark_node;
9661 attrs = declarator->attributes;
9662 if (attrs)
9664 int attr_flags;
9666 attr_flags = 0;
9667 if (declarator == NULL || declarator->kind == cdk_id)
9668 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
9669 if (declarator->kind == cdk_function)
9670 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
9671 if (declarator->kind == cdk_array)
9672 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
9673 returned_attrs = decl_attributes (&type,
9674 chainon (returned_attrs, attrs),
9675 attr_flags);
9678 if (declarator->kind == cdk_id)
9679 break;
9681 inner_declarator = declarator->declarator;
9683 switch (declarator->kind)
9685 case cdk_array:
9686 type = create_array_type_for_decl (dname, type,
9687 declarator->u.array.bounds);
9688 if (declarator->std_attributes)
9689 /* [dcl.array]/1:
9691 The optional attribute-specifier-seq appertains to the
9692 array. */
9693 returned_attrs = chainon (returned_attrs,
9694 declarator->std_attributes);
9695 break;
9697 case cdk_function:
9699 tree arg_types;
9700 int funcdecl_p;
9702 /* Declaring a function type.
9703 Make sure we have a valid type for the function to return. */
9705 if (type_quals != TYPE_UNQUALIFIED)
9707 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
9708 warning (OPT_Wignored_qualifiers,
9709 "type qualifiers ignored on function return type");
9710 /* We now know that the TYPE_QUALS don't apply to the
9711 decl, but to its return type. */
9712 type_quals = TYPE_UNQUALIFIED;
9714 errmsg = targetm.invalid_return_type (type);
9715 if (errmsg)
9717 error (errmsg);
9718 type = integer_type_node;
9721 /* Error about some types functions can't return. */
9723 if (TREE_CODE (type) == FUNCTION_TYPE)
9725 error ("%qs declared as function returning a function", name);
9726 return error_mark_node;
9728 if (TREE_CODE (type) == ARRAY_TYPE)
9730 error ("%qs declared as function returning an array", name);
9731 return error_mark_node;
9734 input_location = declspecs->locations[ds_type_spec];
9735 abstract_virtuals_error (ACU_RETURN, type);
9736 input_location = saved_loc;
9738 /* Pick up type qualifiers which should be applied to `this'. */
9739 memfn_quals = declarator->u.function.qualifiers;
9740 /* Pick up virt-specifiers. */
9741 virt_specifiers = declarator->u.function.virt_specifiers;
9742 /* And ref-qualifier, too */
9743 rqual = declarator->u.function.ref_qualifier;
9744 /* Pick up the exception specifications. */
9745 raises = declarator->u.function.exception_specification;
9746 /* If the exception-specification is ill-formed, let's pretend
9747 there wasn't one. */
9748 if (raises == error_mark_node)
9749 raises = NULL_TREE;
9751 /* Say it's a definition only for the CALL_EXPR
9752 closest to the identifier. */
9753 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
9755 /* Handle a late-specified return type. */
9756 if (funcdecl_p)
9758 if (type_uses_auto (type))
9760 if (!declarator->u.function.late_return_type)
9762 if (current_class_type
9763 && LAMBDA_TYPE_P (current_class_type))
9764 /* OK for C++11 lambdas. */;
9765 else if (cxx_dialect < cxx14)
9767 error ("%qs function uses "
9768 "%<auto%> type specifier without trailing "
9769 "return type", name);
9770 inform (input_location, "deduced return type "
9771 "only available with -std=c++14 or "
9772 "-std=gnu++14");
9774 else if (virtualp)
9776 error ("virtual function cannot "
9777 "have deduced return type");
9778 virtualp = false;
9781 else if (!is_auto (type) && sfk != sfk_conversion)
9783 error ("%qs function with trailing return type has"
9784 " %qT as its type rather than plain %<auto%>",
9785 name, type);
9786 return error_mark_node;
9789 else if (declarator->u.function.late_return_type
9790 && sfk != sfk_conversion)
9792 if (cxx_dialect < cxx11)
9793 /* Not using maybe_warn_cpp0x because this should
9794 always be an error. */
9795 error ("trailing return type only available with "
9796 "-std=c++11 or -std=gnu++11");
9797 else
9798 error ("%qs function with trailing return type not "
9799 "declared with %<auto%> type specifier", name);
9800 return error_mark_node;
9803 type = splice_late_return_type
9804 (type, declarator->u.function.late_return_type);
9805 if (type == error_mark_node)
9806 return error_mark_node;
9808 if (declarator->u.function.late_return_type)
9809 late_return_type_p = true;
9811 if (ctype == NULL_TREE
9812 && decl_context == FIELD
9813 && funcdecl_p
9814 && friendp == 0)
9815 ctype = current_class_type;
9817 if (ctype && (sfk == sfk_constructor
9818 || sfk == sfk_destructor))
9820 /* We are within a class's scope. If our declarator name
9821 is the same as the class name, and we are defining
9822 a function, then it is a constructor/destructor, and
9823 therefore returns a void type. */
9825 /* ISO C++ 12.4/2. A destructor may not be declared
9826 const or volatile. A destructor may not be static.
9827 A destructor may not be declared with ref-qualifier.
9829 ISO C++ 12.1. A constructor may not be declared
9830 const or volatile. A constructor may not be
9831 virtual. A constructor may not be static.
9832 A constructor may not be declared with ref-qualifier. */
9833 if (staticp == 2)
9834 error ((flags == DTOR_FLAG)
9835 ? G_("destructor cannot be static member function")
9836 : G_("constructor cannot be static member function"));
9837 if (memfn_quals)
9839 error ((flags == DTOR_FLAG)
9840 ? G_("destructors may not be cv-qualified")
9841 : G_("constructors may not be cv-qualified"));
9842 memfn_quals = TYPE_UNQUALIFIED;
9845 if (rqual)
9847 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER);
9848 error ((flags == DTOR_FLAG)
9849 ? "destructors may not be ref-qualified"
9850 : "constructors may not be ref-qualified");
9851 rqual = REF_QUAL_NONE;
9854 if (decl_context == FIELD
9855 && !member_function_or_else (ctype,
9856 current_class_type,
9857 flags))
9858 return error_mark_node;
9860 if (flags != DTOR_FLAG)
9862 /* It's a constructor. */
9863 if (explicitp == 1)
9864 explicitp = 2;
9865 if (virtualp)
9867 permerror (input_location, "constructors cannot be declared virtual");
9868 virtualp = 0;
9870 if (decl_context == FIELD
9871 && sfk != sfk_constructor)
9872 return error_mark_node;
9874 if (decl_context == FIELD)
9875 staticp = 0;
9877 else if (friendp)
9879 if (virtualp)
9881 /* Cannot be both friend and virtual. */
9882 error ("virtual functions cannot be friends");
9883 friendp = 0;
9885 if (decl_context == NORMAL)
9886 error ("friend declaration not in class definition");
9887 if (current_function_decl && funcdef_flag)
9888 error ("can%'t define friend function %qs in a local "
9889 "class definition",
9890 name);
9892 else if (ctype && sfk == sfk_conversion)
9894 if (explicitp == 1)
9896 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION);
9897 explicitp = 2;
9899 if (late_return_type_p)
9900 error ("a conversion function cannot have a trailing return type");
9903 arg_types = grokparms (declarator->u.function.parameters,
9904 &parms);
9906 if (inner_declarator
9907 && inner_declarator->kind == cdk_id
9908 && inner_declarator->u.id.sfk == sfk_destructor
9909 && arg_types != void_list_node)
9911 error ("destructors may not have parameters");
9912 arg_types = void_list_node;
9913 parms = NULL_TREE;
9916 type = build_function_type (type, arg_types);
9917 if (declarator->std_attributes)
9918 /* [dcl.fct]/2:
9920 The optional attribute-specifier-seq appertains to
9921 the function type. */
9922 decl_attributes (&type, declarator->std_attributes,
9925 break;
9927 case cdk_pointer:
9928 case cdk_reference:
9929 case cdk_ptrmem:
9930 /* Filter out pointers-to-references and references-to-references.
9931 We can get these if a TYPE_DECL is used. */
9933 if (TREE_CODE (type) == REFERENCE_TYPE)
9935 if (declarator->kind != cdk_reference)
9937 error ("cannot declare pointer to %q#T", type);
9938 type = TREE_TYPE (type);
9941 /* In C++0x, we allow reference to reference declarations
9942 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9943 and template type arguments [14.3.1/4 temp.arg.type]. The
9944 check for direct reference to reference declarations, which
9945 are still forbidden, occurs below. Reasoning behind the change
9946 can be found in DR106, DR540, and the rvalue reference
9947 proposals. */
9948 else if (cxx_dialect == cxx98)
9950 error ("cannot declare reference to %q#T", type);
9951 type = TREE_TYPE (type);
9954 else if (VOID_TYPE_P (type))
9956 if (declarator->kind == cdk_reference)
9957 error ("cannot declare reference to %q#T", type);
9958 else if (declarator->kind == cdk_ptrmem)
9959 error ("cannot declare pointer to %q#T member", type);
9962 /* We now know that the TYPE_QUALS don't apply to the decl,
9963 but to the target of the pointer. */
9964 type_quals = TYPE_UNQUALIFIED;
9966 /* This code used to handle METHOD_TYPE, but I don't think it's
9967 possible to get it here anymore. */
9968 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9969 if (declarator->kind == cdk_ptrmem
9970 && TREE_CODE (type) == FUNCTION_TYPE)
9972 memfn_quals |= type_memfn_quals (type);
9973 type = build_memfn_type (type,
9974 declarator->u.pointer.class_type,
9975 memfn_quals,
9976 rqual);
9977 if (type == error_mark_node)
9978 return error_mark_node;
9980 rqual = REF_QUAL_NONE;
9981 memfn_quals = TYPE_UNQUALIFIED;
9984 if (TREE_CODE (type) == FUNCTION_TYPE
9985 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
9986 || type_memfn_rqual (type) != REF_QUAL_NONE))
9987 error (declarator->kind == cdk_reference
9988 ? G_("cannot declare reference to qualified function type %qT")
9989 : G_("cannot declare pointer to qualified function type %qT"),
9990 type);
9992 /* When the pointed-to type involves components of variable size,
9993 care must be taken to ensure that the size evaluation code is
9994 emitted early enough to dominate all the possible later uses
9995 and late enough for the variables on which it depends to have
9996 been assigned.
9998 This is expected to happen automatically when the pointed-to
9999 type has a name/declaration of it's own, but special attention
10000 is required if the type is anonymous.
10002 We handle the NORMAL and FIELD contexts here by inserting a
10003 dummy statement that just evaluates the size at a safe point
10004 and ensures it is not deferred until e.g. within a deeper
10005 conditional context (c++/43555).
10007 We expect nothing to be needed here for PARM or TYPENAME.
10008 Evaluating the size at this point for TYPENAME would
10009 actually be incorrect, as we might be in the middle of an
10010 expression with side effects on the pointed-to type size
10011 "arguments" prior to the pointer declaration point and the
10012 size evaluation could end up prior to the side effects. */
10014 if (!TYPE_NAME (type)
10015 && (decl_context == NORMAL || decl_context == FIELD)
10016 && at_function_scope_p ()
10017 && variably_modified_type_p (type, NULL_TREE))
10018 /* Force evaluation of the SAVE_EXPR. */
10019 finish_expr_stmt (TYPE_SIZE (type));
10021 if (declarator->kind == cdk_reference)
10023 /* In C++0x, the type we are creating a reference to might be
10024 a typedef which is itself a reference type. In that case,
10025 we follow the reference collapsing rules in
10026 [7.1.3/8 dcl.typedef] to create the final reference type:
10028 "If a typedef TD names a type that is a reference to a type
10029 T, an attempt to create the type 'lvalue reference to cv TD'
10030 creates the type 'lvalue reference to T,' while an attempt
10031 to create the type "rvalue reference to cv TD' creates the
10032 type TD."
10034 if (VOID_TYPE_P (type))
10035 /* We already gave an error. */;
10036 else if (TREE_CODE (type) == REFERENCE_TYPE)
10038 if (declarator->u.reference.rvalue_ref)
10039 /* Leave type alone. */;
10040 else
10041 type = cp_build_reference_type (TREE_TYPE (type), false);
10043 else
10044 type = cp_build_reference_type
10045 (type, declarator->u.reference.rvalue_ref);
10047 /* In C++0x, we need this check for direct reference to
10048 reference declarations, which are forbidden by
10049 [8.3.2/5 dcl.ref]. Reference to reference declarations
10050 are only allowed indirectly through typedefs and template
10051 type arguments. Example:
10053 void foo(int & &); // invalid ref-to-ref decl
10055 typedef int & int_ref;
10056 void foo(int_ref &); // valid ref-to-ref decl
10058 if (inner_declarator && inner_declarator->kind == cdk_reference)
10059 error ("cannot declare reference to %q#T, which is not "
10060 "a typedef or a template type argument", type);
10062 else if (TREE_CODE (type) == METHOD_TYPE)
10063 type = build_ptrmemfunc_type (build_pointer_type (type));
10064 else if (declarator->kind == cdk_ptrmem)
10066 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
10067 != NAMESPACE_DECL);
10068 if (declarator->u.pointer.class_type == error_mark_node)
10069 /* We will already have complained. */
10070 type = error_mark_node;
10071 else
10072 type = build_ptrmem_type (declarator->u.pointer.class_type,
10073 type);
10075 else
10076 type = build_pointer_type (type);
10078 /* Process a list of type modifier keywords (such as
10079 const or volatile) that were given inside the `*' or `&'. */
10081 if (declarator->u.pointer.qualifiers)
10083 type
10084 = cp_build_qualified_type (type,
10085 declarator->u.pointer.qualifiers);
10086 type_quals = cp_type_quals (type);
10089 /* Apply C++11 attributes to the pointer, and not to the
10090 type pointed to. This is unlike what is done for GNU
10091 attributes above. It is to comply with [dcl.ptr]/1:
10093 [the optional attribute-specifier-seq (7.6.1) appertains
10094 to the pointer and not to the object pointed to]. */
10095 if (declarator->std_attributes)
10096 decl_attributes (&type, declarator->std_attributes,
10099 ctype = NULL_TREE;
10100 break;
10102 case cdk_error:
10103 break;
10105 default:
10106 gcc_unreachable ();
10110 /* A `constexpr' specifier used in an object declaration declares
10111 the object as `const'. */
10112 if (constexpr_p && innermost_code != cdk_function)
10114 /* DR1688 says that a `constexpr' specifier in combination with
10115 `volatile' is valid. */
10117 if (TREE_CODE (type) != REFERENCE_TYPE)
10119 type_quals |= TYPE_QUAL_CONST;
10120 type = cp_build_qualified_type (type, type_quals);
10124 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
10125 && TREE_CODE (type) != FUNCTION_TYPE
10126 && TREE_CODE (type) != METHOD_TYPE
10127 && !variable_template_p (TREE_OPERAND (unqualified_id, 0)))
10129 error ("template-id %qD used as a declarator",
10130 unqualified_id);
10131 unqualified_id = dname;
10134 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10135 qualified with a class-name, turn it into a METHOD_TYPE, unless
10136 we know that the function is static. We take advantage of this
10137 opportunity to do other processing that pertains to entities
10138 explicitly declared to be class members. Note that if DECLARATOR
10139 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10140 would not have exited the loop above. */
10141 if (declarator
10142 && declarator->u.id.qualifying_scope
10143 && MAYBE_CLASS_TYPE_P (declarator->u.id.qualifying_scope))
10145 ctype = declarator->u.id.qualifying_scope;
10146 ctype = TYPE_MAIN_VARIANT (ctype);
10147 template_count = num_template_headers_for_class (ctype);
10149 if (ctype == current_class_type)
10151 if (friendp)
10153 permerror (input_location, "member functions are implicitly friends of their class");
10154 friendp = 0;
10156 else
10157 permerror (declarator->id_loc,
10158 "extra qualification %<%T::%> on member %qs",
10159 ctype, name);
10161 else if (/* If the qualifying type is already complete, then we
10162 can skip the following checks. */
10163 !COMPLETE_TYPE_P (ctype)
10164 && (/* If the function is being defined, then
10165 qualifying type must certainly be complete. */
10166 funcdef_flag
10167 /* A friend declaration of "T::f" is OK, even if
10168 "T" is a template parameter. But, if this
10169 function is not a friend, the qualifying type
10170 must be a class. */
10171 || (!friendp && !CLASS_TYPE_P (ctype))
10172 /* For a declaration, the type need not be
10173 complete, if either it is dependent (since there
10174 is no meaningful definition of complete in that
10175 case) or the qualifying class is currently being
10176 defined. */
10177 || !(dependent_type_p (ctype)
10178 || currently_open_class (ctype)))
10179 /* Check that the qualifying type is complete. */
10180 && !complete_type_or_else (ctype, NULL_TREE))
10181 return error_mark_node;
10182 else if (TREE_CODE (type) == FUNCTION_TYPE)
10184 if (current_class_type
10185 && (!friendp || funcdef_flag))
10187 error (funcdef_flag
10188 ? G_("cannot define member function %<%T::%s%> "
10189 "within %<%T%>")
10190 : G_("cannot declare member function %<%T::%s%> "
10191 "within %<%T%>"),
10192 ctype, name, current_class_type);
10193 return error_mark_node;
10196 else if (typedef_p && current_class_type)
10198 error ("cannot declare member %<%T::%s%> within %qT",
10199 ctype, name, current_class_type);
10200 return error_mark_node;
10204 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0)
10205 ctype = current_class_type;
10207 /* Now TYPE has the actual type. */
10209 if (returned_attrs)
10211 if (attrlist)
10212 *attrlist = chainon (returned_attrs, *attrlist);
10213 else
10214 attrlist = &returned_attrs;
10217 if (declarator
10218 && declarator->kind == cdk_id
10219 && declarator->std_attributes)
10220 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10221 a declarator-id appertains to the entity that is declared. */
10222 *attrlist = chainon (*attrlist, declarator->std_attributes);
10224 /* Handle parameter packs. */
10225 if (parameter_pack_p)
10227 if (decl_context == PARM)
10228 /* Turn the type into a pack expansion.*/
10229 type = make_pack_expansion (type);
10230 else
10231 error ("non-parameter %qs cannot be a parameter pack", name);
10234 /* Did array size calculations overflow or does the array cover more
10235 than half of the address-space? */
10236 if (TREE_CODE (type) == ARRAY_TYPE
10237 && COMPLETE_TYPE_P (type)
10238 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
10239 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type)))
10241 error ("size of array %qs is too large", name);
10242 /* If we proceed with the array type as it is, we'll eventually
10243 crash in tree_to_[su]hwi(). */
10244 type = error_mark_node;
10247 if ((decl_context == FIELD || decl_context == PARM)
10248 && !processing_template_decl
10249 && variably_modified_type_p (type, NULL_TREE))
10251 if (decl_context == FIELD)
10252 error ("data member may not have variably modified type %qT", type);
10253 else
10254 error ("parameter may not have variably modified type %qT", type);
10255 type = error_mark_node;
10258 if (explicitp == 1 || (explicitp && friendp))
10260 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10261 in the declaration of a constructor or conversion function within
10262 a class definition. */
10263 if (!current_class_type)
10264 error_at (declspecs->locations[ds_explicit],
10265 "%<explicit%> outside class declaration");
10266 else if (friendp)
10267 error_at (declspecs->locations[ds_explicit],
10268 "%<explicit%> in friend declaration");
10269 else
10270 error_at (declspecs->locations[ds_explicit],
10271 "only declarations of constructors and conversion operators "
10272 "can be %<explicit%>");
10273 explicitp = 0;
10276 if (storage_class == sc_mutable)
10278 if (decl_context != FIELD || friendp)
10280 error ("non-member %qs cannot be declared %<mutable%>", name);
10281 storage_class = sc_none;
10283 else if (decl_context == TYPENAME || typedef_p)
10285 error ("non-object member %qs cannot be declared %<mutable%>", name);
10286 storage_class = sc_none;
10288 else if (TREE_CODE (type) == FUNCTION_TYPE
10289 || TREE_CODE (type) == METHOD_TYPE)
10291 error ("function %qs cannot be declared %<mutable%>", name);
10292 storage_class = sc_none;
10294 else if (staticp)
10296 error ("static %qs cannot be declared %<mutable%>", name);
10297 storage_class = sc_none;
10299 else if (type_quals & TYPE_QUAL_CONST)
10301 error ("const %qs cannot be declared %<mutable%>", name);
10302 storage_class = sc_none;
10304 else if (TREE_CODE (type) == REFERENCE_TYPE)
10306 permerror (input_location, "reference %qs cannot be declared "
10307 "%<mutable%>", name);
10308 storage_class = sc_none;
10312 /* If this is declaring a typedef name, return a TYPE_DECL. */
10313 if (typedef_p && decl_context != TYPENAME)
10315 tree decl;
10317 /* Note that the grammar rejects storage classes
10318 in typenames, fields or parameters. */
10319 if (current_lang_name == lang_name_java)
10320 TYPE_FOR_JAVA (type) = 1;
10322 /* This declaration:
10324 typedef void f(int) const;
10326 declares a function type which is not a member of any
10327 particular class, but which is cv-qualified; for
10328 example "f S::*" declares a pointer to a const-qualified
10329 member function of S. We record the cv-qualification in the
10330 function type. */
10331 if ((rqual || memfn_quals) && TREE_CODE (type) == FUNCTION_TYPE)
10333 type = apply_memfn_quals (type, memfn_quals, rqual);
10335 /* We have now dealt with these qualifiers. */
10336 memfn_quals = TYPE_UNQUALIFIED;
10337 rqual = REF_QUAL_NONE;
10340 if (type_uses_auto (type))
10342 error ("typedef declared %<auto%>");
10343 type = error_mark_node;
10346 if (decl_context == FIELD)
10347 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
10348 else
10349 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
10350 if (id_declarator && declarator->u.id.qualifying_scope) {
10351 error_at (DECL_SOURCE_LOCATION (decl),
10352 "typedef name may not be a nested-name-specifier");
10353 TREE_TYPE (decl) = error_mark_node;
10356 if (decl_context != FIELD)
10358 if (!current_function_decl)
10359 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10360 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
10361 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10362 (current_function_decl)))
10363 /* The TYPE_DECL is "abstract" because there will be
10364 clones of this constructor/destructor, and there will
10365 be copies of this TYPE_DECL generated in those
10366 clones. The decloning optimization (for space) may
10367 revert this subsequently if it determines that
10368 the clones should share a common implementation. */
10369 DECL_ABSTRACT_P (decl) = true;
10371 else if (current_class_type
10372 && constructor_name_p (unqualified_id, current_class_type))
10373 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
10374 "as enclosing class",
10375 unqualified_id);
10377 /* If the user declares "typedef struct {...} foo" then the
10378 struct will have an anonymous name. Fill that name in now.
10379 Nothing can refer to it, so nothing needs know about the name
10380 change. */
10381 if (type != error_mark_node
10382 && unqualified_id
10383 && TYPE_NAME (type)
10384 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10385 && TYPE_ANONYMOUS_P (type)
10386 && declspecs->type_definition_p
10387 && attributes_naming_typedef_ok (*attrlist)
10388 && cp_type_quals (type) == TYPE_UNQUALIFIED)
10390 tree t;
10392 /* Replace the anonymous name with the real name everywhere. */
10393 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10395 if (anon_aggrname_p (TYPE_IDENTIFIER (t)))
10396 /* We do not rename the debug info representing the
10397 anonymous tagged type because the standard says in
10398 [dcl.typedef] that the naming applies only for
10399 linkage purposes. */
10400 /*debug_hooks->set_name (t, decl);*/
10401 TYPE_NAME (t) = decl;
10404 if (TYPE_LANG_SPECIFIC (type))
10405 TYPE_WAS_ANONYMOUS (type) = 1;
10407 /* If this is a typedef within a template class, the nested
10408 type is a (non-primary) template. The name for the
10409 template needs updating as well. */
10410 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10411 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10412 = TYPE_IDENTIFIER (type);
10414 /* Adjust linkage now that we aren't anonymous anymore. */
10415 reset_type_linkage (type);
10417 /* FIXME remangle member functions; member functions of a
10418 type with external linkage have external linkage. */
10421 if (signed_p
10422 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10423 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10425 bad_specifiers (decl, BSP_TYPE, virtualp,
10426 memfn_quals != TYPE_UNQUALIFIED,
10427 inlinep, friendp, raises != NULL_TREE);
10429 if (decl_spec_seq_has_spec_p (declspecs, ds_alias))
10430 /* Acknowledge that this was written:
10431 `using analias = atype;'. */
10432 TYPE_DECL_ALIAS_P (decl) = 1;
10434 return decl;
10437 /* Detect the case of an array type of unspecified size
10438 which came, as such, direct from a typedef name.
10439 We must copy the type, so that the array's domain can be
10440 individually set by the object's initializer. */
10442 if (type && typedef_type
10443 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
10444 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
10445 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
10447 /* Detect where we're using a typedef of function type to declare a
10448 function. PARMS will not be set, so we must create it now. */
10450 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
10452 tree decls = NULL_TREE;
10453 tree args;
10455 for (args = TYPE_ARG_TYPES (type);
10456 args && args != void_list_node;
10457 args = TREE_CHAIN (args))
10459 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
10461 DECL_CHAIN (decl) = decls;
10462 decls = decl;
10465 parms = nreverse (decls);
10467 if (decl_context != TYPENAME)
10469 /* The qualifiers on the function type become the qualifiers on
10470 the non-static member function. */
10471 memfn_quals |= type_memfn_quals (type);
10472 rqual = type_memfn_rqual (type);
10473 type_quals = TYPE_UNQUALIFIED;
10477 /* If this is a type name (such as, in a cast or sizeof),
10478 compute the type and return it now. */
10480 if (decl_context == TYPENAME)
10482 /* Note that here we don't care about type_quals. */
10484 /* Special case: "friend class foo" looks like a TYPENAME context. */
10485 if (friendp)
10487 if (inlinep)
10489 error ("%<inline%> specified for friend class declaration");
10490 inlinep = 0;
10493 if (!current_aggr)
10495 /* Don't allow friend declaration without a class-key. */
10496 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10497 permerror (input_location, "template parameters cannot be friends");
10498 else if (TREE_CODE (type) == TYPENAME_TYPE)
10499 permerror (input_location, "friend declaration requires class-key, "
10500 "i.e. %<friend class %T::%D%>",
10501 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
10502 else
10503 permerror (input_location, "friend declaration requires class-key, "
10504 "i.e. %<friend %#T%>",
10505 type);
10508 /* Only try to do this stuff if we didn't already give up. */
10509 if (type != integer_type_node)
10511 /* A friendly class? */
10512 if (current_class_type)
10513 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
10514 /*complain=*/true);
10515 else
10516 error ("trying to make class %qT a friend of global scope",
10517 type);
10519 type = void_type_node;
10522 else if (memfn_quals || rqual)
10524 if (ctype == NULL_TREE
10525 && TREE_CODE (type) == METHOD_TYPE)
10526 ctype = TYPE_METHOD_BASETYPE (type);
10528 if (ctype)
10529 type = build_memfn_type (type, ctype, memfn_quals, rqual);
10530 /* Core issue #547: need to allow this in template type args.
10531 Allow it in general in C++11 for alias-declarations. */
10532 else if ((template_type_arg || cxx_dialect >= cxx11)
10533 && TREE_CODE (type) == FUNCTION_TYPE)
10534 type = apply_memfn_quals (type, memfn_quals, rqual);
10535 else
10536 error ("invalid qualifiers on non-member function type");
10539 return type;
10541 else if (unqualified_id == NULL_TREE && decl_context != PARM
10542 && decl_context != CATCHPARM
10543 && TREE_CODE (type) != UNION_TYPE
10544 && ! bitfield)
10546 error ("abstract declarator %qT used as declaration", type);
10547 return error_mark_node;
10550 /* Only functions may be declared using an operator-function-id. */
10551 if (unqualified_id
10552 && IDENTIFIER_OPNAME_P (unqualified_id)
10553 && TREE_CODE (type) != FUNCTION_TYPE
10554 && TREE_CODE (type) != METHOD_TYPE)
10556 error ("declaration of %qD as non-function", unqualified_id);
10557 return error_mark_node;
10560 /* We don't check parameter types here because we can emit a better
10561 error message later. */
10562 if (decl_context != PARM)
10564 type = check_var_type (unqualified_id, type);
10565 if (type == error_mark_node)
10566 return error_mark_node;
10569 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10570 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10572 if (decl_context == PARM || decl_context == CATCHPARM)
10574 if (ctype || in_namespace)
10575 error ("cannot use %<::%> in parameter declaration");
10577 if (type_uses_auto (type))
10579 if (cxx_dialect >= cxx14)
10580 error ("%<auto%> parameter not permitted in this context");
10581 else
10582 error ("parameter declared %<auto%>");
10583 type = error_mark_node;
10586 /* A parameter declared as an array of T is really a pointer to T.
10587 One declared as a function is really a pointer to a function.
10588 One declared as a member is really a pointer to member. */
10590 if (TREE_CODE (type) == ARRAY_TYPE)
10592 /* Transfer const-ness of array into that of type pointed to. */
10593 type = build_pointer_type (TREE_TYPE (type));
10594 type_quals = TYPE_UNQUALIFIED;
10595 array_parameter_p = true;
10597 else if (TREE_CODE (type) == FUNCTION_TYPE)
10598 type = build_pointer_type (type);
10601 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
10602 && !NEW_DELETE_OPNAME_P (unqualified_id))
10604 cp_cv_quals real_quals = memfn_quals;
10605 if (cxx_dialect < cxx14 && constexpr_p
10606 && sfk != sfk_constructor && sfk != sfk_destructor)
10607 real_quals |= TYPE_QUAL_CONST;
10608 type = build_memfn_type (type, ctype, real_quals, rqual);
10612 tree decl;
10614 if (decl_context == PARM)
10616 decl = cp_build_parm_decl (unqualified_id, type);
10617 DECL_ARRAY_PARAMETER_P (decl) = array_parameter_p;
10619 bad_specifiers (decl, BSP_PARM, virtualp,
10620 memfn_quals != TYPE_UNQUALIFIED,
10621 inlinep, friendp, raises != NULL_TREE);
10623 else if (decl_context == FIELD)
10625 if (!staticp && !friendp && TREE_CODE (type) != METHOD_TYPE
10626 && type_uses_auto (type))
10628 error ("non-static data member declared %<auto%>");
10629 type = error_mark_node;
10632 /* The C99 flexible array extension. */
10633 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
10634 && TYPE_DOMAIN (type) == NULL_TREE)
10636 tree itype = compute_array_index_type (dname, integer_zero_node,
10637 tf_warning_or_error);
10638 type = build_cplus_array_type (TREE_TYPE (type), itype);
10641 if (type == error_mark_node)
10643 /* Happens when declaring arrays of sizes which
10644 are error_mark_node, for example. */
10645 decl = NULL_TREE;
10647 else if (in_namespace && !friendp)
10649 /* Something like struct S { int N::j; }; */
10650 error ("invalid use of %<::%>");
10651 return error_mark_node;
10653 else if (TREE_CODE (type) == FUNCTION_TYPE
10654 || TREE_CODE (type) == METHOD_TYPE)
10656 int publicp = 0;
10657 tree function_context;
10659 if (friendp == 0)
10661 /* This should never happen in pure C++ (the check
10662 could be an assert). It could happen in
10663 Objective-C++ if someone writes invalid code that
10664 uses a function declaration for an instance
10665 variable or property (instance variables and
10666 properties are parsed as FIELD_DECLs, but they are
10667 part of an Objective-C class, not a C++ class).
10668 That code is invalid and is caught by this
10669 check. */
10670 if (!ctype)
10672 error ("declaration of function %qD in invalid context",
10673 unqualified_id);
10674 return error_mark_node;
10677 /* ``A union may [ ... ] not [ have ] virtual functions.''
10678 ARM 9.5 */
10679 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10681 error ("function %qD declared virtual inside a union",
10682 unqualified_id);
10683 return error_mark_node;
10686 if (NEW_DELETE_OPNAME_P (unqualified_id))
10688 if (virtualp)
10690 error ("%qD cannot be declared virtual, since it "
10691 "is always static",
10692 unqualified_id);
10693 virtualp = 0;
10698 /* Check that the name used for a destructor makes sense. */
10699 if (sfk == sfk_destructor)
10701 tree uqname = id_declarator->u.id.unqualified_name;
10703 if (!ctype)
10705 gcc_assert (friendp);
10706 error ("expected qualified name in friend declaration "
10707 "for destructor %qD", uqname);
10708 return error_mark_node;
10711 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
10713 error ("declaration of %qD as member of %qT",
10714 uqname, ctype);
10715 return error_mark_node;
10717 if (constexpr_p)
10719 error ("a destructor cannot be %<constexpr%>");
10720 return error_mark_node;
10723 else if (sfk == sfk_constructor && friendp && !ctype)
10725 error ("expected qualified name in friend declaration "
10726 "for constructor %qD",
10727 id_declarator->u.id.unqualified_name);
10728 return error_mark_node;
10731 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
10733 tree tmpl = TREE_OPERAND (unqualified_id, 0);
10734 if (variable_template_p (tmpl))
10736 error ("specialization of variable template %qD "
10737 "declared as function", tmpl);
10738 inform (DECL_SOURCE_LOCATION (tmpl),
10739 "variable template declared here");
10740 return error_mark_node;
10744 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10745 function_context = (ctype != NULL_TREE) ?
10746 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10747 publicp = (! friendp || ! staticp)
10748 && function_context == NULL_TREE;
10750 if (late_return_type_p)
10751 TYPE_HAS_LATE_RETURN_TYPE (type) = 1;
10753 decl = grokfndecl (ctype, type,
10754 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
10755 ? unqualified_id : dname,
10756 parms,
10757 unqualified_id,
10758 virtualp, flags, memfn_quals, rqual, raises,
10759 friendp ? -1 : 0, friendp, publicp,
10760 inlinep | (2 * constexpr_p),
10761 initialized == SD_DELETED, sfk,
10762 funcdef_flag, template_count, in_namespace,
10763 attrlist, declarator->id_loc);
10764 decl = set_virt_specifiers (decl, virt_specifiers);
10765 if (decl == NULL_TREE)
10766 return error_mark_node;
10767 #if 0
10768 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10769 /* The decl and setting of decl_attr is also turned off. */
10770 decl = build_decl_attribute_variant (decl, decl_attr);
10771 #endif
10773 /* [class.conv.ctor]
10775 A constructor declared without the function-specifier
10776 explicit that can be called with a single parameter
10777 specifies a conversion from the type of its first
10778 parameter to the type of its class. Such a constructor
10779 is called a converting constructor. */
10780 if (explicitp == 2)
10781 DECL_NONCONVERTING_P (decl) = 1;
10783 else if (!staticp && !dependent_type_p (type)
10784 && !COMPLETE_TYPE_P (complete_type (type))
10785 && (TREE_CODE (type) != ARRAY_TYPE
10786 || !COMPLETE_TYPE_P (TREE_TYPE (type))
10787 || initialized == 0))
10789 if (unqualified_id)
10791 error ("field %qD has incomplete type %qT",
10792 unqualified_id, type);
10793 cxx_incomplete_type_inform (strip_array_types (type));
10795 else
10796 error ("name %qT has incomplete type", type);
10798 type = error_mark_node;
10799 decl = NULL_TREE;
10801 else
10803 if (friendp)
10805 error ("%qE is neither function nor member function; "
10806 "cannot be declared friend", unqualified_id);
10807 friendp = 0;
10809 decl = NULL_TREE;
10812 if (friendp)
10814 /* Friends are treated specially. */
10815 if (ctype == current_class_type)
10816 ; /* We already issued a permerror. */
10817 else if (decl && DECL_NAME (decl))
10819 if (template_class_depth (current_class_type) == 0)
10821 decl = check_explicit_specialization
10822 (unqualified_id, decl, template_count,
10823 2 * funcdef_flag + 4);
10824 if (decl == error_mark_node)
10825 return error_mark_node;
10828 decl = do_friend (ctype, unqualified_id, decl,
10829 *attrlist, flags,
10830 funcdef_flag);
10831 return decl;
10833 else
10834 return error_mark_node;
10837 /* Structure field. It may not be a function, except for C++. */
10839 if (decl == NULL_TREE)
10841 if (staticp)
10843 /* C++ allows static class members. All other work
10844 for this is done by grokfield. */
10845 decl = build_lang_decl_loc (declarator
10846 ? declarator->id_loc
10847 : input_location,
10848 VAR_DECL, unqualified_id, type);
10849 set_linkage_for_static_data_member (decl);
10850 /* Even if there is an in-class initialization, DECL
10851 is considered undefined until an out-of-class
10852 definition is provided. */
10853 DECL_EXTERNAL (decl) = 1;
10855 if (thread_p)
10857 set_decl_tls_model (decl, decl_default_tls_model (decl));
10858 if (declspecs->gnu_thread_keyword_p)
10859 DECL_GNU_TLS_P (decl) = true;
10862 if (constexpr_p && !initialized)
10864 error ("constexpr static data member %qD must have an "
10865 "initializer", decl);
10866 constexpr_p = false;
10869 else
10871 if (constexpr_p)
10873 error ("non-static data member %qE declared %<constexpr%>",
10874 unqualified_id);
10875 constexpr_p = false;
10877 decl = build_decl (input_location,
10878 FIELD_DECL, unqualified_id, type);
10879 DECL_NONADDRESSABLE_P (decl) = bitfield;
10880 if (bitfield && !unqualified_id)
10881 TREE_NO_WARNING (decl) = 1;
10883 if (storage_class == sc_mutable)
10885 DECL_MUTABLE_P (decl) = 1;
10886 storage_class = sc_none;
10889 if (initialized)
10891 /* An attempt is being made to initialize a non-static
10892 member. This is new in C++11. */
10893 maybe_warn_cpp0x (CPP0X_NSDMI);
10895 /* If this has been parsed with static storage class, but
10896 errors forced staticp to be cleared, ensure NSDMI is
10897 not present. */
10898 if (declspecs->storage_class == sc_static)
10899 DECL_INITIAL (decl) = error_mark_node;
10903 bad_specifiers (decl, BSP_FIELD, virtualp,
10904 memfn_quals != TYPE_UNQUALIFIED,
10905 inlinep, friendp, raises != NULL_TREE);
10908 else if (TREE_CODE (type) == FUNCTION_TYPE
10909 || TREE_CODE (type) == METHOD_TYPE)
10911 tree original_name;
10912 int publicp = 0;
10914 if (!unqualified_id)
10915 return error_mark_node;
10917 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
10918 original_name = dname;
10919 else
10920 original_name = unqualified_id;
10922 if (storage_class == sc_auto)
10923 error ("storage class %<auto%> invalid for function %qs", name);
10924 else if (storage_class == sc_register)
10925 error ("storage class %<register%> invalid for function %qs", name);
10926 else if (thread_p)
10928 if (declspecs->gnu_thread_keyword_p)
10929 error ("storage class %<__thread%> invalid for function %qs",
10930 name);
10931 else
10932 error ("storage class %<thread_local%> invalid for function %qs",
10933 name);
10936 if (virt_specifiers)
10937 error ("virt-specifiers in %qs not allowed outside a class definition", name);
10938 /* Function declaration not at top level.
10939 Storage classes other than `extern' are not allowed
10940 and `extern' makes no difference. */
10941 if (! toplevel_bindings_p ()
10942 && (storage_class == sc_static
10943 || decl_spec_seq_has_spec_p (declspecs, ds_inline))
10944 && pedantic)
10946 if (storage_class == sc_static)
10947 pedwarn (input_location, OPT_Wpedantic,
10948 "%<static%> specified invalid for function %qs "
10949 "declared out of global scope", name);
10950 else
10951 pedwarn (input_location, OPT_Wpedantic,
10952 "%<inline%> specifier invalid for function %qs "
10953 "declared out of global scope", name);
10956 if (ctype == NULL_TREE)
10958 if (virtualp)
10960 error ("virtual non-class function %qs", name);
10961 virtualp = 0;
10963 else if (sfk == sfk_constructor
10964 || sfk == sfk_destructor)
10966 error (funcdef_flag
10967 ? G_("%qs defined in a non-class scope")
10968 : G_("%qs declared in a non-class scope"), name);
10969 sfk = sfk_none;
10973 /* Record whether the function is public. */
10974 publicp = (ctype != NULL_TREE
10975 || storage_class != sc_static);
10977 if (late_return_type_p)
10978 TYPE_HAS_LATE_RETURN_TYPE (type) = 1;
10980 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
10981 virtualp, flags, memfn_quals, rqual, raises,
10982 1, friendp,
10983 publicp, inlinep | (2 * constexpr_p),
10984 initialized == SD_DELETED, sfk,
10985 funcdef_flag,
10986 template_count, in_namespace, attrlist,
10987 declarator->id_loc);
10988 if (decl == NULL_TREE)
10989 return error_mark_node;
10991 if (staticp == 1)
10993 int invalid_static = 0;
10995 /* Don't allow a static member function in a class, and forbid
10996 declaring main to be static. */
10997 if (TREE_CODE (type) == METHOD_TYPE)
10999 permerror (input_location, "cannot declare member function %qD to have "
11000 "static linkage", decl);
11001 invalid_static = 1;
11003 else if (current_function_decl)
11005 /* FIXME need arm citation */
11006 error ("cannot declare static function inside another function");
11007 invalid_static = 1;
11010 if (invalid_static)
11012 staticp = 0;
11013 storage_class = sc_none;
11017 else
11019 /* It's a variable. */
11021 /* An uninitialized decl with `extern' is a reference. */
11022 decl = grokvardecl (type, dname, unqualified_id,
11023 declspecs,
11024 initialized,
11025 (type_quals & TYPE_QUAL_CONST) != 0,
11026 template_count,
11027 ctype ? ctype : in_namespace);
11028 if (decl == NULL_TREE)
11029 return error_mark_node;
11031 bad_specifiers (decl, BSP_VAR, virtualp,
11032 memfn_quals != TYPE_UNQUALIFIED,
11033 inlinep, friendp, raises != NULL_TREE);
11035 if (ctype)
11037 DECL_CONTEXT (decl) = ctype;
11038 if (staticp == 1)
11040 permerror (input_location, "%<static%> may not be used when defining "
11041 "(as opposed to declaring) a static data member");
11042 staticp = 0;
11043 storage_class = sc_none;
11045 if (storage_class == sc_register && TREE_STATIC (decl))
11047 error ("static member %qD declared %<register%>", decl);
11048 storage_class = sc_none;
11050 if (storage_class == sc_extern && pedantic)
11052 pedwarn (input_location, OPT_Wpedantic,
11053 "cannot explicitly declare member %q#D to have "
11054 "extern linkage", decl);
11055 storage_class = sc_none;
11058 else if (constexpr_p && DECL_EXTERNAL (decl))
11060 error ("declaration of constexpr variable %qD is not a definition",
11061 decl);
11062 constexpr_p = false;
11066 if (storage_class == sc_extern && initialized && !funcdef_flag)
11068 if (toplevel_bindings_p ())
11070 /* It's common practice (and completely valid) to have a const
11071 be initialized and declared extern. */
11072 if (!(type_quals & TYPE_QUAL_CONST))
11073 warning (0, "%qs initialized and declared %<extern%>", name);
11075 else
11077 error ("%qs has both %<extern%> and initializer", name);
11078 return error_mark_node;
11082 /* Record `register' declaration for warnings on &
11083 and in case doing stupid register allocation. */
11085 if (storage_class == sc_register)
11086 DECL_REGISTER (decl) = 1;
11087 else if (storage_class == sc_extern)
11088 DECL_THIS_EXTERN (decl) = 1;
11089 else if (storage_class == sc_static)
11090 DECL_THIS_STATIC (decl) = 1;
11092 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11093 if (constexpr_p && VAR_P (decl))
11094 DECL_DECLARED_CONSTEXPR_P (decl) = true;
11096 /* Record constancy and volatility on the DECL itself . There's
11097 no need to do this when processing a template; we'll do this
11098 for the instantiated declaration based on the type of DECL. */
11099 if (!processing_template_decl)
11100 cp_apply_type_quals_to_decl (type_quals, decl);
11102 return decl;
11106 /* Subroutine of start_function. Ensure that each of the parameter
11107 types (as listed in PARMS) is complete, as is required for a
11108 function definition. */
11110 static void
11111 require_complete_types_for_parms (tree parms)
11113 for (; parms; parms = DECL_CHAIN (parms))
11115 if (dependent_type_p (TREE_TYPE (parms)))
11116 continue;
11117 if (!VOID_TYPE_P (TREE_TYPE (parms))
11118 && complete_type_or_else (TREE_TYPE (parms), parms))
11120 relayout_decl (parms);
11121 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
11123 else
11124 /* grokparms or complete_type_or_else will have already issued
11125 an error. */
11126 TREE_TYPE (parms) = error_mark_node;
11130 /* Returns nonzero if T is a local variable. */
11133 local_variable_p (const_tree t)
11135 if ((VAR_P (t)
11136 /* A VAR_DECL with a context that is a _TYPE is a static data
11137 member. */
11138 && !TYPE_P (CP_DECL_CONTEXT (t))
11139 /* Any other non-local variable must be at namespace scope. */
11140 && !DECL_NAMESPACE_SCOPE_P (t))
11141 || (TREE_CODE (t) == PARM_DECL))
11142 return 1;
11144 return 0;
11147 /* Like local_variable_p, but suitable for use as a tree-walking
11148 function. */
11150 static tree
11151 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
11152 void * /*data*/)
11154 if (local_variable_p (*tp)
11155 && (!DECL_ARTIFICIAL (*tp) || DECL_NAME (*tp) == this_identifier))
11156 return *tp;
11157 else if (TYPE_P (*tp))
11158 *walk_subtrees = 0;
11160 return NULL_TREE;
11163 /* Check that ARG, which is a default-argument expression for a
11164 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11165 something goes wrong. DECL may also be a _TYPE node, rather than a
11166 DECL, if there is no DECL available. */
11168 tree
11169 check_default_argument (tree decl, tree arg, tsubst_flags_t complain)
11171 tree var;
11172 tree decl_type;
11174 if (TREE_CODE (arg) == DEFAULT_ARG)
11175 /* We get a DEFAULT_ARG when looking at an in-class declaration
11176 with a default argument. Ignore the argument for now; we'll
11177 deal with it after the class is complete. */
11178 return arg;
11180 if (TYPE_P (decl))
11182 decl_type = decl;
11183 decl = NULL_TREE;
11185 else
11186 decl_type = TREE_TYPE (decl);
11188 if (arg == error_mark_node
11189 || decl == error_mark_node
11190 || TREE_TYPE (arg) == error_mark_node
11191 || decl_type == error_mark_node)
11192 /* Something already went wrong. There's no need to check
11193 further. */
11194 return error_mark_node;
11196 /* [dcl.fct.default]
11198 A default argument expression is implicitly converted to the
11199 parameter type. */
11200 ++cp_unevaluated_operand;
11201 perform_implicit_conversion_flags (decl_type, arg, complain,
11202 LOOKUP_IMPLICIT);
11203 --cp_unevaluated_operand;
11205 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
11206 the call sites. */
11207 if (TYPE_PTR_OR_PTRMEM_P (decl_type)
11208 && null_ptr_cst_p (arg))
11209 return nullptr_node;
11211 /* [dcl.fct.default]
11213 Local variables shall not be used in default argument
11214 expressions.
11216 The keyword `this' shall not be used in a default argument of a
11217 member function. */
11218 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
11219 if (var)
11221 if (complain & tf_warning_or_error)
11223 if (DECL_NAME (var) == this_identifier)
11224 permerror (input_location, "default argument %qE uses %qD",
11225 arg, var);
11226 else
11227 error ("default argument %qE uses local variable %qD", arg, var);
11229 return error_mark_node;
11232 /* All is well. */
11233 return arg;
11236 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11238 static tree
11239 type_is_deprecated (tree type)
11241 enum tree_code code;
11242 if (TREE_DEPRECATED (type))
11243 return type;
11244 if (TYPE_NAME (type)
11245 && TREE_DEPRECATED (TYPE_NAME (type)))
11246 return type;
11248 /* Do warn about using typedefs to a deprecated class. */
11249 if (OVERLOAD_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
11250 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
11252 code = TREE_CODE (type);
11254 if (code == POINTER_TYPE || code == REFERENCE_TYPE
11255 || code == OFFSET_TYPE || code == FUNCTION_TYPE
11256 || code == METHOD_TYPE || code == ARRAY_TYPE)
11257 return type_is_deprecated (TREE_TYPE (type));
11259 if (TYPE_PTRMEMFUNC_P (type))
11260 return type_is_deprecated
11261 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
11263 return NULL_TREE;
11266 /* Decode the list of parameter types for a function type.
11267 Given the list of things declared inside the parens,
11268 return a list of types.
11270 If this parameter does not end with an ellipsis, we append
11271 void_list_node.
11273 *PARMS is set to the chain of PARM_DECLs created. */
11275 static tree
11276 grokparms (tree parmlist, tree *parms)
11278 tree result = NULL_TREE;
11279 tree decls = NULL_TREE;
11280 tree parm;
11281 int any_error = 0;
11283 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
11285 tree type = NULL_TREE;
11286 tree init = TREE_PURPOSE (parm);
11287 tree decl = TREE_VALUE (parm);
11288 const char *errmsg;
11290 if (parm == void_list_node)
11291 break;
11293 if (! decl || TREE_TYPE (decl) == error_mark_node)
11294 continue;
11296 type = TREE_TYPE (decl);
11297 if (VOID_TYPE_P (type))
11299 if (same_type_p (type, void_type_node)
11300 && !init
11301 && !DECL_NAME (decl) && !result
11302 && TREE_CHAIN (parm) == void_list_node)
11303 /* DR 577: A parameter list consisting of a single
11304 unnamed parameter of non-dependent type 'void'. */
11305 break;
11306 else if (cv_qualified_p (type))
11307 error_at (DECL_SOURCE_LOCATION (decl),
11308 "invalid use of cv-qualified type %qT in "
11309 "parameter declaration", type);
11310 else
11311 error_at (DECL_SOURCE_LOCATION (decl),
11312 "invalid use of type %<void%> in parameter "
11313 "declaration");
11314 /* It's not a good idea to actually create parameters of
11315 type `void'; other parts of the compiler assume that a
11316 void type terminates the parameter list. */
11317 type = error_mark_node;
11318 TREE_TYPE (decl) = error_mark_node;
11321 if (type != error_mark_node
11322 && TYPE_FOR_JAVA (type)
11323 && MAYBE_CLASS_TYPE_P (type))
11325 error ("parameter %qD has Java class type", decl);
11326 type = error_mark_node;
11327 TREE_TYPE (decl) = error_mark_node;
11328 init = NULL_TREE;
11331 if (type != error_mark_node
11332 && (errmsg = targetm.invalid_parameter_type (type)))
11334 error (errmsg);
11335 type = error_mark_node;
11336 TREE_TYPE (decl) = error_mark_node;
11339 if (type != error_mark_node)
11341 if (deprecated_state != DEPRECATED_SUPPRESS)
11343 tree deptype = type_is_deprecated (type);
11344 if (deptype)
11345 warn_deprecated_use (deptype, NULL_TREE);
11348 /* Top-level qualifiers on the parameters are
11349 ignored for function types. */
11350 type = cp_build_qualified_type (type, 0);
11351 if (TREE_CODE (type) == METHOD_TYPE)
11353 error ("parameter %qD invalidly declared method type", decl);
11354 type = build_pointer_type (type);
11355 TREE_TYPE (decl) = type;
11357 else if (abstract_virtuals_error (decl, type))
11358 any_error = 1; /* Seems like a good idea. */
11359 else if (POINTER_TYPE_P (type))
11361 /* [dcl.fct]/6, parameter types cannot contain pointers
11362 (references) to arrays of unknown bound. */
11363 tree t = TREE_TYPE (type);
11364 int ptr = TYPE_PTR_P (type);
11366 while (1)
11368 if (TYPE_PTR_P (t))
11369 ptr = 1;
11370 else if (TREE_CODE (t) != ARRAY_TYPE)
11371 break;
11372 else if (!TYPE_DOMAIN (t))
11373 break;
11374 t = TREE_TYPE (t);
11376 if (TREE_CODE (t) == ARRAY_TYPE)
11377 error (ptr
11378 ? G_("parameter %qD includes pointer to array of "
11379 "unknown bound %qT")
11380 : G_("parameter %qD includes reference to array of "
11381 "unknown bound %qT"),
11382 decl, t);
11385 if (any_error)
11386 init = NULL_TREE;
11387 else if (init && !processing_template_decl)
11388 init = check_default_argument (decl, init, tf_warning_or_error);
11391 DECL_CHAIN (decl) = decls;
11392 decls = decl;
11393 result = tree_cons (init, type, result);
11395 decls = nreverse (decls);
11396 result = nreverse (result);
11397 if (parm)
11398 result = chainon (result, void_list_node);
11399 *parms = decls;
11401 return result;
11405 /* D is a constructor or overloaded `operator='.
11407 Let T be the class in which D is declared. Then, this function
11408 returns:
11410 -1 if D's is an ill-formed constructor or copy assignment operator
11411 whose first parameter is of type `T'.
11412 0 if D is not a copy constructor or copy assignment
11413 operator.
11414 1 if D is a copy constructor or copy assignment operator whose
11415 first parameter is a reference to non-const qualified T.
11416 2 if D is a copy constructor or copy assignment operator whose
11417 first parameter is a reference to const qualified T.
11419 This function can be used as a predicate. Positive values indicate
11420 a copy constructor and nonzero values indicate a copy assignment
11421 operator. */
11424 copy_fn_p (const_tree d)
11426 tree args;
11427 tree arg_type;
11428 int result = 1;
11430 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
11432 if (TREE_CODE (d) == TEMPLATE_DECL
11433 || (DECL_TEMPLATE_INFO (d)
11434 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
11435 /* Instantiations of template member functions are never copy
11436 functions. Note that member functions of templated classes are
11437 represented as template functions internally, and we must
11438 accept those as copy functions. */
11439 return 0;
11441 args = FUNCTION_FIRST_USER_PARMTYPE (d);
11442 if (!args)
11443 return 0;
11445 arg_type = TREE_VALUE (args);
11446 if (arg_type == error_mark_node)
11447 return 0;
11449 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
11451 /* Pass by value copy assignment operator. */
11452 result = -1;
11454 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
11455 && !TYPE_REF_IS_RVALUE (arg_type)
11456 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
11458 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
11459 result = 2;
11461 else
11462 return 0;
11464 args = TREE_CHAIN (args);
11466 if (args && args != void_list_node && !TREE_PURPOSE (args))
11467 /* There are more non-optional args. */
11468 return 0;
11470 return result;
11473 /* D is a constructor or overloaded `operator='.
11475 Let T be the class in which D is declared. Then, this function
11476 returns true when D is a move constructor or move assignment
11477 operator, false otherwise. */
11479 bool
11480 move_fn_p (const_tree d)
11482 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
11484 if (cxx_dialect == cxx98)
11485 /* There are no move constructors if we are in C++98 mode. */
11486 return false;
11488 if (TREE_CODE (d) == TEMPLATE_DECL
11489 || (DECL_TEMPLATE_INFO (d)
11490 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
11491 /* Instantiations of template member functions are never move
11492 functions. Note that member functions of templated classes are
11493 represented as template functions internally, and we must
11494 accept those as move functions. */
11495 return 0;
11497 return move_signature_fn_p (d);
11500 /* D is a constructor or overloaded `operator='.
11502 Then, this function returns true when D has the same signature as a move
11503 constructor or move assignment operator (because either it is such a
11504 ctor/op= or it is a template specialization with the same signature),
11505 false otherwise. */
11507 bool
11508 move_signature_fn_p (const_tree d)
11510 tree args;
11511 tree arg_type;
11512 bool result = false;
11514 args = FUNCTION_FIRST_USER_PARMTYPE (d);
11515 if (!args)
11516 return 0;
11518 arg_type = TREE_VALUE (args);
11519 if (arg_type == error_mark_node)
11520 return 0;
11522 if (TREE_CODE (arg_type) == REFERENCE_TYPE
11523 && TYPE_REF_IS_RVALUE (arg_type)
11524 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
11525 DECL_CONTEXT (d)))
11526 result = true;
11528 args = TREE_CHAIN (args);
11530 if (args && args != void_list_node && !TREE_PURPOSE (args))
11531 /* There are more non-optional args. */
11532 return false;
11534 return result;
11537 /* Remember any special properties of member function DECL. */
11539 void
11540 grok_special_member_properties (tree decl)
11542 tree class_type;
11544 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
11545 return;
11547 class_type = DECL_CONTEXT (decl);
11548 if (DECL_CONSTRUCTOR_P (decl))
11550 int ctor = copy_fn_p (decl);
11552 if (!DECL_ARTIFICIAL (decl))
11553 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
11555 if (ctor > 0)
11557 /* [class.copy]
11559 A non-template constructor for class X is a copy
11560 constructor if its first parameter is of type X&, const
11561 X&, volatile X& or const volatile X&, and either there
11562 are no other parameters or else all other parameters have
11563 default arguments. */
11564 TYPE_HAS_COPY_CTOR (class_type) = 1;
11565 if (user_provided_p (decl))
11566 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
11567 if (ctor > 1)
11568 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
11570 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
11571 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
11572 else if (move_fn_p (decl) && user_provided_p (decl))
11573 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1;
11574 else if (is_list_ctor (decl))
11575 TYPE_HAS_LIST_CTOR (class_type) = 1;
11577 if (DECL_DECLARED_CONSTEXPR_P (decl)
11578 && !copy_fn_p (decl) && !move_fn_p (decl))
11579 TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
11581 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
11583 /* [class.copy]
11585 A non-template assignment operator for class X is a copy
11586 assignment operator if its parameter is of type X, X&, const
11587 X&, volatile X& or const volatile X&. */
11589 int assop = copy_fn_p (decl);
11591 if (assop)
11593 TYPE_HAS_COPY_ASSIGN (class_type) = 1;
11594 if (user_provided_p (decl))
11595 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
11596 if (assop != 1)
11597 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
11599 else if (move_fn_p (decl) && user_provided_p (decl))
11600 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1;
11602 /* Destructors are handled in check_methods. */
11605 /* Check a constructor DECL has the correct form. Complains
11606 if the class has a constructor of the form X(X). */
11609 grok_ctor_properties (const_tree ctype, const_tree decl)
11611 int ctor_parm = copy_fn_p (decl);
11613 if (ctor_parm < 0)
11615 /* [class.copy]
11617 A declaration of a constructor for a class X is ill-formed if
11618 its first parameter is of type (optionally cv-qualified) X
11619 and either there are no other parameters or else all other
11620 parameters have default arguments.
11622 We *don't* complain about member template instantiations that
11623 have this form, though; they can occur as we try to decide
11624 what constructor to use during overload resolution. Since
11625 overload resolution will never prefer such a constructor to
11626 the non-template copy constructor (which is either explicitly
11627 or implicitly defined), there's no need to worry about their
11628 existence. Theoretically, they should never even be
11629 instantiated, but that's hard to forestall. */
11630 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11631 ctype, ctype);
11632 return 0;
11635 return 1;
11638 /* An operator with this code is unary, but can also be binary. */
11640 static int
11641 ambi_op_p (enum tree_code code)
11643 return (code == INDIRECT_REF
11644 || code == ADDR_EXPR
11645 || code == UNARY_PLUS_EXPR
11646 || code == NEGATE_EXPR
11647 || code == PREINCREMENT_EXPR
11648 || code == PREDECREMENT_EXPR);
11651 /* An operator with this name can only be unary. */
11653 static int
11654 unary_op_p (enum tree_code code)
11656 return (code == TRUTH_NOT_EXPR
11657 || code == BIT_NOT_EXPR
11658 || code == COMPONENT_REF
11659 || code == TYPE_EXPR);
11662 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11663 errors are issued for invalid declarations. */
11665 bool
11666 grok_op_properties (tree decl, bool complain)
11668 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11669 tree argtype;
11670 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11671 tree name = DECL_NAME (decl);
11672 enum tree_code operator_code;
11673 int arity;
11674 bool ellipsis_p;
11675 tree class_type;
11677 /* Count the number of arguments and check for ellipsis. */
11678 for (argtype = argtypes, arity = 0;
11679 argtype && argtype != void_list_node;
11680 argtype = TREE_CHAIN (argtype))
11681 ++arity;
11682 ellipsis_p = !argtype;
11684 class_type = DECL_CONTEXT (decl);
11685 if (class_type && !CLASS_TYPE_P (class_type))
11686 class_type = NULL_TREE;
11688 if (DECL_CONV_FN_P (decl))
11689 operator_code = TYPE_EXPR;
11690 else
11693 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11694 if (ansi_opname (CODE) == name) \
11696 operator_code = (CODE); \
11697 break; \
11699 else if (ansi_assopname (CODE) == name) \
11701 operator_code = (CODE); \
11702 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11703 break; \
11706 #include "operators.def"
11707 #undef DEF_OPERATOR
11709 gcc_unreachable ();
11711 while (0);
11712 gcc_assert (operator_code != MAX_TREE_CODES);
11713 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11715 if (class_type)
11716 switch (operator_code)
11718 case NEW_EXPR:
11719 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
11720 break;
11722 case DELETE_EXPR:
11723 TYPE_GETS_DELETE (class_type) |= 1;
11724 break;
11726 case VEC_NEW_EXPR:
11727 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
11728 break;
11730 case VEC_DELETE_EXPR:
11731 TYPE_GETS_DELETE (class_type) |= 2;
11732 break;
11734 default:
11735 break;
11738 /* [basic.std.dynamic.allocation]/1:
11740 A program is ill-formed if an allocation function is declared
11741 in a namespace scope other than global scope or declared static
11742 in global scope.
11744 The same also holds true for deallocation functions. */
11745 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
11746 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11748 if (DECL_NAMESPACE_SCOPE_P (decl))
11750 if (CP_DECL_CONTEXT (decl) != global_namespace)
11752 error ("%qD may not be declared within a namespace", decl);
11753 return false;
11755 else if (!TREE_PUBLIC (decl))
11757 error ("%qD may not be declared as static", decl);
11758 return false;
11763 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
11765 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11766 DECL_IS_OPERATOR_NEW (decl) = 1;
11768 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11769 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11770 else
11772 /* An operator function must either be a non-static member function
11773 or have at least one parameter of a class, a reference to a class,
11774 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11775 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11777 if (operator_code == TYPE_EXPR
11778 || operator_code == CALL_EXPR
11779 || operator_code == COMPONENT_REF
11780 || operator_code == ARRAY_REF
11781 || operator_code == NOP_EXPR)
11783 error ("%qD must be a nonstatic member function", decl);
11784 return false;
11786 else
11788 tree p;
11790 if (DECL_STATIC_FUNCTION_P (decl))
11792 error ("%qD must be either a non-static member "
11793 "function or a non-member function", decl);
11794 return false;
11797 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
11799 tree arg = non_reference (TREE_VALUE (p));
11800 if (arg == error_mark_node)
11801 return false;
11803 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11804 because these checks are performed even on
11805 template functions. */
11806 if (MAYBE_CLASS_TYPE_P (arg)
11807 || TREE_CODE (arg) == ENUMERAL_TYPE)
11808 break;
11811 if (!p || p == void_list_node)
11813 if (complain)
11814 error ("%qD must have an argument of class or "
11815 "enumerated type", decl);
11816 return false;
11821 /* There are no restrictions on the arguments to an overloaded
11822 "operator ()". */
11823 if (operator_code == CALL_EXPR)
11824 return true;
11826 /* Warn about conversion operators that will never be used. */
11827 if (IDENTIFIER_TYPENAME_P (name)
11828 && ! DECL_TEMPLATE_INFO (decl)
11829 && warn_conversion
11830 /* Warn only declaring the function; there is no need to
11831 warn again about out-of-class definitions. */
11832 && class_type == current_class_type)
11834 tree t = TREE_TYPE (name);
11835 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11837 if (ref)
11838 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11840 if (VOID_TYPE_P (t))
11841 warning (OPT_Wconversion,
11843 ? G_("conversion to a reference to void "
11844 "will never use a type conversion operator")
11845 : G_("conversion to void "
11846 "will never use a type conversion operator"));
11847 else if (class_type)
11849 if (t == class_type)
11850 warning (OPT_Wconversion,
11852 ? G_("conversion to a reference to the same type "
11853 "will never use a type conversion operator")
11854 : G_("conversion to the same type "
11855 "will never use a type conversion operator"));
11856 /* Don't force t to be complete here. */
11857 else if (MAYBE_CLASS_TYPE_P (t)
11858 && COMPLETE_TYPE_P (t)
11859 && DERIVED_FROM_P (t, class_type))
11860 warning (OPT_Wconversion,
11862 ? G_("conversion to a reference to a base class "
11863 "will never use a type conversion operator")
11864 : G_("conversion to a base class "
11865 "will never use a type conversion operator"));
11870 if (operator_code == COND_EXPR)
11872 /* 13.4.0.3 */
11873 error ("ISO C++ prohibits overloading operator ?:");
11874 return false;
11876 else if (ellipsis_p)
11878 error ("%qD must not have variable number of arguments", decl);
11879 return false;
11881 else if (ambi_op_p (operator_code))
11883 if (arity == 1)
11884 /* We pick the one-argument operator codes by default, so
11885 we don't have to change anything. */
11887 else if (arity == 2)
11889 /* If we thought this was a unary operator, we now know
11890 it to be a binary operator. */
11891 switch (operator_code)
11893 case INDIRECT_REF:
11894 operator_code = MULT_EXPR;
11895 break;
11897 case ADDR_EXPR:
11898 operator_code = BIT_AND_EXPR;
11899 break;
11901 case UNARY_PLUS_EXPR:
11902 operator_code = PLUS_EXPR;
11903 break;
11905 case NEGATE_EXPR:
11906 operator_code = MINUS_EXPR;
11907 break;
11909 case PREINCREMENT_EXPR:
11910 operator_code = POSTINCREMENT_EXPR;
11911 break;
11913 case PREDECREMENT_EXPR:
11914 operator_code = POSTDECREMENT_EXPR;
11915 break;
11917 default:
11918 gcc_unreachable ();
11921 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11923 if ((operator_code == POSTINCREMENT_EXPR
11924 || operator_code == POSTDECREMENT_EXPR)
11925 && ! processing_template_decl
11926 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11928 if (methodp)
11929 error ("postfix %qD must take %<int%> as its argument",
11930 decl);
11931 else
11932 error ("postfix %qD must take %<int%> as its second "
11933 "argument", decl);
11934 return false;
11937 else
11939 if (methodp)
11940 error ("%qD must take either zero or one argument", decl);
11941 else
11942 error ("%qD must take either one or two arguments", decl);
11943 return false;
11946 /* More Effective C++ rule 6. */
11947 if (warn_ecpp
11948 && (operator_code == POSTINCREMENT_EXPR
11949 || operator_code == POSTDECREMENT_EXPR
11950 || operator_code == PREINCREMENT_EXPR
11951 || operator_code == PREDECREMENT_EXPR))
11953 tree arg = TREE_VALUE (argtypes);
11954 tree ret = TREE_TYPE (TREE_TYPE (decl));
11955 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
11956 arg = TREE_TYPE (arg);
11957 arg = TYPE_MAIN_VARIANT (arg);
11958 if (operator_code == PREINCREMENT_EXPR
11959 || operator_code == PREDECREMENT_EXPR)
11961 if (TREE_CODE (ret) != REFERENCE_TYPE
11962 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
11963 arg))
11964 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
11965 build_reference_type (arg));
11967 else
11969 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
11970 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
11974 else if (unary_op_p (operator_code))
11976 if (arity != 1)
11978 if (methodp)
11979 error ("%qD must take %<void%>", decl);
11980 else
11981 error ("%qD must take exactly one argument", decl);
11982 return false;
11985 else /* if (binary_op_p (operator_code)) */
11987 if (arity != 2)
11989 if (methodp)
11990 error ("%qD must take exactly one argument", decl);
11991 else
11992 error ("%qD must take exactly two arguments", decl);
11993 return false;
11996 /* More Effective C++ rule 7. */
11997 if (warn_ecpp
11998 && (operator_code == TRUTH_ANDIF_EXPR
11999 || operator_code == TRUTH_ORIF_EXPR
12000 || operator_code == COMPOUND_EXPR))
12001 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
12002 decl);
12005 /* Effective C++ rule 23. */
12006 if (warn_ecpp
12007 && arity == 2
12008 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12009 && (operator_code == PLUS_EXPR
12010 || operator_code == MINUS_EXPR
12011 || operator_code == TRUNC_DIV_EXPR
12012 || operator_code == MULT_EXPR
12013 || operator_code == TRUNC_MOD_EXPR)
12014 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12015 warning (OPT_Weffc__, "%qD should return by value", decl);
12017 /* [over.oper]/8 */
12018 for (; argtypes && argtypes != void_list_node;
12019 argtypes = TREE_CHAIN (argtypes))
12020 if (TREE_PURPOSE (argtypes))
12022 TREE_PURPOSE (argtypes) = NULL_TREE;
12023 if (operator_code == POSTINCREMENT_EXPR
12024 || operator_code == POSTDECREMENT_EXPR)
12026 pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments",
12027 decl);
12029 else
12031 error ("%qD cannot have default arguments", decl);
12032 return false;
12036 return true;
12039 /* Return a string giving the keyword associate with CODE. */
12041 static const char *
12042 tag_name (enum tag_types code)
12044 switch (code)
12046 case record_type:
12047 return "struct";
12048 case class_type:
12049 return "class";
12050 case union_type:
12051 return "union";
12052 case enum_type:
12053 return "enum";
12054 case typename_type:
12055 return "typename";
12056 default:
12057 gcc_unreachable ();
12061 /* Name lookup in an elaborated-type-specifier (after the keyword
12062 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12063 elaborated-type-specifier is invalid, issue a diagnostic and return
12064 error_mark_node; otherwise, return the *_TYPE to which it referred.
12065 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12067 tree
12068 check_elaborated_type_specifier (enum tag_types tag_code,
12069 tree decl,
12070 bool allow_template_p)
12072 tree type;
12074 /* In the case of:
12076 struct S { struct S *p; };
12078 name lookup will find the TYPE_DECL for the implicit "S::S"
12079 typedef. Adjust for that here. */
12080 if (DECL_SELF_REFERENCE_P (decl))
12081 decl = TYPE_NAME (TREE_TYPE (decl));
12083 type = TREE_TYPE (decl);
12085 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12086 is false for this case as well. */
12087 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12089 error ("using template type parameter %qT after %qs",
12090 type, tag_name (tag_code));
12091 return error_mark_node;
12093 /* Accept template template parameters. */
12094 else if (allow_template_p
12095 && (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
12096 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM))
12098 /* [dcl.type.elab]
12100 If the identifier resolves to a typedef-name or the
12101 simple-template-id resolves to an alias template
12102 specialization, the elaborated-type-specifier is ill-formed.
12104 In other words, the only legitimate declaration to use in the
12105 elaborated type specifier is the implicit typedef created when
12106 the type is declared. */
12107 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
12108 && !DECL_SELF_REFERENCE_P (decl)
12109 && tag_code != typename_type)
12111 if (alias_template_specialization_p (type))
12112 error ("using alias template specialization %qT after %qs",
12113 type, tag_name (tag_code));
12114 else
12115 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
12116 inform (DECL_SOURCE_LOCATION (decl),
12117 "%qD has a previous declaration here", decl);
12118 return error_mark_node;
12120 else if (TREE_CODE (type) != RECORD_TYPE
12121 && TREE_CODE (type) != UNION_TYPE
12122 && tag_code != enum_type
12123 && tag_code != typename_type)
12125 error ("%qT referred to as %qs", type, tag_name (tag_code));
12126 inform (input_location, "%q+T has a previous declaration here", type);
12127 return error_mark_node;
12129 else if (TREE_CODE (type) != ENUMERAL_TYPE
12130 && tag_code == enum_type)
12132 error ("%qT referred to as enum", type);
12133 inform (input_location, "%q+T has a previous declaration here", type);
12134 return error_mark_node;
12136 else if (!allow_template_p
12137 && TREE_CODE (type) == RECORD_TYPE
12138 && CLASSTYPE_IS_TEMPLATE (type))
12140 /* If a class template appears as elaborated type specifier
12141 without a template header such as:
12143 template <class T> class C {};
12144 void f(class C); // No template header here
12146 then the required template argument is missing. */
12147 error ("template argument required for %<%s %T%>",
12148 tag_name (tag_code),
12149 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
12150 return error_mark_node;
12153 return type;
12156 /* Lookup NAME in elaborate type specifier in scope according to
12157 SCOPE and issue diagnostics if necessary.
12158 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12159 found, and ERROR_MARK_NODE for type error. */
12161 static tree
12162 lookup_and_check_tag (enum tag_types tag_code, tree name,
12163 tag_scope scope, bool template_header_p)
12165 tree t;
12166 tree decl;
12167 if (scope == ts_global)
12169 /* First try ordinary name lookup, ignoring hidden class name
12170 injected via friend declaration. */
12171 decl = lookup_name_prefer_type (name, 2);
12172 decl = strip_using_decl (decl);
12173 /* If that fails, the name will be placed in the smallest
12174 non-class, non-function-prototype scope according to 3.3.1/5.
12175 We may already have a hidden name declared as friend in this
12176 scope. So lookup again but not ignoring hidden names.
12177 If we find one, that name will be made visible rather than
12178 creating a new tag. */
12179 if (!decl)
12180 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
12182 else
12183 decl = lookup_type_scope (name, scope);
12185 if (decl
12186 && (DECL_CLASS_TEMPLATE_P (decl)
12187 /* If scope is ts_current we're defining a class, so ignore a
12188 template template parameter. */
12189 || (scope != ts_current
12190 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl))))
12191 decl = DECL_TEMPLATE_RESULT (decl);
12193 if (decl && TREE_CODE (decl) == TYPE_DECL)
12195 /* Look for invalid nested type:
12196 class C {
12197 class C {};
12198 }; */
12199 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
12201 error ("%qD has the same name as the class in which it is "
12202 "declared",
12203 decl);
12204 return error_mark_node;
12207 /* Two cases we need to consider when deciding if a class
12208 template is allowed as an elaborated type specifier:
12209 1. It is a self reference to its own class.
12210 2. It comes with a template header.
12212 For example:
12214 template <class T> class C {
12215 class C *c1; // DECL_SELF_REFERENCE_P is true
12216 class D;
12218 template <class U> class C; // template_header_p is true
12219 template <class T> class C<T>::D {
12220 class C *c2; // DECL_SELF_REFERENCE_P is true
12221 }; */
12223 t = check_elaborated_type_specifier (tag_code,
12224 decl,
12225 template_header_p
12226 | DECL_SELF_REFERENCE_P (decl));
12227 return t;
12229 else if (decl && TREE_CODE (decl) == TREE_LIST)
12231 error ("reference to %qD is ambiguous", name);
12232 print_candidates (decl);
12233 return error_mark_node;
12235 else
12236 return NULL_TREE;
12239 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12240 Define the tag as a forward-reference if it is not defined.
12242 If a declaration is given, process it here, and report an error if
12243 multiple declarations are not identical.
12245 SCOPE is TS_CURRENT when this is also a definition. Only look in
12246 the current frame for the name (since C++ allows new names in any
12247 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12248 declaration. Only look beginning from the current scope outward up
12249 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12251 TEMPLATE_HEADER_P is true when this declaration is preceded by
12252 a set of template parameters. */
12254 static tree
12255 xref_tag_1 (enum tag_types tag_code, tree name,
12256 tag_scope orig_scope, bool template_header_p)
12258 enum tree_code code;
12259 tree t;
12260 tree context = NULL_TREE;
12261 tag_scope scope;
12263 gcc_assert (identifier_p (name));
12265 switch (tag_code)
12267 case record_type:
12268 case class_type:
12269 code = RECORD_TYPE;
12270 break;
12271 case union_type:
12272 code = UNION_TYPE;
12273 break;
12274 case enum_type:
12275 code = ENUMERAL_TYPE;
12276 break;
12277 default:
12278 gcc_unreachable ();
12281 if (orig_scope == ts_lambda)
12282 scope = ts_current;
12283 else
12284 scope = orig_scope;
12286 /* In case of anonymous name, xref_tag is only called to
12287 make type node and push name. Name lookup is not required. */
12288 if (anon_aggrname_p (name))
12289 t = NULL_TREE;
12290 else
12291 t = lookup_and_check_tag (tag_code, name,
12292 scope, template_header_p);
12294 if (t == error_mark_node)
12295 return error_mark_node;
12297 if (scope != ts_current && t && current_class_type
12298 && template_class_depth (current_class_type)
12299 && template_header_p)
12301 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
12302 return t;
12304 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12305 definition of this tag. Since, in addition, we are currently
12306 processing a (member) template declaration of a template
12307 class, we must be very careful; consider:
12309 template <class X>
12310 struct S1
12312 template <class U>
12313 struct S2
12314 { template <class V>
12315 friend struct S1; };
12317 Here, the S2::S1 declaration should not be confused with the
12318 outer declaration. In particular, the inner version should
12319 have a template parameter of level 2, not level 1. This
12320 would be particularly important if the member declaration
12321 were instead:
12323 template <class V = U> friend struct S1;
12325 say, when we should tsubst into `U' when instantiating
12326 S2. On the other hand, when presented with:
12328 template <class T>
12329 struct S1 {
12330 template <class U>
12331 struct S2 {};
12332 template <class U>
12333 friend struct S2;
12336 we must find the inner binding eventually. We
12337 accomplish this by making sure that the new type we
12338 create to represent this declaration has the right
12339 TYPE_CONTEXT. */
12340 context = TYPE_CONTEXT (t);
12341 t = NULL_TREE;
12344 if (! t)
12346 /* If no such tag is yet defined, create a forward-reference node
12347 and record it as the "definition".
12348 When a real declaration of this type is found,
12349 the forward-reference will be altered into a real type. */
12350 if (code == ENUMERAL_TYPE)
12352 error ("use of enum %q#D without previous declaration", name);
12353 return error_mark_node;
12355 else
12357 t = make_class_type (code);
12358 TYPE_CONTEXT (t) = context;
12359 if (orig_scope == ts_lambda)
12360 /* Remember that we're declaring a lambda to avoid bogus errors
12361 in push_template_decl. */
12362 CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node;
12363 t = pushtag (name, t, scope);
12366 else
12368 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
12370 if (!redeclare_class_template (t, current_template_parms))
12371 return error_mark_node;
12373 else if (!processing_template_decl
12374 && CLASS_TYPE_P (t)
12375 && CLASSTYPE_IS_TEMPLATE (t))
12377 error ("redeclaration of %qT as a non-template", t);
12378 error ("previous declaration %q+D", t);
12379 return error_mark_node;
12382 /* Make injected friend class visible. */
12383 if (scope != ts_within_enclosing_non_class
12384 && hidden_name_p (TYPE_NAME (t)))
12386 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
12387 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
12389 if (TYPE_TEMPLATE_INFO (t))
12391 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
12392 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
12397 return t;
12400 /* Wrapper for xref_tag_1. */
12402 tree
12403 xref_tag (enum tag_types tag_code, tree name,
12404 tag_scope scope, bool template_header_p)
12406 tree ret;
12407 bool subtime;
12408 subtime = timevar_cond_start (TV_NAME_LOOKUP);
12409 ret = xref_tag_1 (tag_code, name, scope, template_header_p);
12410 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
12411 return ret;
12415 tree
12416 xref_tag_from_type (tree old, tree id, tag_scope scope)
12418 enum tag_types tag_kind;
12420 if (TREE_CODE (old) == RECORD_TYPE)
12421 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
12422 else
12423 tag_kind = union_type;
12425 if (id == NULL_TREE)
12426 id = TYPE_IDENTIFIER (old);
12428 return xref_tag (tag_kind, id, scope, false);
12431 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12432 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12433 access_* node, and the TREE_VALUE is the type of the base-class.
12434 Non-NULL TREE_TYPE indicates virtual inheritance.
12436 Returns true if the binfo hierarchy was successfully created,
12437 false if an error was detected. */
12439 bool
12440 xref_basetypes (tree ref, tree base_list)
12442 tree *basep;
12443 tree binfo, base_binfo;
12444 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
12445 unsigned max_bases = 0; /* Maximum direct bases. */
12446 int i;
12447 tree default_access;
12448 tree igo_prev; /* Track Inheritance Graph Order. */
12450 if (ref == error_mark_node)
12451 return false;
12453 /* The base of a derived class is private by default, all others are
12454 public. */
12455 default_access = (TREE_CODE (ref) == RECORD_TYPE
12456 && CLASSTYPE_DECLARED_CLASS (ref)
12457 ? access_private_node : access_public_node);
12459 /* First, make sure that any templates in base-classes are
12460 instantiated. This ensures that if we call ourselves recursively
12461 we do not get confused about which classes are marked and which
12462 are not. */
12463 basep = &base_list;
12464 while (*basep)
12466 tree basetype = TREE_VALUE (*basep);
12468 /* The dependent_type_p call below should really be dependent_scope_p
12469 so that we give a hard error about using an incomplete type as a
12470 base, but we allow it with a pedwarn for backward
12471 compatibility. */
12472 if (processing_template_decl
12473 && CLASS_TYPE_P (basetype) && TYPE_BEING_DEFINED (basetype))
12474 cxx_incomplete_type_diagnostic (NULL_TREE, basetype, DK_PEDWARN);
12475 if (!dependent_type_p (basetype)
12476 && !complete_type_or_else (basetype, NULL))
12477 /* An incomplete type. Remove it from the list. */
12478 *basep = TREE_CHAIN (*basep);
12479 else
12481 max_bases++;
12482 if (TREE_TYPE (*basep))
12483 max_vbases++;
12484 if (CLASS_TYPE_P (basetype))
12485 max_vbases += vec_safe_length (CLASSTYPE_VBASECLASSES (basetype));
12486 basep = &TREE_CHAIN (*basep);
12490 TYPE_MARKED_P (ref) = 1;
12492 /* The binfo slot should be empty, unless this is an (ill-formed)
12493 redefinition. */
12494 if (TYPE_BINFO (ref) && !TYPE_SIZE (ref))
12496 error ("redefinition of %q#T", ref);
12497 return false;
12500 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
12502 binfo = make_tree_binfo (max_bases);
12504 TYPE_BINFO (ref) = binfo;
12505 BINFO_OFFSET (binfo) = size_zero_node;
12506 BINFO_TYPE (binfo) = ref;
12508 /* Apply base-class info set up to the variants of this type. */
12509 fixup_type_variants (ref);
12511 if (max_bases)
12513 vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases);
12514 /* An aggregate cannot have baseclasses. */
12515 CLASSTYPE_NON_AGGREGATE (ref) = 1;
12517 if (TREE_CODE (ref) == UNION_TYPE)
12519 error ("derived union %qT invalid", ref);
12520 return false;
12524 if (max_bases > 1)
12526 if (TYPE_FOR_JAVA (ref))
12528 error ("Java class %qT cannot have multiple bases", ref);
12529 return false;
12533 if (max_vbases)
12535 vec_alloc (CLASSTYPE_VBASECLASSES (ref), max_vbases);
12537 if (TYPE_FOR_JAVA (ref))
12539 error ("Java class %qT cannot have virtual bases", ref);
12540 return false;
12544 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
12546 tree access = TREE_PURPOSE (base_list);
12547 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
12548 tree basetype = TREE_VALUE (base_list);
12550 if (access == access_default_node)
12551 access = default_access;
12553 if (PACK_EXPANSION_P (basetype))
12554 basetype = PACK_EXPANSION_PATTERN (basetype);
12555 if (TREE_CODE (basetype) == TYPE_DECL)
12556 basetype = TREE_TYPE (basetype);
12557 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
12559 error ("base type %qT fails to be a struct or class type",
12560 basetype);
12561 return false;
12564 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
12565 TYPE_FOR_JAVA (ref) = 1;
12567 base_binfo = NULL_TREE;
12568 if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
12570 base_binfo = TYPE_BINFO (basetype);
12571 /* The original basetype could have been a typedef'd type. */
12572 basetype = BINFO_TYPE (base_binfo);
12574 /* Inherit flags from the base. */
12575 TYPE_HAS_NEW_OPERATOR (ref)
12576 |= TYPE_HAS_NEW_OPERATOR (basetype);
12577 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12578 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12579 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12580 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
12581 CLASSTYPE_DIAMOND_SHAPED_P (ref)
12582 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
12583 CLASSTYPE_REPEATED_BASE_P (ref)
12584 |= CLASSTYPE_REPEATED_BASE_P (basetype);
12587 /* We must do this test after we've seen through a typedef
12588 type. */
12589 if (TYPE_MARKED_P (basetype))
12591 if (basetype == ref)
12592 error ("recursive type %qT undefined", basetype);
12593 else
12594 error ("duplicate base type %qT invalid", basetype);
12595 return false;
12598 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
12599 /* Regenerate the pack expansion for the bases. */
12600 basetype = make_pack_expansion (basetype);
12602 TYPE_MARKED_P (basetype) = 1;
12604 base_binfo = copy_binfo (base_binfo, basetype, ref,
12605 &igo_prev, via_virtual);
12606 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
12607 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
12609 BINFO_BASE_APPEND (binfo, base_binfo);
12610 BINFO_BASE_ACCESS_APPEND (binfo, access);
12613 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref)) < max_vbases)
12614 /* If we didn't get max_vbases vbases, we must have shared at
12615 least one of them, and are therefore diamond shaped. */
12616 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
12618 /* Unmark all the types. */
12619 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12620 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12621 TYPE_MARKED_P (ref) = 0;
12623 /* Now see if we have a repeated base type. */
12624 if (!CLASSTYPE_REPEATED_BASE_P (ref))
12626 for (base_binfo = binfo; base_binfo;
12627 base_binfo = TREE_CHAIN (base_binfo))
12629 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12631 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
12632 break;
12634 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
12636 for (base_binfo = binfo; base_binfo;
12637 base_binfo = TREE_CHAIN (base_binfo))
12638 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12639 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12640 else
12641 break;
12644 return true;
12648 /* Copies the enum-related properties from type SRC to type DST.
12649 Used with the underlying type of an enum and the enum itself. */
12650 static void
12651 copy_type_enum (tree dst, tree src)
12653 tree t;
12654 for (t = dst; t; t = TYPE_NEXT_VARIANT (t))
12656 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src);
12657 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src);
12658 TYPE_SIZE (t) = TYPE_SIZE (src);
12659 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src);
12660 SET_TYPE_MODE (dst, TYPE_MODE (src));
12661 TYPE_PRECISION (t) = TYPE_PRECISION (src);
12662 TYPE_ALIGN (t) = TYPE_ALIGN (src);
12663 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src);
12664 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src);
12668 /* Begin compiling the definition of an enumeration type.
12669 NAME is its name,
12671 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12673 UNDERLYING_TYPE is the type that will be used as the storage for
12674 the enumeration type. This should be NULL_TREE if no storage type
12675 was specified.
12677 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12679 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12681 Returns the type object, as yet incomplete.
12682 Also records info about it so that build_enumerator
12683 may be used to declare the individual values as they are read. */
12685 tree
12686 start_enum (tree name, tree enumtype, tree underlying_type,
12687 bool scoped_enum_p, bool *is_new)
12689 tree prevtype = NULL_TREE;
12690 gcc_assert (identifier_p (name));
12692 if (is_new)
12693 *is_new = false;
12694 /* [C++0x dcl.enum]p5:
12696 If not explicitly specified, the underlying type of a scoped
12697 enumeration type is int. */
12698 if (!underlying_type && scoped_enum_p)
12699 underlying_type = integer_type_node;
12701 if (underlying_type)
12702 underlying_type = cv_unqualified (underlying_type);
12704 /* If this is the real definition for a previous forward reference,
12705 fill in the contents in the same object that used to be the
12706 forward reference. */
12707 if (!enumtype)
12708 enumtype = lookup_and_check_tag (enum_type, name,
12709 /*tag_scope=*/ts_current,
12710 /*template_header_p=*/false);
12712 /* In case of a template_decl, the only check that should be deferred
12713 to instantiation time is the comparison of underlying types. */
12714 if (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12716 if (scoped_enum_p != SCOPED_ENUM_P (enumtype))
12718 error_at (input_location, "scoped/unscoped mismatch "
12719 "in enum %q#T", enumtype);
12720 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12721 "previous definition here");
12722 enumtype = error_mark_node;
12724 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) != !! underlying_type)
12726 error_at (input_location, "underlying type mismatch "
12727 "in enum %q#T", enumtype);
12728 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12729 "previous definition here");
12730 enumtype = error_mark_node;
12732 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype)
12733 && !dependent_type_p (underlying_type)
12734 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))
12735 && !same_type_p (underlying_type,
12736 ENUM_UNDERLYING_TYPE (enumtype)))
12738 error_at (input_location, "different underlying type "
12739 "in enum %q#T", enumtype);
12740 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12741 "previous definition here");
12742 underlying_type = NULL_TREE;
12746 if (!enumtype || TREE_CODE (enumtype) != ENUMERAL_TYPE
12747 || processing_template_decl)
12749 /* In case of error, make a dummy enum to allow parsing to
12750 continue. */
12751 if (enumtype == error_mark_node)
12753 name = make_anon_name ();
12754 enumtype = NULL_TREE;
12757 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12758 of an opaque enum, or an opaque enum of an already defined
12759 enumeration (C++0x only).
12760 In any other case, it'll be NULL_TREE. */
12761 if (!enumtype)
12763 if (is_new)
12764 *is_new = true;
12766 prevtype = enumtype;
12768 /* Do not push the decl more than once, unless we need to
12769 compare underlying types at instantiation time */
12770 if (!enumtype
12771 || TREE_CODE (enumtype) != ENUMERAL_TYPE
12772 || (underlying_type
12773 && dependent_type_p (underlying_type))
12774 || (ENUM_UNDERLYING_TYPE (enumtype)
12775 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))))
12777 enumtype = cxx_make_type (ENUMERAL_TYPE);
12778 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
12780 else
12781 enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current,
12782 false);
12784 if (enumtype == error_mark_node)
12785 return error_mark_node;
12787 /* The enum is considered opaque until the opening '{' of the
12788 enumerator list. */
12789 SET_OPAQUE_ENUM_P (enumtype, true);
12790 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) = !! underlying_type;
12793 SET_SCOPED_ENUM_P (enumtype, scoped_enum_p);
12795 if (underlying_type)
12797 if (CP_INTEGRAL_TYPE_P (underlying_type))
12799 copy_type_enum (enumtype, underlying_type);
12800 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12802 else if (dependent_type_p (underlying_type))
12803 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12804 else
12805 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12806 underlying_type, enumtype);
12809 /* If into a template class, the returned enum is always the first
12810 declaration (opaque or not) seen. This way all the references to
12811 this type will be to the same declaration. The following ones are used
12812 only to check for definition errors. */
12813 if (prevtype && processing_template_decl)
12814 return prevtype;
12815 else
12816 return enumtype;
12819 /* After processing and defining all the values of an enumeration type,
12820 install their decls in the enumeration type.
12821 ENUMTYPE is the type object. */
12823 void
12824 finish_enum_value_list (tree enumtype)
12826 tree values;
12827 tree underlying_type;
12828 tree decl;
12829 tree value;
12830 tree minnode, maxnode;
12831 tree t;
12833 bool fixed_underlying_type_p
12834 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
12836 /* We built up the VALUES in reverse order. */
12837 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12839 /* For an enum defined in a template, just set the type of the values;
12840 all further processing is postponed until the template is
12841 instantiated. We need to set the type so that tsubst of a CONST_DECL
12842 works. */
12843 if (processing_template_decl)
12845 for (values = TYPE_VALUES (enumtype);
12846 values;
12847 values = TREE_CHAIN (values))
12848 TREE_TYPE (TREE_VALUE (values)) = enumtype;
12849 return;
12852 /* Determine the minimum and maximum values of the enumerators. */
12853 if (TYPE_VALUES (enumtype))
12855 minnode = maxnode = NULL_TREE;
12857 for (values = TYPE_VALUES (enumtype);
12858 values;
12859 values = TREE_CHAIN (values))
12861 decl = TREE_VALUE (values);
12863 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12864 each enumerator has the type of its enumeration. Prior to the
12865 closing brace, the type of each enumerator is the type of its
12866 initializing value. */
12867 TREE_TYPE (decl) = enumtype;
12869 /* Update the minimum and maximum values, if appropriate. */
12870 value = DECL_INITIAL (decl);
12871 if (value == error_mark_node)
12872 value = integer_zero_node;
12873 /* Figure out what the minimum and maximum values of the
12874 enumerators are. */
12875 if (!minnode)
12876 minnode = maxnode = value;
12877 else if (tree_int_cst_lt (maxnode, value))
12878 maxnode = value;
12879 else if (tree_int_cst_lt (value, minnode))
12880 minnode = value;
12883 else
12884 /* [dcl.enum]
12886 If the enumerator-list is empty, the underlying type is as if
12887 the enumeration had a single enumerator with value 0. */
12888 minnode = maxnode = integer_zero_node;
12890 if (!fixed_underlying_type_p)
12892 /* Compute the number of bits require to represent all values of the
12893 enumeration. We must do this before the type of MINNODE and
12894 MAXNODE are transformed, since tree_int_cst_min_precision relies
12895 on the TREE_TYPE of the value it is passed. */
12896 signop sgn = tree_int_cst_sgn (minnode) >= 0 ? UNSIGNED : SIGNED;
12897 int lowprec = tree_int_cst_min_precision (minnode, sgn);
12898 int highprec = tree_int_cst_min_precision (maxnode, sgn);
12899 int precision = MAX (lowprec, highprec);
12900 unsigned int itk;
12901 bool use_short_enum;
12903 /* Determine the underlying type of the enumeration.
12905 [dcl.enum]
12907 The underlying type of an enumeration is an integral type that
12908 can represent all the enumerator values defined in the
12909 enumeration. It is implementation-defined which integral type is
12910 used as the underlying type for an enumeration except that the
12911 underlying type shall not be larger than int unless the value of
12912 an enumerator cannot fit in an int or unsigned int.
12914 We use "int" or an "unsigned int" as the underlying type, even if
12915 a smaller integral type would work, unless the user has
12916 explicitly requested that we use the smallest possible type. The
12917 user can request that for all enumerations with a command line
12918 flag, or for just one enumeration with an attribute. */
12920 use_short_enum = flag_short_enums
12921 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
12923 for (itk = (use_short_enum ? itk_char : itk_int);
12924 itk != itk_none;
12925 itk++)
12927 underlying_type = integer_types[itk];
12928 if (underlying_type != NULL_TREE
12929 && TYPE_PRECISION (underlying_type) >= precision
12930 && TYPE_SIGN (underlying_type) == sgn)
12931 break;
12933 if (itk == itk_none)
12935 /* DR 377
12937 IF no integral type can represent all the enumerator values, the
12938 enumeration is ill-formed. */
12939 error ("no integral type can represent all of the enumerator values "
12940 "for %qT", enumtype);
12941 precision = TYPE_PRECISION (long_long_integer_type_node);
12942 underlying_type = integer_types[itk_unsigned_long_long];
12945 /* [dcl.enum]
12947 The value of sizeof() applied to an enumeration type, an object
12948 of an enumeration type, or an enumerator, is the value of sizeof()
12949 applied to the underlying type. */
12950 copy_type_enum (enumtype, underlying_type);
12952 /* Compute the minimum and maximum values for the type.
12954 [dcl.enum]
12956 For an enumeration where emin is the smallest enumerator and emax
12957 is the largest, the values of the enumeration are the values of the
12958 underlying type in the range bmin to bmax, where bmin and bmax are,
12959 respectively, the smallest and largest values of the smallest bit-
12960 field that can store emin and emax. */
12962 /* The middle-end currently assumes that types with TYPE_PRECISION
12963 narrower than their underlying type are suitably zero or sign
12964 extended to fill their mode. Similarly, it assumes that the front
12965 end assures that a value of a particular type must be within
12966 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12968 We used to set these fields based on bmin and bmax, but that led
12969 to invalid assumptions like optimizing away bounds checking. So
12970 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12971 TYPE_MAX_VALUE to the values for the mode above and only restrict
12972 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12973 ENUM_UNDERLYING_TYPE (enumtype)
12974 = build_distinct_type_copy (underlying_type);
12975 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision;
12976 set_min_and_max_values_for_integral_type
12977 (ENUM_UNDERLYING_TYPE (enumtype), precision, sgn);
12979 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12980 if (flag_strict_enums)
12981 set_min_and_max_values_for_integral_type (enumtype, precision, sgn);
12983 else
12984 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
12986 /* Convert each of the enumerators to the type of the underlying
12987 type of the enumeration. */
12988 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
12990 location_t saved_location;
12992 decl = TREE_VALUE (values);
12993 saved_location = input_location;
12994 input_location = DECL_SOURCE_LOCATION (decl);
12995 if (fixed_underlying_type_p)
12996 /* If the enumeration type has a fixed underlying type, we
12997 already checked all of the enumerator values. */
12998 value = DECL_INITIAL (decl);
12999 else
13000 value = perform_implicit_conversion (underlying_type,
13001 DECL_INITIAL (decl),
13002 tf_warning_or_error);
13003 input_location = saved_location;
13005 /* Do not clobber shared ints. */
13006 value = copy_node (value);
13008 TREE_TYPE (value) = enumtype;
13009 DECL_INITIAL (decl) = value;
13012 /* Fix up all variant types of this enum type. */
13013 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13014 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13016 if (at_class_scope_p ()
13017 && COMPLETE_TYPE_P (current_class_type)
13018 && UNSCOPED_ENUM_P (enumtype))
13019 insert_late_enum_def_into_classtype_sorted_fields (enumtype,
13020 current_class_type);
13022 /* Finish debugging output for this type. */
13023 rest_of_type_compilation (enumtype, namespace_bindings_p ());
13026 /* Finishes the enum type. This is called only the first time an
13027 enumeration is seen, be it opaque or odinary.
13028 ENUMTYPE is the type object. */
13030 void
13031 finish_enum (tree enumtype)
13033 if (processing_template_decl)
13035 if (at_function_scope_p ())
13036 add_stmt (build_min (TAG_DEFN, enumtype));
13037 return;
13040 /* If this is a forward declaration, there should not be any variants,
13041 though we can get a variant in the middle of an enum-specifier with
13042 wacky code like 'enum E { e = sizeof(const E*) };' */
13043 gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
13044 && (TYPE_VALUES (enumtype)
13045 || !TYPE_NEXT_VARIANT (enumtype)));
13048 /* Build and install a CONST_DECL for an enumeration constant of the
13049 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13050 Apply ATTRIBUTES if available. LOC is the location of NAME.
13051 Assignment of sequential values by default is handled here. */
13053 void
13054 build_enumerator (tree name, tree value, tree enumtype, tree attributes,
13055 location_t loc)
13057 tree decl;
13058 tree context;
13059 tree type;
13061 /* scalar_constant_value will pull out this expression, so make sure
13062 it's folded as appropriate. */
13063 if (processing_template_decl)
13064 value = fold_non_dependent_expr (value);
13066 /* If the VALUE was erroneous, pretend it wasn't there; that will
13067 result in the enum being assigned the next value in sequence. */
13068 if (value == error_mark_node)
13069 value = NULL_TREE;
13071 /* Remove no-op casts from the value. */
13072 if (value)
13073 STRIP_TYPE_NOPS (value);
13075 if (! processing_template_decl)
13077 /* Validate and default VALUE. */
13078 if (value != NULL_TREE)
13080 if (!ENUM_UNDERLYING_TYPE (enumtype))
13082 tree tmp_value = build_expr_type_conversion (WANT_INT | WANT_ENUM,
13083 value, true);
13084 if (tmp_value)
13085 value = tmp_value;
13087 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
13088 (TREE_TYPE (value)))
13089 value = perform_implicit_conversion_flags
13090 (ENUM_UNDERLYING_TYPE (enumtype), value, tf_warning_or_error,
13091 LOOKUP_IMPLICIT | LOOKUP_NO_NARROWING);
13093 if (value == error_mark_node)
13094 value = NULL_TREE;
13096 if (value != NULL_TREE)
13098 value = cxx_constant_value (value);
13100 if (TREE_CODE (value) != INTEGER_CST
13101 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
13103 error ("enumerator value for %qD is not an integer constant",
13104 name);
13105 value = NULL_TREE;
13110 /* Default based on previous value. */
13111 if (value == NULL_TREE)
13113 if (TYPE_VALUES (enumtype))
13115 tree prev_value;
13116 bool overflowed;
13118 /* C++03 7.2/4: If no initializer is specified for the first
13119 enumerator, the type is an unspecified integral
13120 type. Otherwise the type is the same as the type of the
13121 initializing value of the preceding enumerator unless the
13122 incremented value is not representable in that type, in
13123 which case the type is an unspecified integral type
13124 sufficient to contain the incremented value. */
13125 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13126 if (error_operand_p (prev_value))
13127 value = error_mark_node;
13128 else
13130 tree type = TREE_TYPE (prev_value);
13131 signop sgn = TYPE_SIGN (type);
13132 widest_int wi = wi::add (wi::to_widest (prev_value), 1, sgn,
13133 &overflowed);
13134 if (!overflowed)
13136 bool pos = !wi::neg_p (wi, sgn);
13137 if (!wi::fits_to_tree_p (wi, type))
13139 unsigned int itk;
13140 for (itk = itk_int; itk != itk_none; itk++)
13142 type = integer_types[itk];
13143 if (type != NULL_TREE
13144 && (pos || !TYPE_UNSIGNED (type))
13145 && wi::fits_to_tree_p (wi, type))
13146 break;
13148 if (type && cxx_dialect < cxx11
13149 && itk > itk_unsigned_long)
13150 pedwarn (input_location, OPT_Wlong_long, pos ? "\
13151 incremented enumerator value is too large for %<unsigned long%>" : "\
13152 incremented enumerator value is too large for %<long%>");
13154 if (type == NULL_TREE)
13155 overflowed = true;
13156 else
13157 value = wide_int_to_tree (type, wi);
13160 if (overflowed)
13162 error ("overflow in enumeration values at %qD", name);
13163 value = error_mark_node;
13167 else
13168 value = integer_zero_node;
13171 /* Remove no-op casts from the value. */
13172 STRIP_TYPE_NOPS (value);
13174 /* If the underlying type of the enum is fixed, check whether
13175 the enumerator values fits in the underlying type. If it
13176 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13177 if (ENUM_UNDERLYING_TYPE (enumtype)
13178 && value
13179 && TREE_CODE (value) == INTEGER_CST)
13181 if (!int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
13182 error ("enumerator value %E is outside the range of underlying "
13183 "type %<%T%>", value, ENUM_UNDERLYING_TYPE (enumtype));
13185 /* Convert the value to the appropriate type. */
13186 value = convert (ENUM_UNDERLYING_TYPE (enumtype), value);
13190 /* C++ associates enums with global, function, or class declarations. */
13191 context = current_scope ();
13193 /* Build the actual enumeration constant. Note that the enumeration
13194 constants have the underlying type of the enum (if it is fixed)
13195 or the type of their initializer (if the underlying type of the
13196 enum is not fixed):
13198 [ C++0x dcl.enum ]
13200 If the underlying type is fixed, the type of each enumerator
13201 prior to the closing brace is the underlying type; if the
13202 initializing value of an enumerator cannot be represented by
13203 the underlying type, the program is ill-formed. If the
13204 underlying type is not fixed, the type of each enumerator is
13205 the type of its initializing value.
13207 If the underlying type is not fixed, it will be computed by
13208 finish_enum and we will reset the type of this enumerator. Of
13209 course, if we're processing a template, there may be no value. */
13210 type = value ? TREE_TYPE (value) : NULL_TREE;
13212 decl = build_decl (loc, CONST_DECL, name, type);
13214 DECL_CONTEXT (decl) = enumtype;
13215 TREE_CONSTANT (decl) = 1;
13216 TREE_READONLY (decl) = 1;
13217 DECL_INITIAL (decl) = value;
13219 if (attributes)
13220 cplus_decl_attributes (&decl, attributes, 0);
13222 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype))
13223 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13224 on the TYPE_FIELDS list for `S'. (That's so that you can say
13225 things like `S::i' later.) */
13226 finish_member_declaration (decl);
13227 else
13228 pushdecl (decl);
13230 /* Add this enumeration constant to the list for this type. */
13231 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13234 /* Look for an enumerator with the given NAME within the enumeration
13235 type ENUMTYPE. This routine is used primarily for qualified name
13236 lookup into an enumerator in C++0x, e.g.,
13238 enum class Color { Red, Green, Blue };
13240 Color color = Color::Red;
13242 Returns the value corresponding to the enumerator, or
13243 NULL_TREE if no such enumerator was found. */
13244 tree
13245 lookup_enumerator (tree enumtype, tree name)
13247 tree e;
13248 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
13250 e = purpose_member (name, TYPE_VALUES (enumtype));
13251 return e? TREE_VALUE (e) : NULL_TREE;
13255 /* We're defining DECL. Make sure that its type is OK. */
13257 static void
13258 check_function_type (tree decl, tree current_function_parms)
13260 tree fntype = TREE_TYPE (decl);
13261 tree return_type = complete_type (TREE_TYPE (fntype));
13263 /* In a function definition, arg types must be complete. */
13264 require_complete_types_for_parms (current_function_parms);
13266 if (dependent_type_p (return_type)
13267 || type_uses_auto (return_type))
13268 return;
13269 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
13270 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
13272 tree args = TYPE_ARG_TYPES (fntype);
13274 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13275 error ("return type %q#T is incomplete", return_type);
13276 else
13277 error ("return type has Java class type %q#T", return_type);
13279 /* Make it return void instead. */
13280 if (TREE_CODE (fntype) == METHOD_TYPE)
13281 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
13282 void_type_node,
13283 TREE_CHAIN (args));
13284 else
13285 fntype = build_function_type (void_type_node, args);
13286 fntype
13287 = build_exception_variant (fntype,
13288 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
13289 fntype = (cp_build_type_attribute_variant
13290 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
13291 TREE_TYPE (decl) = fntype;
13293 else
13294 abstract_virtuals_error (decl, TREE_TYPE (fntype));
13297 /* Create the FUNCTION_DECL for a function definition.
13298 DECLSPECS and DECLARATOR are the parts of the declaration;
13299 they describe the function's name and the type it returns,
13300 but twisted together in a fashion that parallels the syntax of C.
13302 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13303 DECLARATOR is really the DECL for the function we are about to
13304 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13305 indicating that the function is an inline defined in-class.
13307 This function creates a binding context for the function body
13308 as well as setting up the FUNCTION_DECL in current_function_decl.
13310 For C++, we must first check whether that datum makes any sense.
13311 For example, "class A local_a(1,2);" means that variable local_a
13312 is an aggregate of type A, which should have a constructor
13313 applied to it with the argument list [1, 2].
13315 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13316 or may be a BLOCK if the function has been defined previously
13317 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13318 error_mark_node if the function has never been defined, or
13319 a BLOCK if the function has been defined somewhere. */
13321 bool
13322 start_preparsed_function (tree decl1, tree attrs, int flags)
13324 tree ctype = NULL_TREE;
13325 tree fntype;
13326 tree restype;
13327 int doing_friend = 0;
13328 cp_binding_level *bl;
13329 tree current_function_parms;
13330 struct c_fileinfo *finfo
13331 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
13332 bool honor_interface;
13334 /* Sanity check. */
13335 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node)));
13336 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
13338 fntype = TREE_TYPE (decl1);
13339 if (TREE_CODE (fntype) == METHOD_TYPE)
13340 ctype = TYPE_METHOD_BASETYPE (fntype);
13342 /* ISO C++ 11.4/5. A friend function defined in a class is in
13343 the (lexical) scope of the class in which it is defined. */
13344 if (!ctype && DECL_FRIEND_P (decl1))
13346 ctype = DECL_FRIEND_CONTEXT (decl1);
13348 /* CTYPE could be null here if we're dealing with a template;
13349 for example, `inline friend float foo()' inside a template
13350 will have no CTYPE set. */
13351 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13352 ctype = NULL_TREE;
13353 else
13354 doing_friend = 1;
13357 if (DECL_DECLARED_INLINE_P (decl1)
13358 && lookup_attribute ("noinline", attrs))
13359 warning (0, "inline function %q+D given attribute noinline", decl1);
13361 /* Handle gnu_inline attribute. */
13362 if (GNU_INLINE_P (decl1))
13364 DECL_EXTERNAL (decl1) = 1;
13365 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13366 DECL_INTERFACE_KNOWN (decl1) = 1;
13367 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
13370 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13371 /* This is a constructor, we must ensure that any default args
13372 introduced by this definition are propagated to the clones
13373 now. The clones are used directly in overload resolution. */
13374 adjust_clone_args (decl1);
13376 /* Sometimes we don't notice that a function is a static member, and
13377 build a METHOD_TYPE for it. Fix that up now. */
13378 gcc_assert (!(ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13379 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE));
13381 /* Set up current_class_type, and enter the scope of the class, if
13382 appropriate. */
13383 if (ctype)
13384 push_nested_class (ctype);
13385 else if (DECL_STATIC_FUNCTION_P (decl1))
13386 push_nested_class (DECL_CONTEXT (decl1));
13388 /* Now that we have entered the scope of the class, we must restore
13389 the bindings for any template parameters surrounding DECL1, if it
13390 is an inline member template. (Order is important; consider the
13391 case where a template parameter has the same name as a field of
13392 the class.) It is not until after this point that
13393 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13394 if (flags & SF_INCLASS_INLINE)
13395 maybe_begin_member_template_processing (decl1);
13397 /* Effective C++ rule 15. */
13398 if (warn_ecpp
13399 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13400 && VOID_TYPE_P (TREE_TYPE (fntype)))
13401 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
13403 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13404 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13405 if (!DECL_INITIAL (decl1))
13406 DECL_INITIAL (decl1) = error_mark_node;
13408 /* This function exists in static storage.
13409 (This does not mean `static' in the C sense!) */
13410 TREE_STATIC (decl1) = 1;
13412 /* We must call push_template_decl after current_class_type is set
13413 up. (If we are processing inline definitions after exiting a
13414 class scope, current_class_type will be NULL_TREE until set above
13415 by push_nested_class.) */
13416 if (processing_template_decl)
13418 tree newdecl1 = push_template_decl (decl1);
13419 if (newdecl1 == error_mark_node)
13421 if (ctype || DECL_STATIC_FUNCTION_P (decl1))
13422 pop_nested_class ();
13423 return false;
13425 decl1 = newdecl1;
13428 /* We are now in the scope of the function being defined. */
13429 current_function_decl = decl1;
13431 /* Save the parm names or decls from this function's declarator
13432 where store_parm_decls will find them. */
13433 current_function_parms = DECL_ARGUMENTS (decl1);
13435 /* Make sure the parameter and return types are reasonable. When
13436 you declare a function, these types can be incomplete, but they
13437 must be complete when you define the function. */
13438 check_function_type (decl1, current_function_parms);
13440 /* Build the return declaration for the function. */
13441 restype = TREE_TYPE (fntype);
13443 if (DECL_RESULT (decl1) == NULL_TREE)
13445 tree resdecl;
13447 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
13448 DECL_ARTIFICIAL (resdecl) = 1;
13449 DECL_IGNORED_P (resdecl) = 1;
13450 DECL_RESULT (decl1) = resdecl;
13452 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
13455 /* Let the user know we're compiling this function. */
13456 announce_function (decl1);
13458 /* Record the decl so that the function name is defined.
13459 If we already have a decl for this name, and it is a FUNCTION_DECL,
13460 use the old decl. */
13461 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13463 /* A specialization is not used to guide overload resolution. */
13464 if (!DECL_FUNCTION_MEMBER_P (decl1)
13465 && !(DECL_USE_TEMPLATE (decl1) &&
13466 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
13468 tree olddecl = pushdecl (decl1);
13470 if (olddecl == error_mark_node)
13471 /* If something went wrong when registering the declaration,
13472 use DECL1; we have to have a FUNCTION_DECL to use when
13473 parsing the body of the function. */
13475 else
13477 /* Otherwise, OLDDECL is either a previous declaration
13478 of the same function or DECL1 itself. */
13480 if (warn_missing_declarations
13481 && olddecl == decl1
13482 && !DECL_MAIN_P (decl1)
13483 && TREE_PUBLIC (decl1)
13484 && !DECL_DECLARED_INLINE_P (decl1))
13486 tree context;
13488 /* Check whether DECL1 is in an anonymous
13489 namespace. */
13490 for (context = DECL_CONTEXT (decl1);
13491 context;
13492 context = DECL_CONTEXT (context))
13494 if (TREE_CODE (context) == NAMESPACE_DECL
13495 && DECL_NAME (context) == NULL_TREE)
13496 break;
13499 if (context == NULL)
13500 warning (OPT_Wmissing_declarations,
13501 "no previous declaration for %q+D", decl1);
13504 decl1 = olddecl;
13507 else
13509 /* We need to set the DECL_CONTEXT. */
13510 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13511 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13513 fntype = TREE_TYPE (decl1);
13514 restype = TREE_TYPE (fntype);
13516 /* If #pragma weak applies, mark the decl appropriately now.
13517 The pragma only applies to global functions. Because
13518 determining whether or not the #pragma applies involves
13519 computing the mangled name for the declaration, we cannot
13520 apply the pragma until after we have merged this declaration
13521 with any previous declarations; if the original declaration
13522 has a linkage specification, that specification applies to
13523 the definition as well, and may affect the mangled name. */
13524 if (DECL_FILE_SCOPE_P (decl1))
13525 maybe_apply_pragma_weak (decl1);
13528 /* Reset this in case the call to pushdecl changed it. */
13529 current_function_decl = decl1;
13531 gcc_assert (DECL_INITIAL (decl1));
13533 /* This function may already have been parsed, in which case just
13534 return; our caller will skip over the body without parsing. */
13535 if (DECL_INITIAL (decl1) != error_mark_node)
13536 return true;
13538 /* Initialize RTL machinery. We cannot do this until
13539 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13540 even when processing a template; this is how we get
13541 CFUN set up, and our per-function variables initialized.
13542 FIXME factor out the non-RTL stuff. */
13543 bl = current_binding_level;
13544 allocate_struct_function (decl1, processing_template_decl);
13546 /* Initialize the language data structures. Whenever we start
13547 a new function, we destroy temporaries in the usual way. */
13548 cfun->language = ggc_cleared_alloc<language_function> ();
13549 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
13550 current_binding_level = bl;
13552 if (!processing_template_decl && type_uses_auto (restype))
13554 FNDECL_USED_AUTO (decl1) = true;
13555 current_function_auto_return_pattern = restype;
13558 /* Start the statement-tree, start the tree now. */
13559 DECL_SAVED_TREE (decl1) = push_stmt_list ();
13561 /* If we are (erroneously) defining a function that we have already
13562 defined before, wipe out what we knew before. */
13563 if (!DECL_PENDING_INLINE_P (decl1))
13564 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13566 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13568 /* We know that this was set up by `grokclassfn'. We do not
13569 wait until `store_parm_decls', since evil parse errors may
13570 never get us to that point. Here we keep the consistency
13571 between `current_class_type' and `current_class_ptr'. */
13572 tree t = DECL_ARGUMENTS (decl1);
13574 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
13575 gcc_assert (TYPE_PTR_P (TREE_TYPE (t)));
13577 cp_function_chain->x_current_class_ref
13578 = cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
13579 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13580 cp_function_chain->x_current_class_ptr = t;
13582 /* Constructors and destructors need to know whether they're "in
13583 charge" of initializing virtual base classes. */
13584 t = DECL_CHAIN (t);
13585 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13587 current_in_charge_parm = t;
13588 t = DECL_CHAIN (t);
13590 if (DECL_HAS_VTT_PARM_P (decl1))
13592 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
13593 current_vtt_parm = t;
13597 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
13598 /* Implicitly-defined methods (like the
13599 destructor for a class in which no destructor
13600 is explicitly declared) must not be defined
13601 until their definition is needed. So, we
13602 ignore interface specifications for
13603 compiler-generated functions. */
13604 && !DECL_ARTIFICIAL (decl1));
13606 if (processing_template_decl)
13607 /* Don't mess with interface flags. */;
13608 else if (DECL_INTERFACE_KNOWN (decl1))
13610 tree ctx = decl_function_context (decl1);
13612 if (DECL_NOT_REALLY_EXTERN (decl1))
13613 DECL_EXTERNAL (decl1) = 0;
13615 if (ctx != NULL_TREE && vague_linkage_p (ctx))
13616 /* This is a function in a local class in an extern inline
13617 or template function. */
13618 comdat_linkage (decl1);
13620 /* If this function belongs to an interface, it is public.
13621 If it belongs to someone else's interface, it is also external.
13622 This only affects inlines and template instantiations. */
13623 else if (!finfo->interface_unknown && honor_interface)
13625 if (DECL_DECLARED_INLINE_P (decl1)
13626 || DECL_TEMPLATE_INSTANTIATION (decl1))
13628 DECL_EXTERNAL (decl1)
13629 = (finfo->interface_only
13630 || (DECL_DECLARED_INLINE_P (decl1)
13631 && ! flag_implement_inlines
13632 && !DECL_VINDEX (decl1)));
13634 /* For WIN32 we also want to put these in linkonce sections. */
13635 maybe_make_one_only (decl1);
13637 else
13638 DECL_EXTERNAL (decl1) = 0;
13639 DECL_INTERFACE_KNOWN (decl1) = 1;
13640 /* If this function is in an interface implemented in this file,
13641 make sure that the back end knows to emit this function
13642 here. */
13643 if (!DECL_EXTERNAL (decl1))
13644 mark_needed (decl1);
13646 else if (finfo->interface_unknown && finfo->interface_only
13647 && honor_interface)
13649 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13650 interface, we will have both finfo->interface_unknown and
13651 finfo->interface_only set. In that case, we don't want to
13652 use the normal heuristics because someone will supply a
13653 #pragma implementation elsewhere, and deducing it here would
13654 produce a conflict. */
13655 comdat_linkage (decl1);
13656 DECL_EXTERNAL (decl1) = 0;
13657 DECL_INTERFACE_KNOWN (decl1) = 1;
13658 DECL_DEFER_OUTPUT (decl1) = 1;
13660 else
13662 /* This is a definition, not a reference.
13663 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13664 if (!GNU_INLINE_P (decl1))
13665 DECL_EXTERNAL (decl1) = 0;
13667 if ((DECL_DECLARED_INLINE_P (decl1)
13668 || DECL_TEMPLATE_INSTANTIATION (decl1))
13669 && ! DECL_INTERFACE_KNOWN (decl1))
13670 DECL_DEFER_OUTPUT (decl1) = 1;
13671 else
13672 DECL_INTERFACE_KNOWN (decl1) = 1;
13675 /* Determine the ELF visibility attribute for the function. We must not
13676 do this before calling "pushdecl", as we must allow "duplicate_decls"
13677 to merge any attributes appropriately. We also need to wait until
13678 linkage is set. */
13679 if (!DECL_CLONED_FUNCTION_P (decl1))
13680 determine_visibility (decl1);
13682 if (!processing_template_decl)
13683 maybe_instantiate_noexcept (decl1);
13685 begin_scope (sk_function_parms, decl1);
13687 ++function_depth;
13689 if (DECL_DESTRUCTOR_P (decl1)
13690 || (DECL_CONSTRUCTOR_P (decl1)
13691 && targetm.cxx.cdtor_returns_this ()))
13693 cdtor_label = create_artificial_label (input_location);
13696 start_fname_decls ();
13698 store_parm_decls (current_function_parms);
13700 if (!processing_template_decl
13701 && flag_lifetime_dse && DECL_CONSTRUCTOR_P (decl1))
13703 /* Insert a clobber to let the back end know that the object storage
13704 is dead when we enter the constructor. */
13705 tree btype = CLASSTYPE_AS_BASE (current_class_type);
13706 tree clobber = build_constructor (btype, NULL);
13707 TREE_THIS_VOLATILE (clobber) = true;
13708 tree bref = build_nop (build_reference_type (btype), current_class_ptr);
13709 bref = convert_from_reference (bref);
13710 tree exprstmt = build2 (MODIFY_EXPR, btype, bref, clobber);
13711 finish_expr_stmt (exprstmt);
13714 return true;
13718 /* Like start_preparsed_function, except that instead of a
13719 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13721 Returns true on success. If the DECLARATOR is not suitable
13722 for a function, we return false, which tells the parser to
13723 skip the entire function. */
13725 bool
13726 start_function (cp_decl_specifier_seq *declspecs,
13727 const cp_declarator *declarator,
13728 tree attrs)
13730 tree decl1;
13732 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
13733 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION, decl1);
13734 if (decl1 == error_mark_node)
13735 return false;
13736 /* If the declarator is not suitable for a function definition,
13737 cause a syntax error. */
13738 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13740 error ("invalid function declaration");
13741 return false;
13744 if (DECL_MAIN_P (decl1))
13745 /* main must return int. grokfndecl should have corrected it
13746 (and issued a diagnostic) if the user got it wrong. */
13747 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
13748 integer_type_node));
13750 return start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
13753 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13754 FN. */
13756 static bool
13757 use_eh_spec_block (tree fn)
13759 return (flag_exceptions && flag_enforce_eh_specs
13760 && !processing_template_decl
13761 && !type_throw_all_p (TREE_TYPE (fn))
13762 /* We insert the EH_SPEC_BLOCK only in the original
13763 function; then, it is copied automatically to the
13764 clones. */
13765 && !DECL_CLONED_FUNCTION_P (fn)
13766 /* Implicitly-generated constructors and destructors have
13767 exception specifications. However, those specifications
13768 are the union of the possible exceptions specified by the
13769 constructors/destructors for bases and members, so no
13770 unallowed exception will ever reach this function. By
13771 not creating the EH_SPEC_BLOCK we save a little memory,
13772 and we avoid spurious warnings about unreachable
13773 code. */
13774 && !DECL_DEFAULTED_FN (fn));
13777 /* Store the parameter declarations into the current function declaration.
13778 This is called after parsing the parameter declarations, before
13779 digesting the body of the function.
13781 Also install to binding contour return value identifier, if any. */
13783 static void
13784 store_parm_decls (tree current_function_parms)
13786 tree fndecl = current_function_decl;
13787 tree parm;
13789 /* This is a chain of any other decls that came in among the parm
13790 declarations. If a parm is declared with enum {foo, bar} x;
13791 then CONST_DECLs for foo and bar are put here. */
13792 tree nonparms = NULL_TREE;
13794 if (current_function_parms)
13796 /* This case is when the function was defined with an ANSI prototype.
13797 The parms already have decls, so we need not do anything here
13798 except record them as in effect
13799 and complain if any redundant old-style parm decls were written. */
13801 tree specparms = current_function_parms;
13802 tree next;
13804 /* Must clear this because it might contain TYPE_DECLs declared
13805 at class level. */
13806 current_binding_level->names = NULL;
13808 /* If we're doing semantic analysis, then we'll call pushdecl
13809 for each of these. We must do them in reverse order so that
13810 they end in the correct forward order. */
13811 specparms = nreverse (specparms);
13813 for (parm = specparms; parm; parm = next)
13815 next = DECL_CHAIN (parm);
13816 if (TREE_CODE (parm) == PARM_DECL)
13818 if (DECL_NAME (parm) == NULL_TREE
13819 || !VOID_TYPE_P (parm))
13820 pushdecl (parm);
13821 else
13822 error ("parameter %qD declared void", parm);
13824 else
13826 /* If we find an enum constant or a type tag,
13827 put it aside for the moment. */
13828 TREE_CHAIN (parm) = NULL_TREE;
13829 nonparms = chainon (nonparms, parm);
13833 /* Get the decls in their original chain order and record in the
13834 function. This is all and only the PARM_DECLs that were
13835 pushed into scope by the loop above. */
13836 DECL_ARGUMENTS (fndecl) = getdecls ();
13838 else
13839 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13841 /* Now store the final chain of decls for the arguments
13842 as the decl-chain of the current lexical scope.
13843 Put the enumerators in as well, at the front so that
13844 DECL_ARGUMENTS is not modified. */
13845 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
13847 if (use_eh_spec_block (current_function_decl))
13848 current_eh_spec_block = begin_eh_spec_block ();
13852 /* We have finished doing semantic analysis on DECL, but have not yet
13853 generated RTL for its body. Save away our current state, so that
13854 when we want to generate RTL later we know what to do. */
13856 static void
13857 save_function_data (tree decl)
13859 struct language_function *f;
13861 /* Save the language-specific per-function data so that we can
13862 get it back when we really expand this function. */
13863 gcc_assert (!DECL_PENDING_INLINE_P (decl));
13865 /* Make a copy. */
13866 f = ggc_alloc<language_function> ();
13867 memcpy (f, cp_function_chain, sizeof (struct language_function));
13868 DECL_SAVED_FUNCTION_DATA (decl) = f;
13870 /* Clear out the bits we don't need. */
13871 f->base.x_stmt_tree.x_cur_stmt_list = NULL;
13872 f->bindings = NULL;
13873 f->x_local_names = NULL;
13874 f->base.local_typedefs = NULL;
13878 /* Set the return value of the constructor (if present). */
13880 static void
13881 finish_constructor_body (void)
13883 tree val;
13884 tree exprstmt;
13886 if (targetm.cxx.cdtor_returns_this ()
13887 && (! TYPE_FOR_JAVA (current_class_type)))
13889 /* Any return from a constructor will end up here. */
13890 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13892 val = DECL_ARGUMENTS (current_function_decl);
13893 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13894 DECL_RESULT (current_function_decl), val);
13895 /* Return the address of the object. */
13896 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13897 add_stmt (exprstmt);
13901 /* Do all the processing for the beginning of a destructor; set up the
13902 vtable pointers and cleanups for bases and members. */
13904 static void
13905 begin_destructor_body (void)
13907 tree compound_stmt;
13909 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13910 issued an error message. We still want to try to process the
13911 body of the function, but initialize_vtbl_ptrs will crash if
13912 TYPE_BINFO is NULL. */
13913 if (COMPLETE_TYPE_P (current_class_type))
13915 compound_stmt = begin_compound_stmt (0);
13916 /* Make all virtual function table pointers in non-virtual base
13917 classes point to CURRENT_CLASS_TYPE's virtual function
13918 tables. */
13919 initialize_vtbl_ptrs (current_class_ptr);
13920 finish_compound_stmt (compound_stmt);
13922 if (flag_lifetime_dse)
13924 /* Insert a cleanup to let the back end know that the object is dead
13925 when we exit the destructor, either normally or via exception. */
13926 tree btype = CLASSTYPE_AS_BASE (current_class_type);
13927 tree clobber = build_constructor (btype, NULL);
13928 TREE_THIS_VOLATILE (clobber) = true;
13929 tree bref = build_nop (build_reference_type (btype),
13930 current_class_ptr);
13931 bref = convert_from_reference (bref);
13932 tree exprstmt = build2 (MODIFY_EXPR, btype, bref, clobber);
13933 finish_decl_cleanup (NULL_TREE, exprstmt);
13936 /* And insert cleanups for our bases and members so that they
13937 will be properly destroyed if we throw. */
13938 push_base_cleanups ();
13942 /* At the end of every destructor we generate code to delete the object if
13943 necessary. Do that now. */
13945 static void
13946 finish_destructor_body (void)
13948 tree exprstmt;
13950 /* Any return from a destructor will end up here; that way all base
13951 and member cleanups will be run when the function returns. */
13952 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13954 /* In a virtual destructor, we must call delete. */
13955 if (DECL_VIRTUAL_P (current_function_decl))
13957 tree if_stmt;
13958 tree virtual_size = cxx_sizeof (current_class_type);
13960 /* [class.dtor]
13962 At the point of definition of a virtual destructor (including
13963 an implicit definition), non-placement operator delete shall
13964 be looked up in the scope of the destructor's class and if
13965 found shall be accessible and unambiguous. */
13966 exprstmt = build_op_delete_call (DELETE_EXPR, current_class_ptr,
13967 virtual_size,
13968 /*global_p=*/false,
13969 /*placement=*/NULL_TREE,
13970 /*alloc_fn=*/NULL_TREE,
13971 tf_warning_or_error);
13973 if_stmt = begin_if_stmt ();
13974 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
13975 current_in_charge_parm,
13976 integer_one_node),
13977 if_stmt);
13978 finish_expr_stmt (exprstmt);
13979 finish_then_clause (if_stmt);
13980 finish_if_stmt (if_stmt);
13983 if (targetm.cxx.cdtor_returns_this ())
13985 tree val;
13987 val = DECL_ARGUMENTS (current_function_decl);
13988 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13989 DECL_RESULT (current_function_decl), val);
13990 /* Return the address of the object. */
13991 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13992 add_stmt (exprstmt);
13996 /* Do the necessary processing for the beginning of a function body, which
13997 in this case includes member-initializers, but not the catch clauses of
13998 a function-try-block. Currently, this means opening a binding level
13999 for the member-initializers (in a ctor), member cleanups (in a dtor),
14000 and capture proxies (in a lambda operator()). */
14002 tree
14003 begin_function_body (void)
14005 tree stmt;
14007 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
14008 return NULL_TREE;
14010 if (processing_template_decl)
14011 /* Do nothing now. */;
14012 else
14013 /* Always keep the BLOCK node associated with the outermost pair of
14014 curly braces of a function. These are needed for correct
14015 operation of dwarfout.c. */
14016 keep_next_level (true);
14018 stmt = begin_compound_stmt (BCS_FN_BODY);
14020 if (processing_template_decl)
14021 /* Do nothing now. */;
14022 else if (DECL_DESTRUCTOR_P (current_function_decl))
14023 begin_destructor_body ();
14025 return stmt;
14028 /* Do the processing for the end of a function body. Currently, this means
14029 closing out the cleanups for fully-constructed bases and members, and in
14030 the case of the destructor, deleting the object if desired. Again, this
14031 is only meaningful for [cd]tors, since they are the only functions where
14032 there is a significant distinction between the main body and any
14033 function catch clauses. Handling, say, main() return semantics here
14034 would be wrong, as flowing off the end of a function catch clause for
14035 main() would also need to return 0. */
14037 void
14038 finish_function_body (tree compstmt)
14040 if (compstmt == NULL_TREE)
14041 return;
14043 /* Close the block. */
14044 finish_compound_stmt (compstmt);
14046 if (processing_template_decl)
14047 /* Do nothing now. */;
14048 else if (DECL_CONSTRUCTOR_P (current_function_decl))
14049 finish_constructor_body ();
14050 else if (DECL_DESTRUCTOR_P (current_function_decl))
14051 finish_destructor_body ();
14054 /* Given a function, returns the BLOCK corresponding to the outermost level
14055 of curly braces, skipping the artificial block created for constructor
14056 initializers. */
14058 tree
14059 outer_curly_brace_block (tree fndecl)
14061 tree block = DECL_INITIAL (fndecl);
14062 if (BLOCK_OUTER_CURLY_BRACE_P (block))
14063 return block;
14064 block = BLOCK_SUBBLOCKS (block);
14065 if (BLOCK_OUTER_CURLY_BRACE_P (block))
14066 return block;
14067 block = BLOCK_SUBBLOCKS (block);
14068 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block));
14069 return block;
14072 /* If FNDECL is a class's key method, add the class to the list of
14073 keyed classes that should be emitted. */
14075 static void
14076 record_key_method_defined (tree fndecl)
14078 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
14079 && DECL_VIRTUAL_P (fndecl)
14080 && !processing_template_decl)
14082 tree fnclass = DECL_CONTEXT (fndecl);
14083 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
14084 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
14088 /* Subroutine of finish_function.
14089 Save the body of constexpr functions for possible
14090 future compile time evaluation. */
14092 static void
14093 maybe_save_function_definition (tree fun)
14095 if (!processing_template_decl
14096 && DECL_DECLARED_CONSTEXPR_P (fun)
14097 && !cp_function_chain->invalid_constexpr
14098 && !DECL_CLONED_FUNCTION_P (fun))
14099 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
14102 /* Finish up a function declaration and compile that function
14103 all the way to assembler language output. The free the storage
14104 for the function definition.
14106 FLAGS is a bitwise or of the following values:
14107 2 - INCLASS_INLINE
14108 We just finished processing the body of an in-class inline
14109 function definition. (This processing will have taken place
14110 after the class definition is complete.) */
14112 tree
14113 finish_function (int flags)
14115 tree fndecl = current_function_decl;
14116 tree fntype, ctype = NULL_TREE;
14117 int inclass_inline = (flags & 2) != 0;
14119 /* When we get some parse errors, we can end up without a
14120 current_function_decl, so cope. */
14121 if (fndecl == NULL_TREE)
14122 return error_mark_node;
14124 if (c_dialect_objc ())
14125 objc_finish_function ();
14127 gcc_assert (!defer_mark_used_calls);
14128 defer_mark_used_calls = true;
14130 record_key_method_defined (fndecl);
14132 fntype = TREE_TYPE (fndecl);
14134 /* TREE_READONLY (fndecl) = 1;
14135 This caused &foo to be of type ptr-to-const-function
14136 which then got a warning when stored in a ptr-to-function variable. */
14138 gcc_assert (building_stmt_list_p ());
14139 /* The current function is being defined, so its DECL_INITIAL should
14140 be set, and unless there's a multiple definition, it should be
14141 error_mark_node. */
14142 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
14144 /* For a cloned function, we've already got all the code we need;
14145 there's no need to add any extra bits. */
14146 if (!DECL_CLONED_FUNCTION_P (fndecl))
14148 /* Make it so that `main' always returns 0 by default. */
14149 if (DECL_MAIN_P (current_function_decl))
14150 finish_return_stmt (integer_zero_node);
14152 if (use_eh_spec_block (current_function_decl))
14153 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14154 (TREE_TYPE (current_function_decl)),
14155 current_eh_spec_block);
14158 /* If we're saving up tree structure, tie off the function now. */
14159 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
14161 if (fn_contains_cilk_spawn_p (cfun) && !processing_template_decl)
14162 cfun->cilk_frame_decl = insert_cilk_frame (fndecl);
14164 finish_fname_decls ();
14166 /* If this function can't throw any exceptions, remember that. */
14167 if (!processing_template_decl
14168 && !cp_function_chain->can_throw
14169 && !flag_non_call_exceptions
14170 && !decl_replaceable_p (fndecl))
14171 TREE_NOTHROW (fndecl) = 1;
14173 /* This must come after expand_function_end because cleanups might
14174 have declarations (from inline functions) that need to go into
14175 this function's blocks. */
14177 /* If the current binding level isn't the outermost binding level
14178 for this function, either there is a bug, or we have experienced
14179 syntax errors and the statement tree is malformed. */
14180 if (current_binding_level->kind != sk_function_parms)
14182 /* Make sure we have already experienced errors. */
14183 gcc_assert (errorcount);
14185 /* Throw away the broken statement tree and extra binding
14186 levels. */
14187 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
14189 while (current_binding_level->kind != sk_function_parms)
14191 if (current_binding_level->kind == sk_class)
14192 pop_nested_class ();
14193 else
14194 poplevel (0, 0, 0);
14197 poplevel (1, 0, 1);
14199 /* Statements should always be full-expressions at the outermost set
14200 of curly braces for a function. */
14201 gcc_assert (stmts_are_full_exprs_p ());
14203 /* If there are no return statements in a function with auto return type,
14204 the return type is void. But if the declared type is something like
14205 auto*, this is an error. */
14206 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
14207 && TREE_TYPE (fntype) == current_function_auto_return_pattern)
14209 if (!is_auto (current_function_auto_return_pattern)
14210 && !current_function_returns_value && !current_function_returns_null)
14212 error ("no return statements in function returning %qT",
14213 current_function_auto_return_pattern);
14214 inform (input_location, "only plain %<auto%> return type can be "
14215 "deduced to %<void%>");
14217 apply_deduced_return_type (fndecl, void_type_node);
14218 fntype = TREE_TYPE (fndecl);
14221 /* Save constexpr function body before it gets munged by
14222 the NRV transformation. */
14223 maybe_save_function_definition (fndecl);
14225 /* Set up the named return value optimization, if we can. Candidate
14226 variables are selected in check_return_expr. */
14227 if (current_function_return_value)
14229 tree r = current_function_return_value;
14230 tree outer;
14232 if (r != error_mark_node
14233 /* This is only worth doing for fns that return in memory--and
14234 simpler, since we don't have to worry about promoted modes. */
14235 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
14236 /* Only allow this for variables declared in the outer scope of
14237 the function so we know that their lifetime always ends with a
14238 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14239 we were to do this optimization in tree-ssa. */
14240 && (outer = outer_curly_brace_block (fndecl))
14241 && chain_member (r, BLOCK_VARS (outer)))
14242 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
14244 current_function_return_value = NULL_TREE;
14247 /* Remember that we were in class scope. */
14248 if (current_class_name)
14249 ctype = current_class_type;
14251 /* Must mark the RESULT_DECL as being in this function. */
14252 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14254 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14255 to the FUNCTION_DECL node itself. */
14256 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14258 /* Save away current state, if appropriate. */
14259 if (!processing_template_decl)
14260 save_function_data (fndecl);
14262 /* Complain if there's just no return statement. */
14263 if (warn_return_type
14264 && !VOID_TYPE_P (TREE_TYPE (fntype))
14265 && !dependent_type_p (TREE_TYPE (fntype))
14266 && !current_function_returns_value && !current_function_returns_null
14267 /* Don't complain if we abort or throw. */
14268 && !current_function_returns_abnormally
14269 /* Don't complain if there's an infinite loop. */
14270 && !current_function_infinite_loop
14271 /* Don't complain if we are declared noreturn. */
14272 && !TREE_THIS_VOLATILE (fndecl)
14273 && !DECL_NAME (DECL_RESULT (fndecl))
14274 && !TREE_NO_WARNING (fndecl)
14275 /* Structor return values (if any) are set by the compiler. */
14276 && !DECL_CONSTRUCTOR_P (fndecl)
14277 && !DECL_DESTRUCTOR_P (fndecl)
14278 && targetm.warn_func_return (fndecl))
14280 warning (OPT_Wreturn_type,
14281 "no return statement in function returning non-void");
14282 TREE_NO_WARNING (fndecl) = 1;
14285 /* Store the end of the function, so that we get good line number
14286 info for the epilogue. */
14287 cfun->function_end_locus = input_location;
14289 /* Complain about parameters that are only set, but never otherwise used. */
14290 if (warn_unused_but_set_parameter
14291 && !processing_template_decl
14292 && errorcount == unused_but_set_errorcount
14293 && !DECL_CLONED_FUNCTION_P (fndecl))
14295 tree decl;
14297 for (decl = DECL_ARGUMENTS (fndecl);
14298 decl;
14299 decl = DECL_CHAIN (decl))
14300 if (TREE_USED (decl)
14301 && TREE_CODE (decl) == PARM_DECL
14302 && !DECL_READ_P (decl)
14303 && DECL_NAME (decl)
14304 && !DECL_ARTIFICIAL (decl)
14305 && !TREE_NO_WARNING (decl)
14306 && !DECL_IN_SYSTEM_HEADER (decl)
14307 && TREE_TYPE (decl) != error_mark_node
14308 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
14309 && (!CLASS_TYPE_P (TREE_TYPE (decl))
14310 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
14311 warning (OPT_Wunused_but_set_parameter,
14312 "parameter %q+D set but not used", decl);
14313 unused_but_set_errorcount = errorcount;
14316 /* Complain about locally defined typedefs that are not used in this
14317 function. */
14318 maybe_warn_unused_local_typedefs ();
14320 /* Genericize before inlining. */
14321 if (!processing_template_decl)
14323 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
14324 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
14325 cp_genericize (fndecl);
14326 /* Clear out the bits we don't need. */
14327 f->x_current_class_ptr = NULL;
14328 f->x_current_class_ref = NULL;
14329 f->x_eh_spec_block = NULL;
14330 f->x_in_charge_parm = NULL;
14331 f->x_vtt_parm = NULL;
14332 f->x_return_value = NULL;
14333 f->bindings = NULL;
14334 f->extern_decl_map = NULL;
14335 f->infinite_loops = NULL;
14337 /* Clear out the bits we don't need. */
14338 local_names = NULL;
14340 /* We're leaving the context of this function, so zap cfun. It's still in
14341 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14342 set_cfun (NULL);
14343 current_function_decl = NULL;
14345 /* If this is an in-class inline definition, we may have to pop the
14346 bindings for the template parameters that we added in
14347 maybe_begin_member_template_processing when start_function was
14348 called. */
14349 if (inclass_inline)
14350 maybe_end_member_template_processing ();
14352 /* Leave the scope of the class. */
14353 if (ctype)
14354 pop_nested_class ();
14356 --function_depth;
14358 /* Clean up. */
14359 current_function_decl = NULL_TREE;
14361 defer_mark_used_calls = false;
14362 if (deferred_mark_used_calls)
14364 unsigned int i;
14365 tree decl;
14367 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls, i, decl)
14368 mark_used (decl);
14369 vec_free (deferred_mark_used_calls);
14372 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION, fndecl);
14373 return fndecl;
14376 /* Create the FUNCTION_DECL for a function definition.
14377 DECLSPECS and DECLARATOR are the parts of the declaration;
14378 they describe the return type and the name of the function,
14379 but twisted together in a fashion that parallels the syntax of C.
14381 This function creates a binding context for the function body
14382 as well as setting up the FUNCTION_DECL in current_function_decl.
14384 Returns a FUNCTION_DECL on success.
14386 If the DECLARATOR is not suitable for a function (it defines a datum
14387 instead), we return 0, which tells yyparse to report a parse error.
14389 May return void_type_node indicating that this method is actually
14390 a friend. See grokfield for more details.
14392 Came here with a `.pushlevel' .
14394 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14395 CHANGES TO CODE IN `grokfield'. */
14397 tree
14398 grokmethod (cp_decl_specifier_seq *declspecs,
14399 const cp_declarator *declarator, tree attrlist)
14401 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14402 &attrlist);
14404 if (fndecl == error_mark_node)
14405 return error_mark_node;
14407 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14409 error ("invalid member function declaration");
14410 return error_mark_node;
14413 if (attrlist)
14414 cplus_decl_attributes (&fndecl, attrlist, 0);
14416 /* Pass friends other than inline friend functions back. */
14417 if (fndecl == void_type_node)
14418 return fndecl;
14420 if (DECL_IN_AGGR_P (fndecl))
14422 if (DECL_CLASS_SCOPE_P (fndecl))
14423 error ("%qD is already defined in class %qT", fndecl,
14424 DECL_CONTEXT (fndecl));
14425 return error_mark_node;
14428 check_template_shadow (fndecl);
14430 if (TREE_PUBLIC (fndecl))
14431 DECL_COMDAT (fndecl) = 1;
14432 DECL_DECLARED_INLINE_P (fndecl) = 1;
14433 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
14435 /* We process method specializations in finish_struct_1. */
14436 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14438 fndecl = push_template_decl (fndecl);
14439 if (fndecl == error_mark_node)
14440 return fndecl;
14443 if (! DECL_FRIEND_P (fndecl))
14445 if (DECL_CHAIN (fndecl))
14447 fndecl = copy_node (fndecl);
14448 TREE_CHAIN (fndecl) = NULL_TREE;
14452 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
14454 DECL_IN_AGGR_P (fndecl) = 1;
14455 return fndecl;
14459 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14460 we can lay it out later, when and if its type becomes complete.
14462 Also handle constexpr variables where the initializer involves
14463 an unlowered PTRMEM_CST because the class isn't complete yet. */
14465 void
14466 maybe_register_incomplete_var (tree var)
14468 gcc_assert (VAR_P (var));
14470 /* Keep track of variables with incomplete types. */
14471 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14472 && DECL_EXTERNAL (var))
14474 tree inner_type = TREE_TYPE (var);
14476 while (TREE_CODE (inner_type) == ARRAY_TYPE)
14477 inner_type = TREE_TYPE (inner_type);
14478 inner_type = TYPE_MAIN_VARIANT (inner_type);
14480 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14481 /* RTTI TD entries are created while defining the type_info. */
14482 || (TYPE_LANG_SPECIFIC (inner_type)
14483 && TYPE_BEING_DEFINED (inner_type)))
14485 incomplete_var iv = {var, inner_type};
14486 vec_safe_push (incomplete_vars, iv);
14488 else if (!(DECL_LANG_SPECIFIC (var) && DECL_TEMPLATE_INFO (var))
14489 && decl_constant_var_p (var)
14490 && (TYPE_PTRMEM_P (inner_type) || CLASS_TYPE_P (inner_type)))
14492 /* When the outermost open class is complete we can resolve any
14493 pointers-to-members. */
14494 tree context = outermost_open_class ();
14495 incomplete_var iv = {var, context};
14496 vec_safe_push (incomplete_vars, iv);
14501 /* Called when a class type (given by TYPE) is defined. If there are
14502 any existing VAR_DECLs whose type has been completed by this
14503 declaration, update them now. */
14505 void
14506 complete_vars (tree type)
14508 unsigned ix;
14509 incomplete_var *iv;
14511 for (ix = 0; vec_safe_iterate (incomplete_vars, ix, &iv); )
14513 if (same_type_p (type, iv->incomplete_type))
14515 tree var = iv->decl;
14516 tree type = TREE_TYPE (var);
14518 if (TYPE_MAIN_VARIANT (strip_array_types (type))
14519 == iv->incomplete_type)
14521 /* Complete the type of the variable. The VAR_DECL itself
14522 will be laid out in expand_expr. */
14523 complete_type (type);
14524 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
14527 if (DECL_INITIAL (var)
14528 && decl_constant_var_p (var))
14529 DECL_INITIAL (var) = cplus_expand_constant (DECL_INITIAL (var));
14531 /* Remove this entry from the list. */
14532 incomplete_vars->unordered_remove (ix);
14534 else
14535 ix++;
14538 /* Check for pending declarations which may have abstract type. */
14539 complete_type_check_abstract (type);
14542 /* If DECL is of a type which needs a cleanup, build and return an
14543 expression to perform that cleanup here. Return NULL_TREE if no
14544 cleanup need be done. */
14546 tree
14547 cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
14549 tree type;
14550 tree attr;
14551 tree cleanup;
14553 /* Assume no cleanup is required. */
14554 cleanup = NULL_TREE;
14556 if (error_operand_p (decl))
14557 return cleanup;
14559 /* Handle "__attribute__((cleanup))". We run the cleanup function
14560 before the destructor since the destructor is what actually
14561 terminates the lifetime of the object. */
14562 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
14563 if (attr)
14565 tree id;
14566 tree fn;
14567 tree arg;
14569 /* Get the name specified by the user for the cleanup function. */
14570 id = TREE_VALUE (TREE_VALUE (attr));
14571 /* Look up the name to find the cleanup function to call. It is
14572 important to use lookup_name here because that is what is
14573 used in c-common.c:handle_cleanup_attribute when performing
14574 initial checks on the attribute. Note that those checks
14575 include ensuring that the function found is not an overloaded
14576 function, or an object with an overloaded call operator,
14577 etc.; we can rely on the fact that the function found is an
14578 ordinary FUNCTION_DECL. */
14579 fn = lookup_name (id);
14580 arg = build_address (decl);
14581 if (!mark_used (decl, complain) && !(complain & tf_error))
14582 return error_mark_node;
14583 cleanup = cp_build_function_call_nary (fn, complain, arg, NULL_TREE);
14584 if (cleanup == error_mark_node)
14585 return error_mark_node;
14587 /* Handle ordinary C++ destructors. */
14588 type = TREE_TYPE (decl);
14589 if (type_build_dtor_call (type))
14591 int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR;
14592 tree addr;
14593 tree call;
14595 if (TREE_CODE (type) == ARRAY_TYPE)
14596 addr = decl;
14597 else
14598 addr = build_address (decl);
14600 call = build_delete (TREE_TYPE (addr), addr,
14601 sfk_complete_destructor, flags, 0, complain);
14602 if (call == error_mark_node)
14603 cleanup = error_mark_node;
14604 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
14605 /* Discard the call. */;
14606 else if (cleanup)
14607 cleanup = cp_build_compound_expr (cleanup, call, complain);
14608 else
14609 cleanup = call;
14612 /* build_delete sets the location of the destructor call to the
14613 current location, even though the destructor is going to be
14614 called later, at the end of the current scope. This can lead to
14615 a "jumpy" behaviour for users of debuggers when they step around
14616 the end of the block. So let's unset the location of the
14617 destructor call instead. */
14618 if (cleanup != NULL && EXPR_P (cleanup))
14619 SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION);
14621 if (cleanup
14622 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl)))
14623 /* Treat objects with destructors as used; the destructor may do
14624 something substantive. */
14625 && !mark_used (decl, complain) && !(complain & tf_error))
14626 return error_mark_node;
14628 return cleanup;
14632 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14633 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14634 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14636 tree
14637 static_fn_type (tree memfntype)
14639 tree fntype;
14640 tree args;
14642 if (TYPE_PTRMEMFUNC_P (memfntype))
14643 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
14644 if (POINTER_TYPE_P (memfntype)
14645 || TREE_CODE (memfntype) == FUNCTION_DECL)
14646 memfntype = TREE_TYPE (memfntype);
14647 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
14648 return memfntype;
14649 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
14650 args = TYPE_ARG_TYPES (memfntype);
14651 cp_ref_qualifier rqual = type_memfn_rqual (memfntype);
14652 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
14653 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype), rqual);
14654 fntype = (cp_build_type_attribute_variant
14655 (fntype, TYPE_ATTRIBUTES (memfntype)));
14656 fntype = (build_exception_variant
14657 (fntype, TYPE_RAISES_EXCEPTIONS (memfntype)));
14658 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype))
14659 TYPE_HAS_LATE_RETURN_TYPE (fntype) = 1;
14660 return fntype;
14663 /* DECL was originally constructed as a non-static member function,
14664 but turned out to be static. Update it accordingly. */
14666 void
14667 revert_static_member_fn (tree decl)
14669 tree stype = static_fn_type (decl);
14670 cp_cv_quals quals = type_memfn_quals (stype);
14671 cp_ref_qualifier rqual = type_memfn_rqual (stype);
14673 if (quals != TYPE_UNQUALIFIED || rqual != REF_QUAL_NONE)
14674 stype = apply_memfn_quals (stype, TYPE_UNQUALIFIED, REF_QUAL_NONE);
14676 TREE_TYPE (decl) = stype;
14678 if (DECL_ARGUMENTS (decl))
14679 DECL_ARGUMENTS (decl) = DECL_CHAIN (DECL_ARGUMENTS (decl));
14680 DECL_STATIC_FUNCTION_P (decl) = 1;
14683 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14684 one of the language-independent trees. */
14686 enum cp_tree_node_structure_enum
14687 cp_tree_node_structure (union lang_tree_node * t)
14689 switch (TREE_CODE (&t->generic))
14691 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
14692 case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT;
14693 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
14694 case OVERLOAD: return TS_CP_OVERLOAD;
14695 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
14696 case PTRMEM_CST: return TS_CP_PTRMEM;
14697 case BASELINK: return TS_CP_BASELINK;
14698 case TEMPLATE_DECL: return TS_CP_TEMPLATE_DECL;
14699 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
14700 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
14701 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
14702 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR;
14703 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO;
14704 case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL;
14705 default: return TS_CP_GENERIC;
14709 /* Build the void_list_node (void_type_node having been created). */
14710 tree
14711 build_void_list_node (void)
14713 tree t = build_tree_list (NULL_TREE, void_type_node);
14714 return t;
14717 bool
14718 cp_missing_noreturn_ok_p (tree decl)
14720 /* A missing noreturn is ok for the `main' function. */
14721 return DECL_MAIN_P (decl);
14724 /* Return the decl used to identify the COMDAT group into which DECL should
14725 be placed. */
14727 tree
14728 cxx_comdat_group (tree decl)
14730 /* Virtual tables, construction virtual tables, and virtual table
14731 tables all go in a single COMDAT group, named after the primary
14732 virtual table. */
14733 if (VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl))
14734 decl = CLASSTYPE_VTABLES (DECL_CONTEXT (decl));
14735 /* For all other DECLs, the COMDAT group is the mangled name of the
14736 declaration itself. */
14737 else
14739 while (DECL_THUNK_P (decl))
14741 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14742 into the same section as the target function. In that case
14743 we must return target's name. */
14744 tree target = THUNK_TARGET (decl);
14745 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
14746 && DECL_SECTION_NAME (target) != NULL
14747 && DECL_ONE_ONLY (target))
14748 decl = target;
14749 else
14750 break;
14754 return decl;
14757 /* Returns the return type for FN as written by the user, which may include
14758 a placeholder for a deduced return type. */
14760 tree
14761 fndecl_declared_return_type (tree fn)
14763 fn = STRIP_TEMPLATE (fn);
14764 if (FNDECL_USED_AUTO (fn))
14766 struct language_function *f = NULL;
14767 if (DECL_STRUCT_FUNCTION (fn))
14768 f = DECL_STRUCT_FUNCTION (fn)->language;
14769 if (f == NULL)
14770 f = DECL_SAVED_FUNCTION_DATA (fn);
14771 return f->x_auto_return_pattern;
14773 return TREE_TYPE (TREE_TYPE (fn));
14776 /* Returns true iff DECL was declared with an auto return type and it has
14777 not yet been deduced to a real type. */
14779 bool
14780 undeduced_auto_decl (tree decl)
14782 if (cxx_dialect < cxx14)
14783 return false;
14784 return type_uses_auto (TREE_TYPE (decl));
14787 /* Complain if DECL has an undeduced return type. */
14789 void
14790 require_deduced_type (tree decl)
14792 if (undeduced_auto_decl (decl))
14793 error ("use of %qD before deduction of %<auto%>", decl);
14796 #include "gt-cp-decl.h"