* xvasprintf.c: New file.
[official-gcc.git] / gcc / cp / decl.c
blob9659336f01d122e734aab67abd09a20afa563de1
1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2014 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 "tree.h"
34 #include "tree-hasher.h"
35 #include "stringpool.h"
36 #include "stor-layout.h"
37 #include "varasm.h"
38 #include "attribs.h"
39 #include "calls.h"
40 #include "flags.h"
41 #include "cp-tree.h"
42 #include "tree-iterator.h"
43 #include "tree-inline.h"
44 #include "decl.h"
45 #include "intl.h"
46 #include "toplev.h"
47 #include "hashtab.h"
48 #include "tm_p.h"
49 #include "target.h"
50 #include "c-family/c-common.h"
51 #include "c-family/c-objc.h"
52 #include "c-family/c-pragma.h"
53 #include "c-family/c-target.h"
54 #include "c-family/c-ubsan.h"
55 #include "diagnostic.h"
56 #include "intl.h"
57 #include "debug.h"
58 #include "timevar.h"
59 #include "splay-tree.h"
60 #include "plugin.h"
61 #include "hash-map.h"
62 #include "is-a.h"
63 #include "plugin-api.h"
64 #include "vec.h"
65 #include "hash-set.h"
66 #include "machmode.h"
67 #include "hard-reg-set.h"
68 #include "input.h"
69 #include "function.h"
70 #include "ipa-ref.h"
71 #include "cgraph.h"
72 #include "cilk.h"
73 #include "wide-int.h"
74 #include "builtins.h"
76 /* Possible cases of bad specifiers type used by bad_specifiers. */
77 enum bad_spec_place {
78 BSP_VAR, /* variable */
79 BSP_PARM, /* parameter */
80 BSP_TYPE, /* type */
81 BSP_FIELD /* field */
84 static tree grokparms (tree parmlist, tree *);
85 static const char *redeclaration_error_message (tree, tree);
87 static int decl_jump_unsafe (tree);
88 static void require_complete_types_for_parms (tree);
89 static int ambi_op_p (enum tree_code);
90 static int unary_op_p (enum tree_code);
91 static void push_local_name (tree);
92 static tree grok_reference_init (tree, tree, tree, int);
93 static tree grokvardecl (tree, tree, tree, const cp_decl_specifier_seq *,
94 int, int, int, tree);
95 static int check_static_variable_definition (tree, tree);
96 static void record_unknown_type (tree, const char *);
97 static tree builtin_function_1 (tree, tree, bool);
98 static int member_function_or_else (tree, tree, enum overload_flags);
99 static void bad_specifiers (tree, enum bad_spec_place, int, int, int, int,
100 int);
101 static void check_for_uninitialized_const_var (tree);
102 static tree local_variable_p_walkfn (tree *, int *, void *);
103 static tree record_builtin_java_type (const char *, int);
104 static const char *tag_name (enum tag_types);
105 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
106 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
107 static void maybe_deduce_size_from_array_init (tree, tree);
108 static void layout_var_decl (tree);
109 static tree check_initializer (tree, tree, int, vec<tree, va_gc> **);
110 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
111 static void save_function_data (tree);
112 static void copy_type_enum (tree , tree);
113 static void check_function_type (tree, tree);
114 static void finish_constructor_body (void);
115 static void begin_destructor_body (void);
116 static void finish_destructor_body (void);
117 static void record_key_method_defined (tree);
118 static tree create_array_type_for_decl (tree, tree, tree);
119 static tree get_atexit_node (void);
120 static tree get_dso_handle_node (void);
121 static tree start_cleanup_fn (void);
122 static void end_cleanup_fn (void);
123 static tree cp_make_fname_decl (location_t, tree, int);
124 static void initialize_predefined_identifiers (void);
125 static tree check_special_function_return_type
126 (special_function_kind, tree, tree);
127 static tree push_cp_library_fn (enum tree_code, tree, int);
128 static tree build_cp_library_fn (tree, enum tree_code, tree, int);
129 static void store_parm_decls (tree);
130 static void initialize_local_var (tree, tree);
131 static void expand_static_init (tree, tree);
133 /* The following symbols are subsumed in the cp_global_trees array, and
134 listed here individually for documentation purposes.
136 C++ extensions
137 tree wchar_decl_node;
139 tree vtable_entry_type;
140 tree delta_type_node;
141 tree __t_desc_type_node;
143 tree class_type_node;
144 tree unknown_type_node;
146 Array type `vtable_entry_type[]'
148 tree vtbl_type_node;
149 tree vtbl_ptr_type_node;
151 Namespaces,
153 tree std_node;
154 tree abi_node;
156 A FUNCTION_DECL which can call `abort'. Not necessarily the
157 one that the user will declare, but sufficient to be called
158 by routines that want to abort the program.
160 tree abort_fndecl;
162 The FUNCTION_DECL for the default `::operator delete'.
164 tree global_delete_fndecl;
166 Used by RTTI
167 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
168 tree tinfo_var_id; */
170 tree cp_global_trees[CPTI_MAX];
172 /* Indicates that there is a type value in some namespace, although
173 that is not necessarily in scope at the moment. */
175 tree global_type_node;
177 /* The node that holds the "name" of the global scope. */
178 tree global_scope_name;
180 #define local_names cp_function_chain->x_local_names
182 /* A list of objects which have constructors or destructors
183 which reside in the global scope. The decl is stored in
184 the TREE_VALUE slot and the initializer is stored
185 in the TREE_PURPOSE slot. */
186 tree static_aggregates;
188 /* Like static_aggregates, but for thread_local variables. */
189 tree tls_aggregates;
191 /* -- end of C++ */
193 /* A node for the integer constant 2. */
195 tree integer_two_node;
197 /* Used only for jumps to as-yet undefined labels, since jumps to
198 defined labels can have their validity checked immediately. */
200 struct GTY((chain_next ("%h.next"))) named_label_use_entry {
201 struct named_label_use_entry *next;
202 /* The binding level to which this entry is *currently* attached.
203 This is initially the binding level in which the goto appeared,
204 but is modified as scopes are closed. */
205 cp_binding_level *binding_level;
206 /* The head of the names list that was current when the goto appeared,
207 or the inner scope popped. These are the decls that will *not* be
208 skipped when jumping to the label. */
209 tree names_in_scope;
210 /* The location of the goto, for error reporting. */
211 location_t o_goto_locus;
212 /* True if an OpenMP structured block scope has been closed since
213 the goto appeared. This means that the branch from the label will
214 illegally exit an OpenMP scope. */
215 bool in_omp_scope;
218 /* A list of all LABEL_DECLs in the function that have names. Here so
219 we can clear out their names' definitions at the end of the
220 function, and so we can check the validity of jumps to these labels. */
222 struct GTY((for_user)) named_label_entry {
223 /* The decl itself. */
224 tree label_decl;
226 /* The binding level to which the label is *currently* attached.
227 This is initially set to the binding level in which the label
228 is defined, but is modified as scopes are closed. */
229 cp_binding_level *binding_level;
230 /* The head of the names list that was current when the label was
231 defined, or the inner scope popped. These are the decls that will
232 be skipped when jumping to the label. */
233 tree names_in_scope;
234 /* A vector of all decls from all binding levels that would be
235 crossed by a backward branch to the label. */
236 vec<tree, va_gc> *bad_decls;
238 /* A list of uses of the label, before the label is defined. */
239 struct named_label_use_entry *uses;
241 /* The following bits are set after the label is defined, and are
242 updated as scopes are popped. They indicate that a backward jump
243 to the label will illegally enter a scope of the given flavor. */
244 bool in_try_scope;
245 bool in_catch_scope;
246 bool in_omp_scope;
249 #define named_labels cp_function_chain->x_named_labels
251 /* The number of function bodies which we are currently processing.
252 (Zero if we are at namespace scope, one inside the body of a
253 function, two inside the body of a function in a local class, etc.) */
254 int function_depth;
256 /* To avoid unwanted recursion, finish_function defers all mark_used calls
257 encountered during its execution until it finishes. */
258 bool defer_mark_used_calls;
259 vec<tree, va_gc> *deferred_mark_used_calls;
261 /* States indicating how grokdeclarator() should handle declspecs marked
262 with __attribute__((deprecated)). An object declared as
263 __attribute__((deprecated)) suppresses warnings of uses of other
264 deprecated items. */
265 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
268 /* A list of VAR_DECLs whose type was incomplete at the time the
269 variable was declared. */
271 typedef struct GTY(()) incomplete_var_d {
272 tree decl;
273 tree incomplete_type;
274 } incomplete_var;
277 static GTY(()) vec<incomplete_var, va_gc> *incomplete_vars;
279 /* Returns the kind of template specialization we are currently
280 processing, given that it's declaration contained N_CLASS_SCOPES
281 explicit scope qualifications. */
283 tmpl_spec_kind
284 current_tmpl_spec_kind (int n_class_scopes)
286 int n_template_parm_scopes = 0;
287 int seen_specialization_p = 0;
288 int innermost_specialization_p = 0;
289 cp_binding_level *b;
291 /* Scan through the template parameter scopes. */
292 for (b = current_binding_level;
293 b->kind == sk_template_parms;
294 b = b->level_chain)
296 /* If we see a specialization scope inside a parameter scope,
297 then something is wrong. That corresponds to a declaration
298 like:
300 template <class T> template <> ...
302 which is always invalid since [temp.expl.spec] forbids the
303 specialization of a class member template if the enclosing
304 class templates are not explicitly specialized as well. */
305 if (b->explicit_spec_p)
307 if (n_template_parm_scopes == 0)
308 innermost_specialization_p = 1;
309 else
310 seen_specialization_p = 1;
312 else if (seen_specialization_p == 1)
313 return tsk_invalid_member_spec;
315 ++n_template_parm_scopes;
318 /* Handle explicit instantiations. */
319 if (processing_explicit_instantiation)
321 if (n_template_parm_scopes != 0)
322 /* We've seen a template parameter list during an explicit
323 instantiation. For example:
325 template <class T> template void f(int);
327 This is erroneous. */
328 return tsk_invalid_expl_inst;
329 else
330 return tsk_expl_inst;
333 if (n_template_parm_scopes < n_class_scopes)
334 /* We've not seen enough template headers to match all the
335 specialized classes present. For example:
337 template <class T> void R<T>::S<T>::f(int);
339 This is invalid; there needs to be one set of template
340 parameters for each class. */
341 return tsk_insufficient_parms;
342 else if (n_template_parm_scopes == n_class_scopes)
343 /* We're processing a non-template declaration (even though it may
344 be a member of a template class.) For example:
346 template <class T> void S<T>::f(int);
348 The `class T' matches the `S<T>', leaving no template headers
349 corresponding to the `f'. */
350 return tsk_none;
351 else if (n_template_parm_scopes > n_class_scopes + 1)
352 /* We've got too many template headers. For example:
354 template <> template <class T> void f (T);
356 There need to be more enclosing classes. */
357 return tsk_excessive_parms;
358 else
359 /* This must be a template. It's of the form:
361 template <class T> template <class U> void S<T>::f(U);
363 This is a specialization if the innermost level was a
364 specialization; otherwise it's just a definition of the
365 template. */
366 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
369 /* Exit the current scope. */
371 void
372 finish_scope (void)
374 poplevel (0, 0, 0);
377 /* When a label goes out of scope, check to see if that label was used
378 in a valid manner, and issue any appropriate warnings or errors. */
380 static void
381 pop_label (tree label, tree old_value)
383 if (!processing_template_decl)
385 if (DECL_INITIAL (label) == NULL_TREE)
387 location_t location;
389 error ("label %q+D used but not defined", label);
390 location = input_location;
391 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
392 /* Avoid crashing later. */
393 define_label (location, DECL_NAME (label));
395 else
396 warn_for_unused_label (label);
399 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
402 /* At the end of a function, all labels declared within the function
403 go out of scope. BLOCK is the top-level block for the
404 function. */
407 pop_labels_1 (named_label_entry **slot, tree block)
409 struct named_label_entry *ent = *slot;
411 pop_label (ent->label_decl, NULL_TREE);
413 /* Put the labels into the "variables" of the top-level block,
414 so debugger can see them. */
415 DECL_CHAIN (ent->label_decl) = BLOCK_VARS (block);
416 BLOCK_VARS (block) = ent->label_decl;
418 named_labels->clear_slot (slot);
420 return 1;
423 static void
424 pop_labels (tree block)
426 if (named_labels)
428 named_labels->traverse<tree, pop_labels_1> (block);
429 named_labels = NULL;
433 /* At the end of a block with local labels, restore the outer definition. */
435 static void
436 pop_local_label (tree label, tree old_value)
438 struct named_label_entry dummy;
440 pop_label (label, old_value);
442 dummy.label_decl = label;
443 named_label_entry **slot = named_labels->find_slot (&dummy, NO_INSERT);
444 named_labels->clear_slot (slot);
447 /* The following two routines are used to interface to Objective-C++.
448 The binding level is purposely treated as an opaque type. */
450 void *
451 objc_get_current_scope (void)
453 return current_binding_level;
456 /* The following routine is used by the NeXT-style SJLJ exceptions;
457 variables get marked 'volatile' so as to not be clobbered by
458 _setjmp()/_longjmp() calls. All variables in the current scope,
459 as well as parent scopes up to (but not including) ENCLOSING_BLK
460 shall be thusly marked. */
462 void
463 objc_mark_locals_volatile (void *enclosing_blk)
465 cp_binding_level *scope;
467 for (scope = current_binding_level;
468 scope && scope != enclosing_blk;
469 scope = scope->level_chain)
471 tree decl;
473 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
474 objc_volatilize_decl (decl);
476 /* Do not climb up past the current function. */
477 if (scope->kind == sk_function_parms)
478 break;
482 /* Update data for defined and undefined labels when leaving a scope. */
485 poplevel_named_label_1 (named_label_entry **slot, cp_binding_level *bl)
487 named_label_entry *ent = *slot;
488 cp_binding_level *obl = bl->level_chain;
490 if (ent->binding_level == bl)
492 tree decl;
494 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
495 TREE_LISTs representing OVERLOADs, so be careful. */
496 for (decl = ent->names_in_scope; decl; decl = (DECL_P (decl)
497 ? DECL_CHAIN (decl)
498 : TREE_CHAIN (decl)))
499 if (decl_jump_unsafe (decl))
500 vec_safe_push (ent->bad_decls, decl);
502 ent->binding_level = obl;
503 ent->names_in_scope = obl->names;
504 switch (bl->kind)
506 case sk_try:
507 ent->in_try_scope = true;
508 break;
509 case sk_catch:
510 ent->in_catch_scope = true;
511 break;
512 case sk_omp:
513 ent->in_omp_scope = true;
514 break;
515 default:
516 break;
519 else if (ent->uses)
521 struct named_label_use_entry *use;
523 for (use = ent->uses; use ; use = use->next)
524 if (use->binding_level == bl)
526 use->binding_level = obl;
527 use->names_in_scope = obl->names;
528 if (bl->kind == sk_omp)
529 use->in_omp_scope = true;
533 return 1;
536 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
537 when errors were reported, except for -Werror-unused-but-set-*. */
538 static int unused_but_set_errorcount;
540 /* Exit a binding level.
541 Pop the level off, and restore the state of the identifier-decl mappings
542 that were in effect when this level was entered.
544 If KEEP == 1, this level had explicit declarations, so
545 and create a "block" (a BLOCK node) for the level
546 to record its declarations and subblocks for symbol table output.
548 If FUNCTIONBODY is nonzero, this level is the body of a function,
549 so create a block as if KEEP were set and also clear out all
550 label names.
552 If REVERSE is nonzero, reverse the order of decls before putting
553 them into the BLOCK. */
555 tree
556 poplevel (int keep, int reverse, int functionbody)
558 tree link;
559 /* The chain of decls was accumulated in reverse order.
560 Put it into forward order, just for cleanliness. */
561 tree decls;
562 tree subblocks;
563 tree block;
564 tree decl;
565 int leaving_for_scope;
566 scope_kind kind;
567 unsigned ix;
568 cp_label_binding *label_bind;
570 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
571 restart:
573 block = NULL_TREE;
575 gcc_assert (current_binding_level->kind != sk_class);
577 if (current_binding_level->kind == sk_cleanup)
578 functionbody = 0;
579 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
581 gcc_assert (!vec_safe_length (current_binding_level->class_shadowed));
583 /* We used to use KEEP == 2 to indicate that the new block should go
584 at the beginning of the list of blocks at this binding level,
585 rather than the end. This hack is no longer used. */
586 gcc_assert (keep == 0 || keep == 1);
588 if (current_binding_level->keep)
589 keep = 1;
591 /* Any uses of undefined labels, and any defined labels, now operate
592 under constraints of next binding contour. */
593 if (cfun && !functionbody && named_labels)
594 named_labels->traverse<cp_binding_level *, poplevel_named_label_1>
595 (current_binding_level);
597 /* Get the decls in the order they were written.
598 Usually current_binding_level->names is in reverse order.
599 But parameter decls were previously put in forward order. */
601 if (reverse)
602 current_binding_level->names
603 = decls = nreverse (current_binding_level->names);
604 else
605 decls = current_binding_level->names;
607 /* If there were any declarations or structure tags in that level,
608 or if this level is a function body,
609 create a BLOCK to record them for the life of this function. */
610 block = NULL_TREE;
611 if (keep == 1 || functionbody)
612 block = make_node (BLOCK);
613 if (block != NULL_TREE)
615 BLOCK_VARS (block) = decls;
616 BLOCK_SUBBLOCKS (block) = subblocks;
619 /* In each subblock, record that this is its superior. */
620 if (keep >= 0)
621 for (link = subblocks; link; link = BLOCK_CHAIN (link))
622 BLOCK_SUPERCONTEXT (link) = block;
624 /* We still support the old for-scope rules, whereby the variables
625 in a for-init statement were in scope after the for-statement
626 ended. We only use the new rules if flag_new_for_scope is
627 nonzero. */
628 leaving_for_scope
629 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
631 /* Before we remove the declarations first check for unused variables. */
632 if ((warn_unused_variable || warn_unused_but_set_variable)
633 && current_binding_level->kind != sk_template_parms
634 && !processing_template_decl)
635 for (tree d = getdecls (); d; d = TREE_CHAIN (d))
637 /* There are cases where D itself is a TREE_LIST. See in
638 push_local_binding where the list of decls returned by
639 getdecls is built. */
640 decl = TREE_CODE (d) == TREE_LIST ? TREE_VALUE (d) : d;
641 tree type = TREE_TYPE (decl);
642 if (VAR_P (decl)
643 && (! TREE_USED (decl) || !DECL_READ_P (decl))
644 && ! DECL_IN_SYSTEM_HEADER (decl)
645 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)
646 && type != error_mark_node
647 && (!CLASS_TYPE_P (type)
648 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
649 || lookup_attribute ("warn_unused",
650 TYPE_ATTRIBUTES (TREE_TYPE (decl)))))
652 if (! TREE_USED (decl))
653 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
654 else if (DECL_CONTEXT (decl) == current_function_decl
655 // For -Wunused-but-set-variable leave references alone.
656 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
657 && errorcount == unused_but_set_errorcount)
659 warning (OPT_Wunused_but_set_variable,
660 "variable %q+D set but not used", decl);
661 unused_but_set_errorcount = errorcount;
666 /* Remove declarations for all the DECLs in this level. */
667 for (link = decls; link; link = TREE_CHAIN (link))
669 if (leaving_for_scope && VAR_P (link)
670 /* It's hard to make this ARM compatibility hack play nicely with
671 lambdas, and it really isn't necessary in C++11 mode. */
672 && cxx_dialect < cxx11
673 && DECL_NAME (link))
675 tree name = DECL_NAME (link);
676 cxx_binding *ob;
677 tree ns_binding;
679 ob = outer_binding (name,
680 IDENTIFIER_BINDING (name),
681 /*class_p=*/true);
682 if (!ob)
683 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
684 else
685 ns_binding = NULL_TREE;
687 if (ob && ob->scope == current_binding_level->level_chain)
688 /* We have something like:
690 int i;
691 for (int i; ;);
693 and we are leaving the `for' scope. There's no reason to
694 keep the binding of the inner `i' in this case. */
695 pop_binding (name, link);
696 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
697 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
698 /* Here, we have something like:
700 typedef int I;
702 void f () {
703 for (int I; ;);
706 We must pop the for-scope binding so we know what's a
707 type and what isn't. */
708 pop_binding (name, link);
709 else
711 /* Mark this VAR_DECL as dead so that we can tell we left it
712 there only for backward compatibility. */
713 DECL_DEAD_FOR_LOCAL (link) = 1;
715 /* Keep track of what should have happened when we
716 popped the binding. */
717 if (ob && ob->value)
719 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
720 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
723 /* Add it to the list of dead variables in the next
724 outermost binding to that we can remove these when we
725 leave that binding. */
726 vec_safe_push (
727 current_binding_level->level_chain->dead_vars_from_for,
728 link);
730 /* Although we don't pop the cxx_binding, we do clear
731 its SCOPE since the scope is going away now. */
732 IDENTIFIER_BINDING (name)->scope
733 = current_binding_level->level_chain;
736 else
738 tree name;
740 /* Remove the binding. */
741 decl = link;
743 if (TREE_CODE (decl) == TREE_LIST)
744 decl = TREE_VALUE (decl);
745 name = decl;
747 if (TREE_CODE (name) == OVERLOAD)
748 name = OVL_FUNCTION (name);
750 gcc_assert (DECL_P (name));
751 pop_binding (DECL_NAME (name), decl);
755 /* Remove declarations for any `for' variables from inner scopes
756 that we kept around. */
757 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->dead_vars_from_for,
758 ix, decl)
759 pop_binding (DECL_NAME (decl), decl);
761 /* Restore the IDENTIFIER_TYPE_VALUEs. */
762 for (link = current_binding_level->type_shadowed;
763 link; link = TREE_CHAIN (link))
764 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
766 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
767 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level->shadowed_labels,
768 ix, label_bind)
769 pop_local_label (label_bind->label, label_bind->prev_value);
771 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
772 list if a `using' declaration put them there. The debugging
773 back ends won't understand OVERLOAD, so we remove them here.
774 Because the BLOCK_VARS are (temporarily) shared with
775 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
776 popped all the bindings. */
777 if (block)
779 tree* d;
781 for (d = &BLOCK_VARS (block); *d; )
783 if (TREE_CODE (*d) == TREE_LIST)
784 *d = TREE_CHAIN (*d);
785 else
786 d = &DECL_CHAIN (*d);
790 /* If the level being exited is the top level of a function,
791 check over all the labels. */
792 if (functionbody)
794 /* Since this is the top level block of a function, the vars are
795 the function's parameters. Don't leave them in the BLOCK
796 because they are found in the FUNCTION_DECL instead. */
797 BLOCK_VARS (block) = 0;
798 pop_labels (block);
801 kind = current_binding_level->kind;
802 if (kind == sk_cleanup)
804 tree stmt;
806 /* If this is a temporary binding created for a cleanup, then we'll
807 have pushed a statement list level. Pop that, create a new
808 BIND_EXPR for the block, and insert it into the stream. */
809 stmt = pop_stmt_list (current_binding_level->statement_list);
810 stmt = c_build_bind_expr (input_location, block, stmt);
811 add_stmt (stmt);
814 leave_scope ();
815 if (functionbody)
817 /* The current function is being defined, so its DECL_INITIAL
818 should be error_mark_node. */
819 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
820 DECL_INITIAL (current_function_decl) = block;
822 else if (block)
823 current_binding_level->blocks
824 = block_chainon (current_binding_level->blocks, block);
826 /* If we did not make a block for the level just exited,
827 any blocks made for inner levels
828 (since they cannot be recorded as subblocks in that level)
829 must be carried forward so they will later become subblocks
830 of something else. */
831 else if (subblocks)
832 current_binding_level->blocks
833 = block_chainon (current_binding_level->blocks, subblocks);
835 /* Each and every BLOCK node created here in `poplevel' is important
836 (e.g. for proper debugging information) so if we created one
837 earlier, mark it as "used". */
838 if (block)
839 TREE_USED (block) = 1;
841 /* All temporary bindings created for cleanups are popped silently. */
842 if (kind == sk_cleanup)
843 goto restart;
845 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
846 return block;
849 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
850 itself, calling F for each. The DATA is passed to F as well. */
852 static int
853 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
855 int result = 0;
856 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
858 result |= (*f) (name_space, data);
860 for (; current; current = DECL_CHAIN (current))
861 result |= walk_namespaces_r (current, f, data);
863 return result;
866 /* Walk all the namespaces, calling F for each. The DATA is passed to
867 F as well. */
870 walk_namespaces (walk_namespaces_fn f, void* data)
872 return walk_namespaces_r (global_namespace, f, data);
875 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
876 DATA is non-NULL, this is the last time we will call
877 wrapup_global_declarations for this NAMESPACE. */
880 wrapup_globals_for_namespace (tree name_space, void* data)
882 cp_binding_level *level = NAMESPACE_LEVEL (name_space);
883 vec<tree, va_gc> *statics = level->static_decls;
884 tree *vec = statics->address ();
885 int len = statics->length ();
886 int last_time = (data != 0);
888 if (last_time)
890 check_global_declarations (vec, len);
891 emit_debug_global_declarations (vec, len);
892 return 0;
895 /* Write out any globals that need to be output. */
896 return wrapup_global_declarations (vec, len);
900 /* In C++, you don't have to write `struct S' to refer to `S'; you
901 can just use `S'. We accomplish this by creating a TYPE_DECL as
902 if the user had written `typedef struct S S'. Create and return
903 the TYPE_DECL for TYPE. */
905 tree
906 create_implicit_typedef (tree name, tree type)
908 tree decl;
910 decl = build_decl (input_location, TYPE_DECL, name, type);
911 DECL_ARTIFICIAL (decl) = 1;
912 /* There are other implicit type declarations, like the one *within*
913 a class that allows you to write `S::S'. We must distinguish
914 amongst these. */
915 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
916 TYPE_NAME (type) = decl;
917 TYPE_STUB_DECL (type) = decl;
919 return decl;
922 /* Remember a local name for name-mangling purposes. */
924 static void
925 push_local_name (tree decl)
927 size_t i, nelts;
928 tree t, name;
930 timevar_start (TV_NAME_LOOKUP);
932 name = DECL_NAME (decl);
934 nelts = vec_safe_length (local_names);
935 for (i = 0; i < nelts; i++)
937 t = (*local_names)[i];
938 if (DECL_NAME (t) == name)
940 if (!DECL_LANG_SPECIFIC (decl))
941 retrofit_lang_decl (decl);
942 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
943 if (DECL_DISCRIMINATOR_SET_P (t))
944 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
945 else
946 DECL_DISCRIMINATOR (decl) = 1;
948 (*local_names)[i] = decl;
949 timevar_stop (TV_NAME_LOOKUP);
950 return;
954 vec_safe_push (local_names, decl);
955 timevar_stop (TV_NAME_LOOKUP);
958 /* Subroutine of duplicate_decls: return truthvalue of whether
959 or not types of these decls match.
961 For C++, we must compare the parameter list so that `int' can match
962 `int&' in a parameter position, but `int&' is not confused with
963 `const int&'. */
966 decls_match (tree newdecl, tree olddecl)
968 int types_match;
970 if (newdecl == olddecl)
971 return 1;
973 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
974 /* If the two DECLs are not even the same kind of thing, we're not
975 interested in their types. */
976 return 0;
978 gcc_assert (DECL_P (newdecl));
980 if (TREE_CODE (newdecl) == FUNCTION_DECL)
982 tree f1 = TREE_TYPE (newdecl);
983 tree f2 = TREE_TYPE (olddecl);
984 tree p1 = TYPE_ARG_TYPES (f1);
985 tree p2 = TYPE_ARG_TYPES (f2);
986 tree r2;
988 /* Specializations of different templates are different functions
989 even if they have the same type. */
990 tree t1 = (DECL_USE_TEMPLATE (newdecl)
991 ? DECL_TI_TEMPLATE (newdecl)
992 : NULL_TREE);
993 tree t2 = (DECL_USE_TEMPLATE (olddecl)
994 ? DECL_TI_TEMPLATE (olddecl)
995 : NULL_TREE);
996 if (t1 != t2)
997 return 0;
999 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1000 && ! (DECL_EXTERN_C_P (newdecl)
1001 && DECL_EXTERN_C_P (olddecl)))
1002 return 0;
1004 /* A new declaration doesn't match a built-in one unless it
1005 is also extern "C". */
1006 if (DECL_IS_BUILTIN (olddecl)
1007 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
1008 return 0;
1010 if (TREE_CODE (f1) != TREE_CODE (f2))
1011 return 0;
1013 /* A declaration with deduced return type should use its pre-deduction
1014 type for declaration matching. */
1015 r2 = fndecl_declared_return_type (olddecl);
1017 if (same_type_p (TREE_TYPE (f1), r2))
1019 if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
1020 && (DECL_BUILT_IN (olddecl)
1021 #ifndef NO_IMPLICIT_EXTERN_C
1022 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
1023 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
1024 #endif
1027 types_match = self_promoting_args_p (p1);
1028 if (p1 == void_list_node)
1029 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1031 #ifndef NO_IMPLICIT_EXTERN_C
1032 else if (!prototype_p (f1)
1033 && (DECL_EXTERN_C_P (olddecl)
1034 && DECL_IN_SYSTEM_HEADER (olddecl)
1035 && !DECL_CLASS_SCOPE_P (olddecl))
1036 && (DECL_EXTERN_C_P (newdecl)
1037 && DECL_IN_SYSTEM_HEADER (newdecl)
1038 && !DECL_CLASS_SCOPE_P (newdecl)))
1040 types_match = self_promoting_args_p (p2);
1041 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1043 #endif
1044 else
1045 types_match =
1046 compparms (p1, p2)
1047 && type_memfn_rqual (f1) == type_memfn_rqual (f2)
1048 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
1049 || comp_type_attributes (TREE_TYPE (newdecl),
1050 TREE_TYPE (olddecl)) != 0);
1052 else
1053 types_match = 0;
1055 /* The decls dont match if they correspond to two different versions
1056 of the same function. Disallow extern "C" functions to be
1057 versions for now. */
1058 if (types_match
1059 && !DECL_EXTERN_C_P (newdecl)
1060 && !DECL_EXTERN_C_P (olddecl)
1061 && targetm.target_option.function_versions (newdecl, olddecl))
1063 /* Mark functions as versions if necessary. Modify the mangled decl
1064 name if necessary. */
1065 if (DECL_FUNCTION_VERSIONED (newdecl)
1066 && DECL_FUNCTION_VERSIONED (olddecl))
1067 return 0;
1068 if (!DECL_FUNCTION_VERSIONED (newdecl))
1070 DECL_FUNCTION_VERSIONED (newdecl) = 1;
1071 if (DECL_ASSEMBLER_NAME_SET_P (newdecl))
1072 mangle_decl (newdecl);
1074 if (!DECL_FUNCTION_VERSIONED (olddecl))
1076 DECL_FUNCTION_VERSIONED (olddecl) = 1;
1077 if (DECL_ASSEMBLER_NAME_SET_P (olddecl))
1078 mangle_decl (olddecl);
1080 cgraph_node::record_function_versions (olddecl, newdecl);
1081 return 0;
1084 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1086 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1087 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1088 return 0;
1090 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1091 DECL_TEMPLATE_PARMS (olddecl)))
1092 return 0;
1094 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1095 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1096 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1097 else
1098 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1099 DECL_TEMPLATE_RESULT (newdecl));
1101 else
1103 /* Need to check scope for variable declaration (VAR_DECL).
1104 For typedef (TYPE_DECL), scope is ignored. */
1105 if (VAR_P (newdecl)
1106 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1107 /* [dcl.link]
1108 Two declarations for an object with C language linkage
1109 with the same name (ignoring the namespace that qualify
1110 it) that appear in different namespace scopes refer to
1111 the same object. */
1112 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1113 return 0;
1115 if (TREE_TYPE (newdecl) == error_mark_node)
1116 types_match = TREE_TYPE (olddecl) == error_mark_node;
1117 else if (TREE_TYPE (olddecl) == NULL_TREE)
1118 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1119 else if (TREE_TYPE (newdecl) == NULL_TREE)
1120 types_match = 0;
1121 else
1122 types_match = comptypes (TREE_TYPE (newdecl),
1123 TREE_TYPE (olddecl),
1124 COMPARE_REDECLARATION);
1127 return types_match;
1130 /* If NEWDECL is `static' and an `extern' was seen previously,
1131 warn about it. OLDDECL is the previous declaration.
1133 Note that this does not apply to the C++ case of declaring
1134 a variable `extern const' and then later `const'.
1136 Don't complain about built-in functions, since they are beyond
1137 the user's control. */
1139 void
1140 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1142 if (TREE_CODE (newdecl) == TYPE_DECL
1143 || TREE_CODE (newdecl) == TEMPLATE_DECL
1144 || TREE_CODE (newdecl) == CONST_DECL
1145 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1146 return;
1148 /* Don't get confused by static member functions; that's a different
1149 use of `static'. */
1150 if (TREE_CODE (newdecl) == FUNCTION_DECL
1151 && DECL_STATIC_FUNCTION_P (newdecl))
1152 return;
1154 /* If the old declaration was `static', or the new one isn't, then
1155 everything is OK. */
1156 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1157 return;
1159 /* It's OK to declare a builtin function as `static'. */
1160 if (TREE_CODE (olddecl) == FUNCTION_DECL
1161 && DECL_ARTIFICIAL (olddecl))
1162 return;
1164 if (permerror (input_location,
1165 "%qD was declared %<extern%> and later %<static%>", newdecl))
1166 inform (input_location, "previous declaration of %q+D", olddecl);
1169 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1170 function templates. If their exception specifications do not
1171 match, issue a diagnostic. */
1173 static void
1174 check_redeclaration_exception_specification (tree new_decl,
1175 tree old_decl)
1177 tree new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl));
1178 tree old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl));
1180 /* Two default specs are equivalent, don't force evaluation. */
1181 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions)
1182 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions))
1183 return;
1185 maybe_instantiate_noexcept (new_decl);
1186 maybe_instantiate_noexcept (old_decl);
1187 new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl));
1188 old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl));
1190 /* [except.spec]
1192 If any declaration of a function has an exception-specification,
1193 all declarations, including the definition and an explicit
1194 specialization, of that function shall have an
1195 exception-specification with the same set of type-ids. */
1196 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1197 && ! DECL_IS_BUILTIN (old_decl)
1198 && flag_exceptions
1199 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal))
1201 error ("declaration of %qF has a different exception specifier",
1202 new_decl);
1203 error ("from previous declaration %q+F", old_decl);
1207 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1208 Otherwise issue diagnostics. */
1210 static bool
1211 validate_constexpr_redeclaration (tree old_decl, tree new_decl)
1213 old_decl = STRIP_TEMPLATE (old_decl);
1214 new_decl = STRIP_TEMPLATE (new_decl);
1215 if (!VAR_OR_FUNCTION_DECL_P (old_decl)
1216 || !VAR_OR_FUNCTION_DECL_P (new_decl))
1217 return true;
1218 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
1219 == DECL_DECLARED_CONSTEXPR_P (new_decl))
1220 return true;
1221 if (TREE_CODE (old_decl) == FUNCTION_DECL)
1223 if (DECL_BUILT_IN (old_decl))
1225 /* Hide a built-in declaration. */
1226 DECL_DECLARED_CONSTEXPR_P (old_decl)
1227 = DECL_DECLARED_CONSTEXPR_P (new_decl);
1228 return true;
1230 /* 7.1.5 [dcl.constexpr]
1231 Note: An explicit specialization can differ from the template
1232 declaration with respect to the constexpr specifier. */
1233 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl)
1234 && DECL_TEMPLATE_SPECIALIZATION (new_decl))
1235 return true;
1237 error ("redeclaration %qD differs in %<constexpr%>", new_decl);
1238 error ("from previous declaration %q+D", old_decl);
1239 return false;
1241 return true;
1244 /* DECL is a redeclaration of a function or function template. If
1245 it does have default arguments issue a diagnostic. Note: this
1246 function is used to enforce the requirements in C++11 8.3.6 about
1247 no default arguments in redeclarations. */
1249 static void
1250 check_redeclaration_no_default_args (tree decl)
1252 gcc_assert (DECL_DECLARES_FUNCTION_P (decl));
1254 for (tree t = FUNCTION_FIRST_USER_PARMTYPE (decl);
1255 t && t != void_list_node; t = TREE_CHAIN (t))
1256 if (TREE_PURPOSE (t))
1258 permerror (input_location,
1259 "redeclaration of %q#D may not have default "
1260 "arguments", decl);
1261 return;
1265 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1266 && lookup_attribute ("gnu_inline", \
1267 DECL_ATTRIBUTES (fn)))
1269 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1270 If the redeclaration is invalid, a diagnostic is issued, and the
1271 error_mark_node is returned. Otherwise, OLDDECL is returned.
1273 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1274 returned.
1276 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1278 tree
1279 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1281 unsigned olddecl_uid = DECL_UID (olddecl);
1282 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1283 int new_defines_function = 0;
1284 tree new_template_info;
1286 if (newdecl == olddecl)
1287 return olddecl;
1289 types_match = decls_match (newdecl, olddecl);
1291 /* If either the type of the new decl or the type of the old decl is an
1292 error_mark_node, then that implies that we have already issued an
1293 error (earlier) for some bogus type specification, and in that case,
1294 it is rather pointless to harass the user with yet more error message
1295 about the same declaration, so just pretend the types match here. */
1296 if (TREE_TYPE (newdecl) == error_mark_node
1297 || TREE_TYPE (olddecl) == error_mark_node)
1298 return error_mark_node;
1300 if (UDLIT_OPER_P (DECL_NAME (newdecl))
1301 && UDLIT_OPER_P (DECL_NAME (olddecl)))
1303 if (TREE_CODE (newdecl) == TEMPLATE_DECL
1304 && TREE_CODE (olddecl) != TEMPLATE_DECL
1305 && check_raw_literal_operator (olddecl))
1306 error ("literal operator template %q+D conflicts with"
1307 " raw literal operator %qD", newdecl, olddecl);
1308 else if (TREE_CODE (newdecl) != TEMPLATE_DECL
1309 && TREE_CODE (olddecl) == TEMPLATE_DECL
1310 && check_raw_literal_operator (newdecl))
1311 error ("raw literal operator %q+D conflicts with"
1312 " literal operator template %qD", newdecl, olddecl);
1315 if (DECL_P (olddecl)
1316 && TREE_CODE (newdecl) == FUNCTION_DECL
1317 && TREE_CODE (olddecl) == FUNCTION_DECL
1318 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1320 if (DECL_DECLARED_INLINE_P (newdecl)
1321 && DECL_UNINLINABLE (newdecl)
1322 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1323 /* Already warned elsewhere. */;
1324 else if (DECL_DECLARED_INLINE_P (olddecl)
1325 && DECL_UNINLINABLE (olddecl)
1326 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1327 /* Already warned. */;
1328 else if (DECL_DECLARED_INLINE_P (newdecl)
1329 && DECL_UNINLINABLE (olddecl)
1330 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1332 if (warning (OPT_Wattributes, "function %q+D redeclared as inline",
1333 newdecl))
1334 inform (DECL_SOURCE_LOCATION (olddecl),
1335 "previous declaration of %qD with attribute noinline",
1336 olddecl);
1338 else if (DECL_DECLARED_INLINE_P (olddecl)
1339 && DECL_UNINLINABLE (newdecl)
1340 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1342 if (warning (OPT_Wattributes, "function %q+D redeclared with "
1343 "attribute noinline", newdecl))
1344 inform (DECL_SOURCE_LOCATION (olddecl),
1345 "previous declaration of %qD was inline",
1346 olddecl);
1350 /* Check for redeclaration and other discrepancies. */
1351 if (TREE_CODE (olddecl) == FUNCTION_DECL
1352 && DECL_ARTIFICIAL (olddecl))
1354 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1355 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1357 /* Avoid warnings redeclaring built-ins which have not been
1358 explicitly declared. */
1359 if (DECL_ANTICIPATED (olddecl))
1360 return NULL_TREE;
1362 /* If you declare a built-in or predefined function name as static,
1363 the old definition is overridden, but optionally warn this was a
1364 bad choice of name. */
1365 if (! TREE_PUBLIC (newdecl))
1367 warning (OPT_Wshadow,
1368 DECL_BUILT_IN (olddecl)
1369 ? G_("shadowing built-in function %q#D")
1370 : G_("shadowing library function %q#D"), olddecl);
1371 /* Discard the old built-in function. */
1372 return NULL_TREE;
1374 /* If the built-in is not ansi, then programs can override
1375 it even globally without an error. */
1376 else if (! DECL_BUILT_IN (olddecl))
1377 warning (0, "library function %q#D redeclared as non-function %q#D",
1378 olddecl, newdecl);
1379 else
1380 error ("declaration of %q#D conflicts with built-in "
1381 "declaration %q#D", newdecl, olddecl);
1382 return NULL_TREE;
1384 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl))
1386 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl));
1387 error_at (DECL_SOURCE_LOCATION (newdecl),
1388 "redeclaration of %<pragma omp declare reduction%>");
1389 inform (DECL_SOURCE_LOCATION (olddecl),
1390 "previous %<pragma omp declare reduction%> declaration");
1391 return error_mark_node;
1393 else if (!types_match)
1395 /* Avoid warnings redeclaring built-ins which have not been
1396 explicitly declared. */
1397 if (DECL_ANTICIPATED (olddecl))
1399 /* Deal with fileptr_type_node. FILE type is not known
1400 at the time we create the builtins. */
1401 tree t1, t2;
1403 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1404 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1405 t1 || t2;
1406 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1407 if (!t1 || !t2)
1408 break;
1409 else if (TREE_VALUE (t2) == fileptr_type_node)
1411 tree t = TREE_VALUE (t1);
1413 if (TYPE_PTR_P (t)
1414 && TYPE_IDENTIFIER (TREE_TYPE (t))
1415 == get_identifier ("FILE")
1416 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1418 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1420 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1421 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1422 types_match = decls_match (newdecl, olddecl);
1423 if (types_match)
1424 return duplicate_decls (newdecl, olddecl,
1425 newdecl_is_friend);
1426 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1429 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1430 break;
1432 else if ((DECL_EXTERN_C_P (newdecl)
1433 && DECL_EXTERN_C_P (olddecl))
1434 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1435 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1437 /* A near match; override the builtin. */
1439 if (TREE_PUBLIC (newdecl))
1440 warning (0, "new declaration %q#D ambiguates built-in "
1441 "declaration %q#D", newdecl, olddecl);
1442 else
1443 warning (OPT_Wshadow,
1444 DECL_BUILT_IN (olddecl)
1445 ? G_("shadowing built-in function %q#D")
1446 : G_("shadowing library function %q#D"), olddecl);
1448 else
1449 /* Discard the old built-in function. */
1450 return NULL_TREE;
1452 /* Replace the old RTL to avoid problems with inlining. */
1453 COPY_DECL_RTL (newdecl, olddecl);
1455 /* Even if the types match, prefer the new declarations type for
1456 built-ins which have not been explicitly declared, for
1457 exception lists, etc... */
1458 else if (DECL_IS_BUILTIN (olddecl))
1460 tree type = TREE_TYPE (newdecl);
1461 tree attribs = (*targetm.merge_type_attributes)
1462 (TREE_TYPE (olddecl), type);
1464 type = cp_build_type_attribute_variant (type, attribs);
1465 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1468 /* If a function is explicitly declared "throw ()", propagate that to
1469 the corresponding builtin. */
1470 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1471 && DECL_ANTICIPATED (olddecl)
1472 && TREE_NOTHROW (newdecl)
1473 && !TREE_NOTHROW (olddecl))
1475 enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl);
1476 tree tmpdecl = builtin_decl_explicit (fncode);
1477 if (tmpdecl && tmpdecl != olddecl && types_match)
1478 TREE_NOTHROW (tmpdecl) = 1;
1481 /* Whether or not the builtin can throw exceptions has no
1482 bearing on this declarator. */
1483 TREE_NOTHROW (olddecl) = 0;
1485 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1487 /* If a builtin function is redeclared as `static', merge
1488 the declarations, but make the original one static. */
1489 DECL_THIS_STATIC (olddecl) = 1;
1490 TREE_PUBLIC (olddecl) = 0;
1492 /* Make the old declaration consistent with the new one so
1493 that all remnants of the builtin-ness of this function
1494 will be banished. */
1495 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1496 COPY_DECL_RTL (newdecl, olddecl);
1499 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1501 /* C++ Standard, 3.3, clause 4:
1502 "[Note: a namespace name or a class template name must be unique
1503 in its declarative region (7.3.2, clause 14). ]" */
1504 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1505 && TREE_CODE (newdecl) != NAMESPACE_DECL
1506 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1507 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1508 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1509 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1511 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1512 && TREE_CODE (newdecl) != TYPE_DECL)
1513 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1514 && TREE_CODE (olddecl) != TYPE_DECL))
1516 /* We do nothing special here, because C++ does such nasty
1517 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1518 get shadowed, and know that if we need to find a TYPE_DECL
1519 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1520 slot of the identifier. */
1521 return NULL_TREE;
1524 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1525 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1526 || (TREE_CODE (olddecl) == FUNCTION_DECL
1527 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1528 return NULL_TREE;
1531 error ("%q#D redeclared as different kind of symbol", newdecl);
1532 if (TREE_CODE (olddecl) == TREE_LIST)
1533 olddecl = TREE_VALUE (olddecl);
1534 inform (DECL_SOURCE_LOCATION (olddecl),
1535 "previous declaration %q#D", olddecl);
1537 return error_mark_node;
1539 else if (!types_match)
1541 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1542 /* These are certainly not duplicate declarations; they're
1543 from different scopes. */
1544 return NULL_TREE;
1546 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1548 /* The name of a class template may not be declared to refer to
1549 any other template, class, function, object, namespace, value,
1550 or type in the same scope. */
1551 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1552 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1554 error ("conflicting declaration of template %q#D", newdecl);
1555 inform (DECL_SOURCE_LOCATION (olddecl),
1556 "previous declaration %q#D", olddecl);
1557 return error_mark_node;
1559 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1560 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1561 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1562 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1563 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1564 DECL_TEMPLATE_PARMS (olddecl))
1565 /* Template functions can be disambiguated by
1566 return type. */
1567 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1568 TREE_TYPE (TREE_TYPE (olddecl))))
1570 error ("ambiguating new declaration %q#D", newdecl);
1571 inform (DECL_SOURCE_LOCATION (olddecl),
1572 "old declaration %q#D", olddecl);
1574 return NULL_TREE;
1576 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1578 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1580 error ("conflicting declaration of C function %q#D",
1581 newdecl);
1582 inform (DECL_SOURCE_LOCATION (olddecl),
1583 "previous declaration %q#D", olddecl);
1584 return NULL_TREE;
1586 /* For function versions, params and types match, but they
1587 are not ambiguous. */
1588 else if ((!DECL_FUNCTION_VERSIONED (newdecl)
1589 && !DECL_FUNCTION_VERSIONED (olddecl))
1590 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1591 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1593 error ("ambiguating new declaration of %q#D", newdecl);
1594 inform (DECL_SOURCE_LOCATION (olddecl),
1595 "old declaration %q#D", olddecl);
1596 return error_mark_node;
1598 else
1599 return NULL_TREE;
1601 else
1603 error ("conflicting declaration %q#D", newdecl);
1604 inform (DECL_SOURCE_LOCATION (olddecl),
1605 "previous declaration as %q#D", olddecl);
1606 return error_mark_node;
1609 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1610 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1611 && (!DECL_TEMPLATE_INFO (newdecl)
1612 || (DECL_TI_TEMPLATE (newdecl)
1613 != DECL_TI_TEMPLATE (olddecl))))
1614 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1615 && (!DECL_TEMPLATE_INFO (olddecl)
1616 || (DECL_TI_TEMPLATE (olddecl)
1617 != DECL_TI_TEMPLATE (newdecl))))))
1618 /* It's OK to have a template specialization and a non-template
1619 with the same type, or to have specializations of two
1620 different templates with the same type. Note that if one is a
1621 specialization, and the other is an instantiation of the same
1622 template, that we do not exit at this point. That situation
1623 can occur if we instantiate a template class, and then
1624 specialize one of its methods. This situation is valid, but
1625 the declarations must be merged in the usual way. */
1626 return NULL_TREE;
1627 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1628 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1629 && !DECL_USE_TEMPLATE (newdecl))
1630 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1631 && !DECL_USE_TEMPLATE (olddecl))))
1632 /* One of the declarations is a template instantiation, and the
1633 other is not a template at all. That's OK. */
1634 return NULL_TREE;
1635 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1637 /* In [namespace.alias] we have:
1639 In a declarative region, a namespace-alias-definition can be
1640 used to redefine a namespace-alias declared in that declarative
1641 region to refer only to the namespace to which it already
1642 refers.
1644 Therefore, if we encounter a second alias directive for the same
1645 alias, we can just ignore the second directive. */
1646 if (DECL_NAMESPACE_ALIAS (newdecl)
1647 && (DECL_NAMESPACE_ALIAS (newdecl)
1648 == DECL_NAMESPACE_ALIAS (olddecl)))
1649 return olddecl;
1650 /* [namespace.alias]
1652 A namespace-name or namespace-alias shall not be declared as
1653 the name of any other entity in the same declarative region.
1654 A namespace-name defined at global scope shall not be
1655 declared as the name of any other entity in any global scope
1656 of the program. */
1657 error ("conflicting declaration of namespace %qD", newdecl);
1658 inform (DECL_SOURCE_LOCATION (olddecl),
1659 "previous declaration of namespace %qD here", olddecl);
1660 return error_mark_node;
1662 else
1664 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1665 if (errmsg)
1667 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1668 if (DECL_NAME (olddecl) != NULL_TREE)
1669 inform (input_location,
1670 (DECL_INITIAL (olddecl) && namespace_bindings_p ())
1671 ? G_("%q+#D previously defined here")
1672 : G_("%q+#D previously declared here"), olddecl);
1673 return error_mark_node;
1675 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1676 && DECL_INITIAL (olddecl) != NULL_TREE
1677 && !prototype_p (TREE_TYPE (olddecl))
1678 && prototype_p (TREE_TYPE (newdecl)))
1680 /* Prototype decl follows defn w/o prototype. */
1681 if (warning_at (DECL_SOURCE_LOCATION (newdecl), 0,
1682 "prototype specified for %q#D", newdecl))
1683 inform (DECL_SOURCE_LOCATION (olddecl),
1684 "previous non-prototype definition here");
1686 else if (VAR_OR_FUNCTION_DECL_P (olddecl)
1687 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1689 /* [dcl.link]
1690 If two declarations of the same function or object
1691 specify different linkage-specifications ..., the program
1692 is ill-formed.... Except for functions with C++ linkage,
1693 a function declaration without a linkage specification
1694 shall not precede the first linkage specification for
1695 that function. A function can be declared without a
1696 linkage specification after an explicit linkage
1697 specification has been seen; the linkage explicitly
1698 specified in the earlier declaration is not affected by
1699 such a function declaration.
1701 DR 563 raises the question why the restrictions on
1702 functions should not also apply to objects. Older
1703 versions of G++ silently ignore the linkage-specification
1704 for this example:
1706 namespace N {
1707 extern int i;
1708 extern "C" int i;
1711 which is clearly wrong. Therefore, we now treat objects
1712 like functions. */
1713 if (current_lang_depth () == 0)
1715 /* There is no explicit linkage-specification, so we use
1716 the linkage from the previous declaration. */
1717 if (!DECL_LANG_SPECIFIC (newdecl))
1718 retrofit_lang_decl (newdecl);
1719 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1721 else
1723 error ("conflicting declaration of %q#D with %qL linkage",
1724 newdecl, DECL_LANGUAGE (newdecl));
1725 inform (DECL_SOURCE_LOCATION (olddecl),
1726 "previous declaration with %qL linkage",
1727 DECL_LANGUAGE (olddecl));
1731 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1733 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1735 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1736 if (DECL_FUNCTION_MEMBER_P (olddecl)
1737 && (/* grokfndecl passes member function templates too
1738 as FUNCTION_DECLs. */
1739 DECL_TEMPLATE_INFO (olddecl)
1740 /* C++11 8.3.6/6.
1741 Default arguments for a member function of a class
1742 template shall be specified on the initial declaration
1743 of the member function within the class template. */
1744 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl))))
1745 check_redeclaration_no_default_args (newdecl);
1746 else
1748 tree t1 = FUNCTION_FIRST_USER_PARMTYPE (olddecl);
1749 tree t2 = FUNCTION_FIRST_USER_PARMTYPE (newdecl);
1750 int i = 1;
1752 for (; t1 && t1 != void_list_node;
1753 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1754 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1756 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1757 TREE_PURPOSE (t2)))
1759 if (permerror (input_location,
1760 "default argument given for parameter "
1761 "%d of %q#D", i, newdecl))
1762 inform (DECL_SOURCE_LOCATION (olddecl),
1763 "previous specification in %q#D here",
1764 olddecl);
1766 else
1768 error ("default argument given for parameter %d "
1769 "of %q#D", i, newdecl);
1770 inform (DECL_SOURCE_LOCATION (olddecl),
1771 "previous specification in %q#D here",
1772 olddecl);
1779 /* Do not merge an implicit typedef with an explicit one. In:
1781 class A;
1783 typedef class A A __attribute__ ((foo));
1785 the attribute should apply only to the typedef. */
1786 if (TREE_CODE (olddecl) == TYPE_DECL
1787 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1788 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1789 return NULL_TREE;
1791 /* If new decl is `static' and an `extern' was seen previously,
1792 warn about it. */
1793 warn_extern_redeclared_static (newdecl, olddecl);
1795 if (!validate_constexpr_redeclaration (olddecl, newdecl))
1796 return error_mark_node;
1798 /* We have committed to returning 1 at this point. */
1799 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1801 /* Now that functions must hold information normally held
1802 by field decls, there is extra work to do so that
1803 declaration information does not get destroyed during
1804 definition. */
1805 if (DECL_VINDEX (olddecl))
1806 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1807 if (DECL_CONTEXT (olddecl))
1808 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1809 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1810 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1811 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1812 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1813 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1814 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1815 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1816 SET_OVERLOADED_OPERATOR_CODE
1817 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1818 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1820 /* Optionally warn about more than one declaration for the same
1821 name, but don't warn about a function declaration followed by a
1822 definition. */
1823 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1824 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1825 /* Don't warn about extern decl followed by definition. */
1826 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1827 /* Don't warn about friends, let add_friend take care of it. */
1828 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
1829 /* Don't warn about declaration followed by specialization. */
1830 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
1831 || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
1833 if (warning (OPT_Wredundant_decls,
1834 "redundant redeclaration of %qD in same scope",
1835 newdecl))
1836 inform (DECL_SOURCE_LOCATION (olddecl),
1837 "previous declaration of %qD", olddecl);
1840 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl)
1841 && DECL_TEMPLATE_SPECIALIZATION (newdecl)))
1843 if (DECL_DELETED_FN (newdecl))
1845 error ("deleted definition of %qD", newdecl);
1846 inform (DECL_SOURCE_LOCATION (olddecl),
1847 "previous declaration of %qD", olddecl);
1849 DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl);
1853 /* Deal with C++: must preserve virtual function table size. */
1854 if (TREE_CODE (olddecl) == TYPE_DECL)
1856 tree newtype = TREE_TYPE (newdecl);
1857 tree oldtype = TREE_TYPE (olddecl);
1859 if (newtype != error_mark_node && oldtype != error_mark_node
1860 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1861 CLASSTYPE_FRIEND_CLASSES (newtype)
1862 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1864 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1867 /* Copy all the DECL_... slots specified in the new decl
1868 except for any that we copy here from the old type. */
1869 DECL_ATTRIBUTES (newdecl)
1870 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1872 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1874 tree old_result;
1875 tree new_result;
1876 old_result = DECL_TEMPLATE_RESULT (olddecl);
1877 new_result = DECL_TEMPLATE_RESULT (newdecl);
1878 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1879 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1880 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1881 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1883 DECL_ATTRIBUTES (old_result)
1884 = (*targetm.merge_decl_attributes) (old_result, new_result);
1886 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1888 /* Per C++11 8.3.6/4, default arguments cannot be added in later
1889 declarations of a function template. */
1890 check_redeclaration_no_default_args (newdecl);
1892 check_default_args (newdecl);
1894 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1895 && DECL_INITIAL (new_result))
1897 if (DECL_INITIAL (old_result))
1898 DECL_UNINLINABLE (old_result) = 1;
1899 else
1900 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1901 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1902 DECL_NOT_REALLY_EXTERN (old_result)
1903 = DECL_NOT_REALLY_EXTERN (new_result);
1904 DECL_INTERFACE_KNOWN (old_result)
1905 = DECL_INTERFACE_KNOWN (new_result);
1906 DECL_DECLARED_INLINE_P (old_result)
1907 = DECL_DECLARED_INLINE_P (new_result);
1908 DECL_DISREGARD_INLINE_LIMITS (old_result)
1909 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1912 else
1914 DECL_DECLARED_INLINE_P (old_result)
1915 |= DECL_DECLARED_INLINE_P (new_result);
1916 DECL_DISREGARD_INLINE_LIMITS (old_result)
1917 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1918 check_redeclaration_exception_specification (newdecl, olddecl);
1922 /* If the new declaration is a definition, update the file and
1923 line information on the declaration, and also make
1924 the old declaration the same definition. */
1925 if (DECL_INITIAL (new_result) != NULL_TREE)
1927 DECL_SOURCE_LOCATION (olddecl)
1928 = DECL_SOURCE_LOCATION (old_result)
1929 = DECL_SOURCE_LOCATION (newdecl);
1930 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1931 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1933 tree parm;
1934 DECL_ARGUMENTS (old_result)
1935 = DECL_ARGUMENTS (new_result);
1936 for (parm = DECL_ARGUMENTS (old_result); parm;
1937 parm = DECL_CHAIN (parm))
1938 DECL_CONTEXT (parm) = old_result;
1942 return olddecl;
1945 if (types_match)
1947 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1948 check_redeclaration_exception_specification (newdecl, olddecl);
1950 /* Automatically handles default parameters. */
1951 tree oldtype = TREE_TYPE (olddecl);
1952 tree newtype;
1954 /* For typedefs use the old type, as the new type's DECL_NAME points
1955 at newdecl, which will be ggc_freed. */
1956 if (TREE_CODE (newdecl) == TYPE_DECL)
1957 newtype = oldtype;
1958 else
1959 /* Merge the data types specified in the two decls. */
1960 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1962 if (VAR_P (newdecl))
1964 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1965 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1966 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1967 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1968 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1969 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1971 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1972 if (DECL_LANG_SPECIFIC (olddecl)
1973 && CP_DECL_THREADPRIVATE_P (olddecl))
1975 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1976 if (!DECL_LANG_SPECIFIC (newdecl))
1977 retrofit_lang_decl (newdecl);
1979 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1983 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1985 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1986 check_default_args (newdecl);
1988 /* Lay the type out, unless already done. */
1989 if (! same_type_p (newtype, oldtype)
1990 && TREE_TYPE (newdecl) != error_mark_node
1991 && !(processing_template_decl && uses_template_parms (newdecl)))
1992 layout_type (TREE_TYPE (newdecl));
1994 if ((VAR_P (newdecl)
1995 || TREE_CODE (newdecl) == PARM_DECL
1996 || TREE_CODE (newdecl) == RESULT_DECL
1997 || TREE_CODE (newdecl) == FIELD_DECL
1998 || TREE_CODE (newdecl) == TYPE_DECL)
1999 && !(processing_template_decl && uses_template_parms (newdecl)))
2000 layout_decl (newdecl, 0);
2002 /* Merge the type qualifiers. */
2003 if (TREE_READONLY (newdecl))
2004 TREE_READONLY (olddecl) = 1;
2005 if (TREE_THIS_VOLATILE (newdecl))
2006 TREE_THIS_VOLATILE (olddecl) = 1;
2007 if (TREE_NOTHROW (newdecl))
2008 TREE_NOTHROW (olddecl) = 1;
2010 /* Merge deprecatedness. */
2011 if (TREE_DEPRECATED (newdecl))
2012 TREE_DEPRECATED (olddecl) = 1;
2014 /* Preserve function specific target and optimization options */
2015 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2017 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2018 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2019 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2020 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2022 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2023 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2024 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2025 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2028 /* Merge the initialization information. */
2029 if (DECL_INITIAL (newdecl) == NULL_TREE
2030 && DECL_INITIAL (olddecl) != NULL_TREE)
2032 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2033 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2034 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2036 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2037 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2041 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2043 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2044 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2045 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2046 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
2047 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
2048 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
2049 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2050 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
2051 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
2052 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
2053 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
2054 /* Keep the old RTL. */
2055 COPY_DECL_RTL (olddecl, newdecl);
2057 else if (VAR_P (newdecl)
2058 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
2060 /* Keep the old RTL. We cannot keep the old RTL if the old
2061 declaration was for an incomplete object and the new
2062 declaration is not since many attributes of the RTL will
2063 change. */
2064 COPY_DECL_RTL (olddecl, newdecl);
2067 /* If cannot merge, then use the new type and qualifiers,
2068 and don't preserve the old rtl. */
2069 else
2071 /* Clean out any memory we had of the old declaration. */
2072 tree oldstatic = value_member (olddecl, static_aggregates);
2073 if (oldstatic)
2074 TREE_VALUE (oldstatic) = error_mark_node;
2076 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2077 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2078 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2079 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
2082 /* Merge the storage class information. */
2083 merge_weak (newdecl, olddecl);
2085 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
2086 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2087 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
2088 if (! DECL_EXTERNAL (olddecl))
2089 DECL_EXTERNAL (newdecl) = 0;
2091 new_template_info = NULL_TREE;
2092 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
2094 bool new_redefines_gnu_inline = false;
2096 if (new_defines_function
2097 && ((DECL_INTERFACE_KNOWN (olddecl)
2098 && TREE_CODE (olddecl) == FUNCTION_DECL)
2099 || (TREE_CODE (olddecl) == TEMPLATE_DECL
2100 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
2101 == FUNCTION_DECL))))
2103 tree fn = olddecl;
2105 if (TREE_CODE (fn) == TEMPLATE_DECL)
2106 fn = DECL_TEMPLATE_RESULT (olddecl);
2108 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
2111 if (!new_redefines_gnu_inline)
2113 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
2114 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
2115 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
2117 DECL_TEMPLATE_INSTANTIATED (newdecl)
2118 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
2119 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
2121 /* If the OLDDECL is an instantiation and/or specialization,
2122 then the NEWDECL must be too. But, it may not yet be marked
2123 as such if the caller has created NEWDECL, but has not yet
2124 figured out that it is a redeclaration. */
2125 if (!DECL_USE_TEMPLATE (newdecl))
2126 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
2128 /* Don't really know how much of the language-specific
2129 values we should copy from old to new. */
2130 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2131 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
2132 DECL_INITIALIZED_IN_CLASS_P (newdecl)
2133 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
2135 if (LANG_DECL_HAS_MIN (newdecl))
2137 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
2138 DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
2139 if (DECL_TEMPLATE_INFO (newdecl))
2141 new_template_info = DECL_TEMPLATE_INFO (newdecl);
2142 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2143 && DECL_TEMPLATE_SPECIALIZATION (newdecl))
2144 /* Remember the presence of explicit specialization args. */
2145 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl))
2146 = TINFO_USED_TEMPLATE_ID (new_template_info);
2148 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2150 /* Only functions have these fields. */
2151 if (DECL_DECLARES_FUNCTION_P (newdecl))
2153 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
2154 olddecl_friend = DECL_FRIEND_P (olddecl);
2155 hidden_friend = (DECL_ANTICIPATED (olddecl)
2156 && DECL_HIDDEN_FRIEND_P (olddecl)
2157 && newdecl_is_friend);
2158 DECL_BEFRIENDING_CLASSES (newdecl)
2159 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
2160 DECL_BEFRIENDING_CLASSES (olddecl));
2161 /* DECL_THUNKS is only valid for virtual functions,
2162 otherwise it is a DECL_FRIEND_CONTEXT. */
2163 if (DECL_VIRTUAL_P (newdecl))
2164 SET_DECL_THUNKS (newdecl, DECL_THUNKS (olddecl));
2166 /* Only variables have this field. */
2167 else if (VAR_P (newdecl)
2168 && VAR_HAD_UNKNOWN_BOUND (olddecl))
2169 SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
2172 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2174 tree parm;
2176 /* Merge parameter attributes. */
2177 tree oldarg, newarg;
2178 for (oldarg = DECL_ARGUMENTS(olddecl),
2179 newarg = DECL_ARGUMENTS(newdecl);
2180 oldarg && newarg;
2181 oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg)) {
2182 DECL_ATTRIBUTES (newarg)
2183 = (*targetm.merge_decl_attributes) (oldarg, newarg);
2184 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
2187 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2188 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
2190 /* If newdecl is not a specialization, then it is not a
2191 template-related function at all. And that means that we
2192 should have exited above, returning 0. */
2193 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
2195 if (DECL_ODR_USED (olddecl))
2196 /* From [temp.expl.spec]:
2198 If a template, a member template or the member of a class
2199 template is explicitly specialized then that
2200 specialization shall be declared before the first use of
2201 that specialization that would cause an implicit
2202 instantiation to take place, in every translation unit in
2203 which such a use occurs. */
2204 error ("explicit specialization of %qD after first use",
2205 olddecl);
2207 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
2208 DECL_COMDAT (newdecl) = (TREE_PUBLIC (newdecl)
2209 && DECL_DECLARED_INLINE_P (newdecl));
2211 /* Don't propagate visibility from the template to the
2212 specialization here. We'll do that in determine_visibility if
2213 appropriate. */
2214 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
2216 /* [temp.expl.spec/14] We don't inline explicit specialization
2217 just because the primary template says so. */
2219 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2220 the always_inline attribute. */
2221 if (DECL_DISREGARD_INLINE_LIMITS (olddecl)
2222 && !DECL_DISREGARD_INLINE_LIMITS (newdecl))
2224 if (DECL_DECLARED_INLINE_P (newdecl))
2225 DECL_DISREGARD_INLINE_LIMITS (newdecl) = true;
2226 else
2227 DECL_ATTRIBUTES (newdecl)
2228 = remove_attribute ("always_inline",
2229 DECL_ATTRIBUTES (newdecl));
2232 else if (new_defines_function && DECL_INITIAL (olddecl))
2234 /* Never inline re-defined extern inline functions.
2235 FIXME: this could be better handled by keeping both
2236 function as separate declarations. */
2237 DECL_UNINLINABLE (newdecl) = 1;
2239 else
2241 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
2242 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
2244 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
2246 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2247 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2249 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2250 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2251 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2252 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2255 /* Preserve abstractness on cloned [cd]tors. */
2256 DECL_ABSTRACT_P (newdecl) = DECL_ABSTRACT_P (olddecl);
2258 /* Update newdecl's parms to point at olddecl. */
2259 for (parm = DECL_ARGUMENTS (newdecl); parm;
2260 parm = DECL_CHAIN (parm))
2261 DECL_CONTEXT (parm) = olddecl;
2263 if (! types_match)
2265 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2266 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2267 COPY_DECL_RTL (newdecl, olddecl);
2269 if (! types_match || new_defines_function)
2271 /* These need to be copied so that the names are available.
2272 Note that if the types do match, we'll preserve inline
2273 info and other bits, but if not, we won't. */
2274 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2275 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2277 /* If redeclaring a builtin function, it stays built in
2278 if newdecl is a gnu_inline definition, or if newdecl is just
2279 a declaration. */
2280 if (DECL_BUILT_IN (olddecl)
2281 && (new_defines_function ? GNU_INLINE_P (newdecl) : types_match))
2283 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2284 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2285 /* If we're keeping the built-in definition, keep the rtl,
2286 regardless of declaration matches. */
2287 COPY_DECL_RTL (olddecl, newdecl);
2288 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2290 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2291 switch (fncode)
2293 /* If a compatible prototype of these builtin functions
2294 is seen, assume the runtime implements it with the
2295 expected semantics. */
2296 case BUILT_IN_STPCPY:
2297 if (builtin_decl_explicit_p (fncode))
2298 set_builtin_decl_implicit_p (fncode, true);
2299 break;
2300 default:
2301 break;
2305 if (new_defines_function)
2306 /* If defining a function declared with other language
2307 linkage, use the previously declared language linkage. */
2308 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2309 else if (types_match)
2311 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2312 /* Don't clear out the arguments if we're just redeclaring a
2313 function. */
2314 if (DECL_ARGUMENTS (olddecl))
2315 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2318 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2319 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2321 /* Now preserve various other info from the definition. */
2322 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2323 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2324 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2325 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2327 /* Warn about conflicting visibility specifications. */
2328 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2329 && DECL_VISIBILITY_SPECIFIED (newdecl)
2330 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2332 if (warning_at (DECL_SOURCE_LOCATION (newdecl), OPT_Wattributes,
2333 "%qD: visibility attribute ignored because it "
2334 "conflicts with previous declaration", newdecl))
2335 inform (DECL_SOURCE_LOCATION (olddecl),
2336 "previous declaration of %qD", olddecl);
2338 /* Choose the declaration which specified visibility. */
2339 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2341 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2342 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2344 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2345 so keep this behavior. */
2346 if (VAR_P (newdecl) && DECL_HAS_INIT_PRIORITY_P (newdecl))
2348 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2349 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2351 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2352 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2354 DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
2355 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2357 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2358 if (TREE_CODE (newdecl) == FIELD_DECL)
2359 DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
2361 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2362 with that from NEWDECL below. */
2363 if (DECL_LANG_SPECIFIC (olddecl))
2365 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2366 != DECL_LANG_SPECIFIC (newdecl));
2367 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2370 /* Merge the USED information. */
2371 if (TREE_USED (olddecl))
2372 TREE_USED (newdecl) = 1;
2373 else if (TREE_USED (newdecl))
2374 TREE_USED (olddecl) = 1;
2375 if (VAR_P (newdecl))
2377 if (DECL_READ_P (olddecl))
2378 DECL_READ_P (newdecl) = 1;
2379 else if (DECL_READ_P (newdecl))
2380 DECL_READ_P (olddecl) = 1;
2382 if (DECL_PRESERVE_P (olddecl))
2383 DECL_PRESERVE_P (newdecl) = 1;
2384 else if (DECL_PRESERVE_P (newdecl))
2385 DECL_PRESERVE_P (olddecl) = 1;
2387 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2388 to olddecl and deleted. */
2389 if (TREE_CODE (newdecl) == FUNCTION_DECL
2390 && DECL_FUNCTION_VERSIONED (olddecl))
2392 /* Set the flag for newdecl so that it gets copied to olddecl. */
2393 DECL_FUNCTION_VERSIONED (newdecl) = 1;
2394 /* newdecl will be purged after copying to olddecl and is no longer
2395 a version. */
2396 cgraph_node::delete_function_version (newdecl);
2399 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2401 int function_size;
2402 struct symtab_node *snode = symtab_node::get (olddecl);
2404 function_size = sizeof (struct tree_decl_common);
2406 memcpy ((char *) olddecl + sizeof (struct tree_common),
2407 (char *) newdecl + sizeof (struct tree_common),
2408 function_size - sizeof (struct tree_common));
2410 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2411 (char *) newdecl + sizeof (struct tree_decl_common),
2412 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2414 /* Preserve symtab node mapping. */
2415 olddecl->decl_with_vis.symtab_node = snode;
2417 if (new_template_info)
2418 /* If newdecl is a template instantiation, it is possible that
2419 the following sequence of events has occurred:
2421 o A friend function was declared in a class template. The
2422 class template was instantiated.
2424 o The instantiation of the friend declaration was
2425 recorded on the instantiation list, and is newdecl.
2427 o Later, however, instantiate_class_template called pushdecl
2428 on the newdecl to perform name injection. But, pushdecl in
2429 turn called duplicate_decls when it discovered that another
2430 declaration of a global function with the same name already
2431 existed.
2433 o Here, in duplicate_decls, we decided to clobber newdecl.
2435 If we're going to do that, we'd better make sure that
2436 olddecl, and not newdecl, is on the list of
2437 instantiations so that if we try to do the instantiation
2438 again we won't get the clobbered declaration. */
2439 reregister_specialization (newdecl,
2440 new_template_info,
2441 olddecl);
2443 else
2445 size_t size = tree_code_size (TREE_CODE (newdecl));
2447 memcpy ((char *) olddecl + sizeof (struct tree_common),
2448 (char *) newdecl + sizeof (struct tree_common),
2449 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2450 switch (TREE_CODE (newdecl))
2452 case LABEL_DECL:
2453 case VAR_DECL:
2454 case RESULT_DECL:
2455 case PARM_DECL:
2456 case FIELD_DECL:
2457 case TYPE_DECL:
2458 case CONST_DECL:
2460 struct symtab_node *snode = NULL;
2462 if (TREE_CODE (newdecl) == VAR_DECL
2463 && (TREE_STATIC (olddecl) || TREE_PUBLIC (olddecl) || DECL_EXTERNAL (olddecl)))
2464 snode = symtab_node::get (olddecl);
2465 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2466 (char *) newdecl + sizeof (struct tree_decl_common),
2467 size - sizeof (struct tree_decl_common)
2468 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2469 if (TREE_CODE (newdecl) == VAR_DECL)
2470 olddecl->decl_with_vis.symtab_node = snode;
2472 break;
2473 default:
2474 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2475 (char *) newdecl + sizeof (struct tree_decl_common),
2476 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2477 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2478 break;
2482 if (TREE_CODE (newdecl) == FUNCTION_DECL
2483 || TREE_CODE (newdecl) == VAR_DECL)
2485 if (DECL_EXTERNAL (olddecl)
2486 || TREE_PUBLIC (olddecl)
2487 || TREE_STATIC (olddecl))
2489 /* Merge the section attribute.
2490 We want to issue an error if the sections conflict but that must be
2491 done later in decl_attributes since we are called before attributes
2492 are assigned. */
2493 if (DECL_SECTION_NAME (newdecl) != NULL)
2494 set_decl_section_name (olddecl, DECL_SECTION_NAME (newdecl));
2496 if (DECL_ONE_ONLY (newdecl))
2498 struct symtab_node *oldsym, *newsym;
2499 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2500 oldsym = cgraph_node::get_create (olddecl);
2501 else
2502 oldsym = varpool_node::get_create (olddecl);
2503 newsym = symtab_node::get (newdecl);
2504 oldsym->set_comdat_group (newsym->get_comdat_group ());
2508 if (TREE_CODE (newdecl) == VAR_DECL
2509 && DECL_THREAD_LOCAL_P (newdecl))
2510 set_decl_tls_model (olddecl, DECL_TLS_MODEL (newdecl));
2513 DECL_UID (olddecl) = olddecl_uid;
2514 if (olddecl_friend)
2515 DECL_FRIEND_P (olddecl) = 1;
2516 if (hidden_friend)
2518 DECL_ANTICIPATED (olddecl) = 1;
2519 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2522 /* NEWDECL contains the merged attribute lists.
2523 Update OLDDECL to be the same. */
2524 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2526 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2527 so that encode_section_info has a chance to look at the new decl
2528 flags and attributes. */
2529 if (DECL_RTL_SET_P (olddecl)
2530 && (TREE_CODE (olddecl) == FUNCTION_DECL
2531 || (VAR_P (olddecl)
2532 && TREE_STATIC (olddecl))))
2533 make_decl_rtl (olddecl);
2535 /* The NEWDECL will no longer be needed. Because every out-of-class
2536 declaration of a member results in a call to duplicate_decls,
2537 freeing these nodes represents in a significant savings.
2539 Before releasing the node, be sore to remove function from symbol
2540 table that might have been inserted there to record comdat group.
2541 Be sure to however do not free DECL_STRUCT_FUNCTION becuase this
2542 structure is shared in between newdecl and oldecl. */
2543 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2544 DECL_STRUCT_FUNCTION (newdecl) = NULL;
2545 if (TREE_CODE (newdecl) == FUNCTION_DECL
2546 || TREE_CODE (newdecl) == VAR_DECL)
2548 struct symtab_node *snode = symtab_node::get (newdecl);
2549 if (snode)
2550 snode->remove ();
2552 ggc_free (newdecl);
2554 return olddecl;
2557 /* Return zero if the declaration NEWDECL is valid
2558 when the declaration OLDDECL (assumed to be for the same name)
2559 has already been seen.
2560 Otherwise return an error message format string with a %s
2561 where the identifier should go. */
2563 static const char *
2564 redeclaration_error_message (tree newdecl, tree olddecl)
2566 if (TREE_CODE (newdecl) == TYPE_DECL)
2568 /* Because C++ can put things into name space for free,
2569 constructs like "typedef struct foo { ... } foo"
2570 would look like an erroneous redeclaration. */
2571 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2572 return NULL;
2573 else
2574 return G_("redefinition of %q#D");
2576 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2578 /* If this is a pure function, its olddecl will actually be
2579 the original initialization to `0' (which we force to call
2580 abort()). Don't complain about redefinition in this case. */
2581 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2582 && DECL_INITIAL (olddecl) == NULL_TREE)
2583 return NULL;
2585 /* If both functions come from different namespaces, this is not
2586 a redeclaration - this is a conflict with a used function. */
2587 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2588 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2589 && ! decls_match (olddecl, newdecl))
2590 return G_("%qD conflicts with used function");
2592 /* We'll complain about linkage mismatches in
2593 warn_extern_redeclared_static. */
2595 /* Defining the same name twice is no good. */
2596 if (DECL_INITIAL (olddecl) != NULL_TREE
2597 && DECL_INITIAL (newdecl) != NULL_TREE)
2599 if (DECL_NAME (olddecl) == NULL_TREE)
2600 return G_("%q#D not declared in class");
2601 else if (!GNU_INLINE_P (olddecl)
2602 || GNU_INLINE_P (newdecl))
2603 return G_("redefinition of %q#D");
2606 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2608 bool olda = GNU_INLINE_P (olddecl);
2609 bool newa = GNU_INLINE_P (newdecl);
2611 if (olda != newa)
2613 if (newa)
2614 return G_("%q+D redeclared inline with "
2615 "%<gnu_inline%> attribute");
2616 else
2617 return G_("%q+D redeclared inline without "
2618 "%<gnu_inline%> attribute");
2622 check_abi_tag_redeclaration
2623 (olddecl, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl)),
2624 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl)));
2626 return NULL;
2628 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2630 tree nt, ot;
2632 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2634 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2635 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2636 return G_("redefinition of %q#D");
2637 return NULL;
2640 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2641 || (DECL_TEMPLATE_RESULT (newdecl)
2642 == DECL_TEMPLATE_RESULT (olddecl)))
2643 return NULL;
2645 nt = DECL_TEMPLATE_RESULT (newdecl);
2646 if (DECL_TEMPLATE_INFO (nt))
2647 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2648 ot = DECL_TEMPLATE_RESULT (olddecl);
2649 if (DECL_TEMPLATE_INFO (ot))
2650 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2651 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2652 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2653 return G_("redefinition of %q#D");
2655 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2657 bool olda = GNU_INLINE_P (ot);
2658 bool newa = GNU_INLINE_P (nt);
2660 if (olda != newa)
2662 if (newa)
2663 return G_("%q+D redeclared inline with "
2664 "%<gnu_inline%> attribute");
2665 else
2666 return G_("%q+D redeclared inline without "
2667 "%<gnu_inline%> attribute");
2671 /* Core issue #226 (C++0x):
2673 If a friend function template declaration specifies a
2674 default template-argument, that declaration shall be a
2675 definition and shall be the only declaration of the
2676 function template in the translation unit. */
2677 if ((cxx_dialect != cxx98)
2678 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2679 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2680 /*is_primary=*/true,
2681 /*is_partial=*/false,
2682 /*is_friend_decl=*/2))
2683 return G_("redeclaration of friend %q#D "
2684 "may not have default template arguments");
2686 return NULL;
2688 else if (VAR_P (newdecl)
2689 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2690 && (! DECL_LANG_SPECIFIC (olddecl)
2691 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2692 || DECL_THREAD_LOCAL_P (newdecl)))
2694 /* Only variables can be thread-local, and all declarations must
2695 agree on this property. */
2696 if (DECL_THREAD_LOCAL_P (newdecl))
2697 return G_("thread-local declaration of %q#D follows "
2698 "non-thread-local declaration");
2699 else
2700 return G_("non-thread-local declaration of %q#D follows "
2701 "thread-local declaration");
2703 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2705 /* The objects have been declared at namespace scope. If either
2706 is a member of an anonymous union, then this is an invalid
2707 redeclaration. For example:
2709 int i;
2710 union { int i; };
2712 is invalid. */
2713 if ((VAR_P (newdecl) && DECL_ANON_UNION_VAR_P (newdecl))
2714 || (VAR_P (olddecl) && DECL_ANON_UNION_VAR_P (olddecl)))
2715 return G_("redeclaration of %q#D");
2716 /* If at least one declaration is a reference, there is no
2717 conflict. For example:
2719 int i = 3;
2720 extern int i;
2722 is valid. */
2723 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2724 return NULL;
2725 /* Reject two definitions. */
2726 return G_("redefinition of %q#D");
2728 else
2730 /* Objects declared with block scope: */
2731 /* Reject two definitions, and reject a definition
2732 together with an external reference. */
2733 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2734 return G_("redeclaration of %q#D");
2735 return NULL;
2739 /* Hash and equality functions for the named_label table. */
2741 hashval_t
2742 named_label_hasher::hash (named_label_entry *ent)
2744 return DECL_UID (ent->label_decl);
2747 bool
2748 named_label_hasher::equal (named_label_entry *a, named_label_entry *b)
2750 return a->label_decl == b->label_decl;
2753 /* Create a new label, named ID. */
2755 static tree
2756 make_label_decl (tree id, int local_p)
2758 struct named_label_entry *ent;
2759 tree decl;
2761 decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2763 DECL_CONTEXT (decl) = current_function_decl;
2764 DECL_MODE (decl) = VOIDmode;
2765 C_DECLARED_LABEL_FLAG (decl) = local_p;
2767 /* Say where one reference is to the label, for the sake of the
2768 error if it is not defined. */
2769 DECL_SOURCE_LOCATION (decl) = input_location;
2771 /* Record the fact that this identifier is bound to this label. */
2772 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2774 /* Create the label htab for the function on demand. */
2775 if (!named_labels)
2776 named_labels = hash_table<named_label_hasher>::create_ggc (13);
2778 /* Record this label on the list of labels used in this function.
2779 We do this before calling make_label_decl so that we get the
2780 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2781 ent = ggc_cleared_alloc<named_label_entry> ();
2782 ent->label_decl = decl;
2784 named_label_entry **slot = named_labels->find_slot (ent, INSERT);
2785 gcc_assert (*slot == NULL);
2786 *slot = ent;
2788 return decl;
2791 /* Look for a label named ID in the current function. If one cannot
2792 be found, create one. (We keep track of used, but undefined,
2793 labels, and complain about them at the end of a function.) */
2795 static tree
2796 lookup_label_1 (tree id)
2798 tree decl;
2800 /* You can't use labels at global scope. */
2801 if (current_function_decl == NULL_TREE)
2803 error ("label %qE referenced outside of any function", id);
2804 return NULL_TREE;
2807 /* See if we've already got this label. */
2808 decl = IDENTIFIER_LABEL_VALUE (id);
2809 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2810 return decl;
2812 decl = make_label_decl (id, /*local_p=*/0);
2813 return decl;
2816 /* Wrapper for lookup_label_1. */
2818 tree
2819 lookup_label (tree id)
2821 tree ret;
2822 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2823 ret = lookup_label_1 (id);
2824 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2825 return ret;
2828 /* Declare a local label named ID. */
2830 tree
2831 declare_local_label (tree id)
2833 tree decl;
2834 cp_label_binding bind;
2836 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2837 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2838 bind.prev_value = IDENTIFIER_LABEL_VALUE (id);
2840 decl = make_label_decl (id, /*local_p=*/1);
2841 bind.label = decl;
2842 vec_safe_push (current_binding_level->shadowed_labels, bind);
2844 return decl;
2847 /* Returns nonzero if it is ill-formed to jump past the declaration of
2848 DECL. Returns 2 if it's also a real problem. */
2850 static int
2851 decl_jump_unsafe (tree decl)
2853 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2854 with automatic storage duration is not in scope to a point where it is
2855 in scope is ill-formed unless the variable has scalar type, class type
2856 with a trivial default constructor and a trivial destructor, a
2857 cv-qualified version of one of these types, or an array of one of the
2858 preceding types and is declared without an initializer (8.5). */
2859 tree type = TREE_TYPE (decl);
2861 if (!VAR_P (decl) || TREE_STATIC (decl)
2862 || type == error_mark_node)
2863 return 0;
2865 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl)
2866 || variably_modified_type_p (type, NULL_TREE))
2867 return 2;
2869 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
2870 return 1;
2872 return 0;
2875 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2877 static bool
2878 identify_goto (tree decl, const location_t *locus)
2880 bool complained = (decl
2881 ? permerror (input_location, "jump to label %qD", decl)
2882 : permerror (input_location, "jump to case label"));
2883 if (complained && locus)
2884 inform (*locus, " from here");
2885 return complained;
2888 /* Check that a single previously seen jump to a newly defined label
2889 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2890 the jump context; NAMES are the names in scope in LEVEL at the jump
2891 context; LOCUS is the source position of the jump or 0. Returns
2892 true if all is well. */
2894 static bool
2895 check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
2896 bool exited_omp, const location_t *locus)
2898 cp_binding_level *b;
2899 bool identified = false, complained = false;
2900 bool saw_eh = false, saw_omp = false;
2902 if (exited_omp)
2904 complained = identify_goto (decl, locus);
2905 if (complained)
2906 inform (input_location, " exits OpenMP structured block");
2907 identified = saw_omp = true;
2910 for (b = current_binding_level; b ; b = b->level_chain)
2912 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2914 for (new_decls = b->names; new_decls != old_decls;
2915 new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls)
2916 : TREE_CHAIN (new_decls)))
2918 int problem = decl_jump_unsafe (new_decls);
2919 if (! problem)
2920 continue;
2922 if (!identified)
2924 complained = identify_goto (decl, locus);
2925 identified = true;
2927 if (complained)
2929 if (problem > 1)
2930 inform (input_location,
2931 " crosses initialization of %q+#D", new_decls);
2932 else
2933 inform (input_location, " enters scope of %q+#D which has "
2934 "non-trivial destructor", new_decls);
2938 if (b == level)
2939 break;
2940 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2942 if (!identified)
2944 complained = identify_goto (decl, locus);
2945 identified = true;
2947 if (complained)
2949 if (b->kind == sk_try)
2950 inform (input_location, " enters try block");
2951 else
2952 inform (input_location, " enters catch block");
2954 saw_eh = true;
2956 if (b->kind == sk_omp && !saw_omp)
2958 if (!identified)
2960 complained = identify_goto (decl, locus);
2961 identified = true;
2963 if (complained)
2964 inform (input_location, " enters OpenMP structured block");
2965 saw_omp = true;
2969 return !identified;
2972 static void
2973 check_previous_goto (tree decl, struct named_label_use_entry *use)
2975 check_previous_goto_1 (decl, use->binding_level,
2976 use->names_in_scope, use->in_omp_scope,
2977 &use->o_goto_locus);
2980 static bool
2981 check_switch_goto (cp_binding_level* level)
2983 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2986 /* Check that a new jump to a label DECL is OK. Called by
2987 finish_goto_stmt. */
2989 void
2990 check_goto (tree decl)
2992 struct named_label_entry *ent, dummy;
2993 bool saw_catch = false, identified = false, complained = false;
2994 tree bad;
2995 unsigned ix;
2997 /* We can't know where a computed goto is jumping.
2998 So we assume that it's OK. */
2999 if (TREE_CODE (decl) != LABEL_DECL)
3000 return;
3002 /* We didn't record any information about this label when we created it,
3003 and there's not much point since it's trivial to analyze as a return. */
3004 if (decl == cdtor_label)
3005 return;
3007 dummy.label_decl = decl;
3008 ent = named_labels->find (&dummy);
3009 gcc_assert (ent != NULL);
3011 /* If the label hasn't been defined yet, defer checking. */
3012 if (! DECL_INITIAL (decl))
3014 struct named_label_use_entry *new_use;
3016 /* Don't bother creating another use if the last goto had the
3017 same data, and will therefore create the same set of errors. */
3018 if (ent->uses
3019 && ent->uses->names_in_scope == current_binding_level->names)
3020 return;
3022 new_use = ggc_alloc<named_label_use_entry> ();
3023 new_use->binding_level = current_binding_level;
3024 new_use->names_in_scope = current_binding_level->names;
3025 new_use->o_goto_locus = input_location;
3026 new_use->in_omp_scope = false;
3028 new_use->next = ent->uses;
3029 ent->uses = new_use;
3030 return;
3033 if (ent->in_try_scope || ent->in_catch_scope
3034 || ent->in_omp_scope || !vec_safe_is_empty (ent->bad_decls))
3036 complained = permerror (input_location, "jump to label %q+D", decl);
3037 if (complained)
3038 inform (input_location, " from here");
3039 identified = true;
3042 FOR_EACH_VEC_SAFE_ELT (ent->bad_decls, ix, bad)
3044 int u = decl_jump_unsafe (bad);
3046 if (u > 1 && DECL_ARTIFICIAL (bad))
3048 /* Can't skip init of __exception_info. */
3049 if (complained)
3050 inform (DECL_SOURCE_LOCATION (bad), " enters catch block");
3051 saw_catch = true;
3053 else if (complained)
3055 if (u > 1)
3056 inform (input_location, " skips initialization of %q+#D", bad);
3057 else
3058 inform (input_location, " enters scope of %q+#D which has "
3059 "non-trivial destructor", bad);
3063 if (complained)
3065 if (ent->in_try_scope)
3066 inform (input_location, " enters try block");
3067 else if (ent->in_catch_scope && !saw_catch)
3068 inform (input_location, " enters catch block");
3071 if (ent->in_omp_scope)
3073 if (complained)
3074 inform (input_location, " enters OpenMP structured block");
3076 else if (flag_openmp)
3078 cp_binding_level *b;
3079 for (b = current_binding_level; b ; b = b->level_chain)
3081 if (b == ent->binding_level)
3082 break;
3083 if (b->kind == sk_omp)
3085 if (!identified)
3087 complained = permerror (input_location,
3088 "jump to label %q+D", decl);
3089 if (complained)
3090 inform (input_location, " from here");
3091 identified = true;
3093 if (complained)
3094 inform (input_location, " exits OpenMP structured block");
3095 break;
3101 /* Check that a return is ok wrt OpenMP structured blocks.
3102 Called by finish_return_stmt. Returns true if all is well. */
3104 bool
3105 check_omp_return (void)
3107 cp_binding_level *b;
3108 for (b = current_binding_level; b ; b = b->level_chain)
3109 if (b->kind == sk_omp)
3111 error ("invalid exit from OpenMP structured block");
3112 return false;
3114 else if (b->kind == sk_function_parms)
3115 break;
3116 return true;
3119 /* Define a label, specifying the location in the source file.
3120 Return the LABEL_DECL node for the label. */
3122 static tree
3123 define_label_1 (location_t location, tree name)
3125 struct named_label_entry *ent, dummy;
3126 cp_binding_level *p;
3127 tree decl;
3129 decl = lookup_label (name);
3131 dummy.label_decl = decl;
3132 ent = named_labels->find (&dummy);
3133 gcc_assert (ent != NULL);
3135 /* After labels, make any new cleanups in the function go into their
3136 own new (temporary) binding contour. */
3137 for (p = current_binding_level;
3138 p->kind != sk_function_parms;
3139 p = p->level_chain)
3140 p->more_cleanups_ok = 0;
3142 if (name == get_identifier ("wchar_t"))
3143 permerror (input_location, "label named wchar_t");
3145 if (DECL_INITIAL (decl) != NULL_TREE)
3147 error ("duplicate label %qD", decl);
3148 return error_mark_node;
3150 else
3152 struct named_label_use_entry *use;
3154 /* Mark label as having been defined. */
3155 DECL_INITIAL (decl) = error_mark_node;
3156 /* Say where in the source. */
3157 DECL_SOURCE_LOCATION (decl) = location;
3159 ent->binding_level = current_binding_level;
3160 ent->names_in_scope = current_binding_level->names;
3162 for (use = ent->uses; use ; use = use->next)
3163 check_previous_goto (decl, use);
3164 ent->uses = NULL;
3167 return decl;
3170 /* Wrapper for define_label_1. */
3172 tree
3173 define_label (location_t location, tree name)
3175 tree ret;
3176 bool running = timevar_cond_start (TV_NAME_LOOKUP);
3177 ret = define_label_1 (location, name);
3178 timevar_cond_stop (TV_NAME_LOOKUP, running);
3179 return ret;
3183 struct cp_switch
3185 cp_binding_level *level;
3186 struct cp_switch *next;
3187 /* The SWITCH_STMT being built. */
3188 tree switch_stmt;
3189 /* A splay-tree mapping the low element of a case range to the high
3190 element, or NULL_TREE if there is no high element. Used to
3191 determine whether or not a new case label duplicates an old case
3192 label. We need a tree, rather than simply a hash table, because
3193 of the GNU case range extension. */
3194 splay_tree cases;
3197 /* A stack of the currently active switch statements. The innermost
3198 switch statement is on the top of the stack. There is no need to
3199 mark the stack for garbage collection because it is only active
3200 during the processing of the body of a function, and we never
3201 collect at that point. */
3203 static struct cp_switch *switch_stack;
3205 /* Called right after a switch-statement condition is parsed.
3206 SWITCH_STMT is the switch statement being parsed. */
3208 void
3209 push_switch (tree switch_stmt)
3211 struct cp_switch *p = XNEW (struct cp_switch);
3212 p->level = current_binding_level;
3213 p->next = switch_stack;
3214 p->switch_stmt = switch_stmt;
3215 p->cases = splay_tree_new (case_compare, NULL, NULL);
3216 switch_stack = p;
3219 void
3220 pop_switch (void)
3222 struct cp_switch *cs = switch_stack;
3223 location_t switch_location;
3225 /* Emit warnings as needed. */
3226 switch_location = EXPR_LOC_OR_LOC (cs->switch_stmt, input_location);
3227 if (!processing_template_decl)
3228 c_do_switch_warnings (cs->cases, switch_location,
3229 SWITCH_STMT_TYPE (cs->switch_stmt),
3230 SWITCH_STMT_COND (cs->switch_stmt));
3232 splay_tree_delete (cs->cases);
3233 switch_stack = switch_stack->next;
3234 free (cs);
3237 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3238 condition. Note that if TYPE and VALUE are already integral we don't
3239 really do the conversion because the language-independent
3240 warning/optimization code will work better that way. */
3242 static tree
3243 case_conversion (tree type, tree value)
3245 if (value == NULL_TREE)
3246 return value;
3248 if (cxx_dialect >= cxx11
3249 && (SCOPED_ENUM_P (type)
3250 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
3252 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
3253 type = type_promotes_to (type);
3254 value = (perform_implicit_conversion_flags
3255 (type, value, tf_warning_or_error,
3256 LOOKUP_IMPLICIT | LOOKUP_NO_NON_INTEGRAL));
3258 return cxx_constant_value (value);
3261 /* Note that we've seen a definition of a case label, and complain if this
3262 is a bad place for one. */
3264 tree
3265 finish_case_label (location_t loc, tree low_value, tree high_value)
3267 tree cond, r;
3268 cp_binding_level *p;
3269 tree type;
3271 if (processing_template_decl)
3273 tree label;
3275 /* For templates, just add the case label; we'll do semantic
3276 analysis at instantiation-time. */
3277 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
3278 return add_stmt (build_case_label (low_value, high_value, label));
3281 /* Find the condition on which this switch statement depends. */
3282 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
3283 if (cond && TREE_CODE (cond) == TREE_LIST)
3284 cond = TREE_VALUE (cond);
3286 if (!check_switch_goto (switch_stack->level))
3287 return error_mark_node;
3289 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt);
3291 low_value = case_conversion (type, low_value);
3292 high_value = case_conversion (type, high_value);
3294 r = c_add_case_label (loc, switch_stack->cases, cond, type,
3295 low_value, high_value);
3297 /* After labels, make any new cleanups in the function go into their
3298 own new (temporary) binding contour. */
3299 for (p = current_binding_level;
3300 p->kind != sk_function_parms;
3301 p = p->level_chain)
3302 p->more_cleanups_ok = 0;
3304 return r;
3307 struct typename_info {
3308 tree scope;
3309 tree name;
3310 tree template_id;
3311 bool enum_p;
3312 bool class_p;
3315 struct typename_hasher : ggc_hasher<tree>
3317 typedef typename_info *compare_type;
3319 /* Hash a TYPENAME_TYPE. */
3321 static hashval_t
3322 hash (tree t)
3324 hashval_t hash;
3326 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
3327 ^ htab_hash_pointer (TYPE_IDENTIFIER (t)));
3329 return hash;
3332 /* Compare two TYPENAME_TYPEs. */
3334 static bool
3335 equal (tree t1, const typename_info *t2)
3337 return (TYPE_IDENTIFIER (t1) == t2->name
3338 && TYPE_CONTEXT (t1) == t2->scope
3339 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
3340 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
3341 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
3345 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3346 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3348 Returns the new TYPENAME_TYPE. */
3350 static GTY (()) hash_table<typename_hasher> *typename_htab;
3352 static tree
3353 build_typename_type (tree context, tree name, tree fullname,
3354 enum tag_types tag_type)
3356 tree t;
3357 tree d;
3358 typename_info ti;
3359 tree *e;
3360 hashval_t hash;
3362 if (typename_htab == NULL)
3363 typename_htab = hash_table<typename_hasher>::create_ggc (61);
3365 ti.scope = FROB_CONTEXT (context);
3366 ti.name = name;
3367 ti.template_id = fullname;
3368 ti.enum_p = tag_type == enum_type;
3369 ti.class_p = (tag_type == class_type
3370 || tag_type == record_type
3371 || tag_type == union_type);
3372 hash = (htab_hash_pointer (ti.scope)
3373 ^ htab_hash_pointer (ti.name));
3375 /* See if we already have this type. */
3376 e = typename_htab->find_slot_with_hash (&ti, hash, INSERT);
3377 if (*e)
3378 t = *e;
3379 else
3381 /* Build the TYPENAME_TYPE. */
3382 t = cxx_make_type (TYPENAME_TYPE);
3383 TYPE_CONTEXT (t) = ti.scope;
3384 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
3385 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
3386 TYPENAME_IS_CLASS_P (t) = ti.class_p;
3388 /* Build the corresponding TYPE_DECL. */
3389 d = build_decl (input_location, TYPE_DECL, name, t);
3390 TYPE_NAME (TREE_TYPE (d)) = d;
3391 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3392 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3393 DECL_ARTIFICIAL (d) = 1;
3395 /* Store it in the hash table. */
3396 *e = t;
3398 /* TYPENAME_TYPEs must always be compared structurally, because
3399 they may or may not resolve down to another type depending on
3400 the currently open classes. */
3401 SET_TYPE_STRUCTURAL_EQUALITY (t);
3404 return t;
3407 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3408 provided to name the type. Returns an appropriate type, unless an
3409 error occurs, in which case error_mark_node is returned. If we
3410 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3411 return that, rather than the _TYPE it corresponds to, in other
3412 cases we look through the type decl. If TF_ERROR is set, complain
3413 about errors, otherwise be quiet. */
3415 tree
3416 make_typename_type (tree context, tree name, enum tag_types tag_type,
3417 tsubst_flags_t complain)
3419 tree fullname;
3420 tree t;
3421 bool want_template;
3423 if (name == error_mark_node
3424 || context == NULL_TREE
3425 || context == error_mark_node)
3426 return error_mark_node;
3428 if (TYPE_P (name))
3430 if (!(TYPE_LANG_SPECIFIC (name)
3431 && (CLASSTYPE_IS_TEMPLATE (name)
3432 || CLASSTYPE_USE_TEMPLATE (name))))
3433 name = TYPE_IDENTIFIER (name);
3434 else
3435 /* Create a TEMPLATE_ID_EXPR for the type. */
3436 name = build_nt (TEMPLATE_ID_EXPR,
3437 CLASSTYPE_TI_TEMPLATE (name),
3438 CLASSTYPE_TI_ARGS (name));
3440 else if (TREE_CODE (name) == TYPE_DECL)
3441 name = DECL_NAME (name);
3443 fullname = name;
3445 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3447 name = TREE_OPERAND (name, 0);
3448 if (TREE_CODE (name) == TEMPLATE_DECL)
3449 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3450 else if (TREE_CODE (name) == OVERLOAD)
3452 if (complain & tf_error)
3453 error ("%qD is not a type", name);
3454 return error_mark_node;
3457 if (TREE_CODE (name) == TEMPLATE_DECL)
3459 if (complain & tf_error)
3460 error ("%qD used without template parameters", name);
3461 return error_mark_node;
3463 gcc_assert (identifier_p (name));
3464 gcc_assert (TYPE_P (context));
3466 if (!MAYBE_CLASS_TYPE_P (context))
3468 if (complain & tf_error)
3469 error ("%q#T is not a class", context);
3470 return error_mark_node;
3473 /* When the CONTEXT is a dependent type, NAME could refer to a
3474 dependent base class of CONTEXT. But look inside it anyway
3475 if CONTEXT is a currently open scope, in case it refers to a
3476 member of the current instantiation or a non-dependent base;
3477 lookup will stop when we hit a dependent base. */
3478 if (!dependent_scope_p (context))
3479 /* We should only set WANT_TYPE when we're a nested typename type.
3480 Then we can give better diagnostics if we find a non-type. */
3481 t = lookup_field (context, name, 2, /*want_type=*/true);
3482 else
3483 t = NULL_TREE;
3485 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3486 return build_typename_type (context, name, fullname, tag_type);
3488 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3490 if (!t)
3492 if (complain & tf_error)
3493 error (want_template ? G_("no class template named %q#T in %q#T")
3494 : G_("no type named %q#T in %q#T"), name, context);
3495 return error_mark_node;
3498 /* Pull out the template from an injected-class-name (or multiple). */
3499 if (want_template)
3500 t = maybe_get_template_decl_from_type_decl (t);
3502 if (TREE_CODE (t) == TREE_LIST)
3504 if (complain & tf_error)
3506 error ("lookup of %qT in %qT is ambiguous", name, context);
3507 print_candidates (t);
3509 return error_mark_node;
3512 if (want_template && !DECL_TYPE_TEMPLATE_P (t))
3514 if (complain & tf_error)
3515 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3516 context, name, t);
3517 return error_mark_node;
3519 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3521 if (complain & tf_error)
3522 error ("%<typename %T::%D%> names %q#T, which is not a type",
3523 context, name, t);
3524 return error_mark_node;
3527 if (!perform_or_defer_access_check (TYPE_BINFO (context), t, t, complain))
3528 return error_mark_node;
3530 /* If we are currently parsing a template and if T is a typedef accessed
3531 through CONTEXT then we need to remember and check access of T at
3532 template instantiation time. */
3533 add_typedef_to_current_template_for_access_check (t, context, input_location);
3535 if (want_template)
3536 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3537 NULL_TREE, context,
3538 /*entering_scope=*/0,
3539 tf_warning_or_error | tf_user);
3541 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3542 t = TREE_TYPE (t);
3544 maybe_record_typedef_use (t);
3546 return t;
3549 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3550 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3551 in which case error_mark_node is returned.
3553 If PARM_LIST is non-NULL, also make sure that the template parameter
3554 list of TEMPLATE_DECL matches.
3556 If COMPLAIN zero, don't complain about any errors that occur. */
3558 tree
3559 make_unbound_class_template (tree context, tree name, tree parm_list,
3560 tsubst_flags_t complain)
3562 tree t;
3563 tree d;
3565 if (TYPE_P (name))
3566 name = TYPE_IDENTIFIER (name);
3567 else if (DECL_P (name))
3568 name = DECL_NAME (name);
3569 gcc_assert (identifier_p (name));
3571 if (!dependent_type_p (context)
3572 || currently_open_class (context))
3574 tree tmpl = NULL_TREE;
3576 if (MAYBE_CLASS_TYPE_P (context))
3577 tmpl = lookup_field (context, name, 0, false);
3579 if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
3580 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
3582 if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl))
3584 if (complain & tf_error)
3585 error ("no class template named %q#T in %q#T", name, context);
3586 return error_mark_node;
3589 if (parm_list
3590 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3592 if (complain & tf_error)
3594 error ("template parameters do not match template %qD", tmpl);
3595 inform (DECL_SOURCE_LOCATION (tmpl),
3596 "%qD declared here", tmpl);
3598 return error_mark_node;
3601 if (!perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl,
3602 complain))
3603 return error_mark_node;
3605 return tmpl;
3608 /* Build the UNBOUND_CLASS_TEMPLATE. */
3609 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3610 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3611 TREE_TYPE (t) = NULL_TREE;
3612 SET_TYPE_STRUCTURAL_EQUALITY (t);
3614 /* Build the corresponding TEMPLATE_DECL. */
3615 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3616 TYPE_NAME (TREE_TYPE (d)) = d;
3617 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3618 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3619 DECL_ARTIFICIAL (d) = 1;
3620 DECL_TEMPLATE_PARMS (d) = parm_list;
3622 return t;
3627 /* Push the declarations of builtin types into the namespace.
3628 RID_INDEX is the index of the builtin type in the array
3629 RID_POINTERS. NAME is the name used when looking up the builtin
3630 type. TYPE is the _TYPE node for the builtin type. */
3632 void
3633 record_builtin_type (enum rid rid_index,
3634 const char* name,
3635 tree type)
3637 tree rname = NULL_TREE, tname = NULL_TREE;
3638 tree tdecl = NULL_TREE;
3640 if ((int) rid_index < (int) RID_MAX)
3641 rname = ridpointers[(int) rid_index];
3642 if (name)
3643 tname = get_identifier (name);
3645 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3646 eliminated. Built-in types should not be looked up name; their
3647 names are keywords that the parser can recognize. However, there
3648 is code in c-common.c that uses identifier_global_value to look
3649 up built-in types by name. */
3650 if (tname)
3652 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3653 DECL_ARTIFICIAL (tdecl) = 1;
3654 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3656 if (rname)
3658 if (!tdecl)
3660 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3661 DECL_ARTIFICIAL (tdecl) = 1;
3663 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3666 if (!TYPE_NAME (type))
3667 TYPE_NAME (type) = tdecl;
3669 if (tdecl)
3670 debug_hooks->type_decl (tdecl, 0);
3673 /* Record one of the standard Java types.
3674 * Declare it as having the given NAME.
3675 * If SIZE > 0, it is the size of one of the integral types;
3676 * otherwise it is the negative of the size of one of the other types. */
3678 static tree
3679 record_builtin_java_type (const char* name, int size)
3681 tree type, decl;
3682 if (size > 0)
3684 type = build_nonstandard_integer_type (size, 0);
3685 type = build_distinct_type_copy (type);
3687 else if (size > -32)
3689 tree stype;
3690 /* "__java_char" or ""__java_boolean". */
3691 type = build_nonstandard_integer_type (-size, 1);
3692 type = build_distinct_type_copy (type);
3693 /* Get the signed type cached and attached to the unsigned type,
3694 so it doesn't get garbage-collected at "random" times,
3695 causing potential codegen differences out of different UIDs
3696 and different alias set numbers. */
3697 stype = build_nonstandard_integer_type (-size, 0);
3698 stype = build_distinct_type_copy (stype);
3699 TREE_CHAIN (type) = stype;
3700 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3702 else
3703 { /* "__java_float" or ""__java_double". */
3704 type = make_node (REAL_TYPE);
3705 TYPE_PRECISION (type) = - size;
3706 layout_type (type);
3708 record_builtin_type (RID_MAX, name, type);
3709 decl = TYPE_NAME (type);
3711 /* Suppress generate debug symbol entries for these types,
3712 since for normal C++ they are just clutter.
3713 However, push_lang_context undoes this if extern "Java" is seen. */
3714 DECL_IGNORED_P (decl) = 1;
3716 TYPE_FOR_JAVA (type) = 1;
3717 return type;
3720 /* Push a type into the namespace so that the back ends ignore it. */
3722 static void
3723 record_unknown_type (tree type, const char* name)
3725 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3726 TYPE_DECL, get_identifier (name), type));
3727 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3728 DECL_IGNORED_P (decl) = 1;
3729 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3730 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3731 TYPE_ALIGN (type) = 1;
3732 TYPE_USER_ALIGN (type) = 0;
3733 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3736 /* A string for which we should create an IDENTIFIER_NODE at
3737 startup. */
3739 typedef struct predefined_identifier
3741 /* The name of the identifier. */
3742 const char *const name;
3743 /* The place where the IDENTIFIER_NODE should be stored. */
3744 tree *const node;
3745 /* Nonzero if this is the name of a constructor or destructor. */
3746 const int ctor_or_dtor_p;
3747 } predefined_identifier;
3749 /* Create all the predefined identifiers. */
3751 static void
3752 initialize_predefined_identifiers (void)
3754 const predefined_identifier *pid;
3756 /* A table of identifiers to create at startup. */
3757 static const predefined_identifier predefined_identifiers[] = {
3758 { "C++", &lang_name_cplusplus, 0 },
3759 { "C", &lang_name_c, 0 },
3760 { "Java", &lang_name_java, 0 },
3761 /* Some of these names have a trailing space so that it is
3762 impossible for them to conflict with names written by users. */
3763 { "__ct ", &ctor_identifier, 1 },
3764 { "__base_ctor ", &base_ctor_identifier, 1 },
3765 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3766 { "__dt ", &dtor_identifier, 1 },
3767 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3768 { "__base_dtor ", &base_dtor_identifier, 1 },
3769 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3770 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3771 { "nelts", &nelts_identifier, 0 },
3772 { THIS_NAME, &this_identifier, 0 },
3773 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3774 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3775 { "_vptr", &vptr_identifier, 0 },
3776 { "__vtt_parm", &vtt_parm_identifier, 0 },
3777 { "::", &global_scope_name, 0 },
3778 { "std", &std_identifier, 0 },
3779 { NULL, NULL, 0 }
3782 for (pid = predefined_identifiers; pid->name; ++pid)
3784 *pid->node = get_identifier (pid->name);
3785 if (pid->ctor_or_dtor_p)
3786 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3790 /* Create the predefined scalar types of C,
3791 and some nodes representing standard constants (0, 1, (void *)0).
3792 Initialize the global binding level.
3793 Make definitions for built-in primitive functions. */
3795 void
3796 cxx_init_decl_processing (void)
3798 tree void_ftype;
3799 tree void_ftype_ptr;
3801 /* Create all the identifiers we need. */
3802 initialize_predefined_identifiers ();
3804 /* Create the global variables. */
3805 push_to_top_level ();
3807 current_function_decl = NULL_TREE;
3808 current_binding_level = NULL;
3809 /* Enter the global namespace. */
3810 gcc_assert (global_namespace == NULL_TREE);
3811 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3812 void_type_node);
3813 DECL_CONTEXT (global_namespace) = build_translation_unit_decl (NULL_TREE);
3814 TREE_PUBLIC (global_namespace) = 1;
3815 begin_scope (sk_namespace, global_namespace);
3817 if (flag_visibility_ms_compat)
3818 default_visibility = VISIBILITY_HIDDEN;
3820 /* Initially, C. */
3821 current_lang_name = lang_name_c;
3823 /* Create the `std' namespace. */
3824 push_namespace (std_identifier);
3825 std_node = current_namespace;
3826 pop_namespace ();
3828 c_common_nodes_and_builtins ();
3830 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3831 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3832 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3833 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3834 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3835 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3836 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3837 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3839 integer_two_node = build_int_cst (NULL_TREE, 2);
3841 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3842 truthvalue_type_node = boolean_type_node;
3843 truthvalue_false_node = boolean_false_node;
3844 truthvalue_true_node = boolean_true_node;
3846 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3847 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE);
3848 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE);
3850 #if 0
3851 record_builtin_type (RID_MAX, NULL, string_type_node);
3852 #endif
3854 delta_type_node = ptrdiff_type_node;
3855 vtable_index_type = ptrdiff_type_node;
3857 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3858 void_ftype = build_function_type_list (void_type_node, NULL_TREE);
3859 void_ftype_ptr = build_function_type_list (void_type_node,
3860 ptr_type_node, NULL_TREE);
3861 void_ftype_ptr
3862 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3864 /* C++ extensions */
3866 unknown_type_node = make_node (LANG_TYPE);
3867 record_unknown_type (unknown_type_node, "unknown type");
3869 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3870 TREE_TYPE (unknown_type_node) = unknown_type_node;
3872 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3873 result. */
3874 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3875 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3877 init_list_type_node = make_node (LANG_TYPE);
3878 record_unknown_type (init_list_type_node, "init list");
3881 /* Make sure we get a unique function type, so we can give
3882 its pointer type a name. (This wins for gdb.) */
3883 tree vfunc_type = make_node (FUNCTION_TYPE);
3884 TREE_TYPE (vfunc_type) = integer_type_node;
3885 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3886 layout_type (vfunc_type);
3888 vtable_entry_type = build_pointer_type (vfunc_type);
3890 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3892 vtbl_type_node
3893 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3894 layout_type (vtbl_type_node);
3895 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3896 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3897 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3898 layout_type (vtbl_ptr_type_node);
3899 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3901 push_namespace (get_identifier ("__cxxabiv1"));
3902 abi_node = current_namespace;
3903 pop_namespace ();
3905 global_type_node = make_node (LANG_TYPE);
3906 record_unknown_type (global_type_node, "global type");
3908 /* Now, C++. */
3909 current_lang_name = lang_name_cplusplus;
3912 tree newattrs, extvisattr;
3913 tree newtype, deltype;
3914 tree ptr_ftype_sizetype;
3915 tree new_eh_spec;
3917 ptr_ftype_sizetype
3918 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE);
3919 if (cxx_dialect == cxx98)
3921 tree bad_alloc_id;
3922 tree bad_alloc_type_node;
3923 tree bad_alloc_decl;
3925 push_namespace (std_identifier);
3926 bad_alloc_id = get_identifier ("bad_alloc");
3927 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3928 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3929 bad_alloc_decl
3930 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3931 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3932 pop_namespace ();
3934 new_eh_spec
3935 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
3937 else
3938 new_eh_spec = noexcept_false_spec;
3940 /* Ensure attribs.c is initialized. */
3941 init_attributes ();
3942 extvisattr = build_tree_list (get_identifier ("externally_visible"),
3943 NULL_TREE);
3944 newattrs = tree_cons (get_identifier ("alloc_size"),
3945 build_tree_list (NULL_TREE, integer_one_node),
3946 extvisattr);
3947 newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs);
3948 newtype = build_exception_variant (newtype, new_eh_spec);
3949 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
3950 deltype = build_exception_variant (deltype, empty_except_spec);
3951 tree opnew = push_cp_library_fn (NEW_EXPR, newtype, 0);
3952 DECL_IS_MALLOC (opnew) = 1;
3953 DECL_IS_OPERATOR_NEW (opnew) = 1;
3954 opnew = push_cp_library_fn (VEC_NEW_EXPR, newtype, 0);
3955 DECL_IS_MALLOC (opnew) = 1;
3956 DECL_IS_OPERATOR_NEW (opnew) = 1;
3957 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
3958 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
3960 nullptr_type_node = make_node (NULLPTR_TYPE);
3961 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
3962 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode));
3963 TYPE_UNSIGNED (nullptr_type_node) = 1;
3964 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode);
3965 SET_TYPE_MODE (nullptr_type_node, ptr_mode);
3966 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node);
3967 nullptr_node = build_int_cst (nullptr_type_node, 0);
3970 abort_fndecl
3971 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype,
3972 ECF_NORETURN | ECF_NOTHROW);
3974 /* Perform other language dependent initializations. */
3975 init_class_processing ();
3976 init_rtti_processing ();
3977 init_template_processing ();
3979 if (flag_exceptions)
3980 init_exception_processing ();
3982 if (! supports_one_only ())
3983 flag_weak = 0;
3985 make_fname_decl = cp_make_fname_decl;
3986 start_fname_decls ();
3988 /* Show we use EH for cleanups. */
3989 if (flag_exceptions)
3990 using_eh_for_cleanups ();
3993 /* Generate an initializer for a function naming variable from
3994 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3995 filled in with the type of the init. */
3997 tree
3998 cp_fname_init (const char* name, tree *type_p)
4000 tree domain = NULL_TREE;
4001 tree type;
4002 tree init = NULL_TREE;
4003 size_t length = 0;
4005 if (name)
4007 length = strlen (name);
4008 domain = build_index_type (size_int (length));
4009 init = build_string (length + 1, name);
4012 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
4013 type = build_cplus_array_type (type, domain);
4015 *type_p = type;
4017 if (init)
4018 TREE_TYPE (init) = type;
4019 else
4020 init = error_mark_node;
4022 return init;
4025 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4026 the decl, LOC is the location to give the decl, NAME is the
4027 initialization string and TYPE_DEP indicates whether NAME depended
4028 on the type of the function. We make use of that to detect
4029 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4030 at the point of first use, so we mustn't push the decl now. */
4032 static tree
4033 cp_make_fname_decl (location_t loc, tree id, int type_dep)
4035 const char *const name = (type_dep && processing_template_decl
4036 ? NULL : fname_as_string (type_dep));
4037 tree type;
4038 tree init = cp_fname_init (name, &type);
4039 tree decl = build_decl (loc, VAR_DECL, id, type);
4041 if (name)
4042 free (CONST_CAST (char *, name));
4044 /* As we're using pushdecl_with_scope, we must set the context. */
4045 DECL_CONTEXT (decl) = current_function_decl;
4047 TREE_STATIC (decl) = 1;
4048 TREE_READONLY (decl) = 1;
4049 DECL_ARTIFICIAL (decl) = 1;
4051 TREE_USED (decl) = 1;
4053 if (current_function_decl)
4055 cp_binding_level *b = current_binding_level;
4056 if (b->kind == sk_function_parms)
4057 return error_mark_node;
4058 while (b->level_chain->kind != sk_function_parms)
4059 b = b->level_chain;
4060 pushdecl_with_scope (decl, b, /*is_friend=*/false);
4061 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
4062 LOOKUP_ONLYCONVERTING);
4064 else
4066 DECL_THIS_STATIC (decl) = true;
4067 pushdecl_top_level_and_finish (decl, init);
4070 return decl;
4073 static tree
4074 builtin_function_1 (tree decl, tree context, bool is_global)
4076 tree id = DECL_NAME (decl);
4077 const char *name = IDENTIFIER_POINTER (id);
4079 retrofit_lang_decl (decl);
4081 DECL_ARTIFICIAL (decl) = 1;
4082 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
4083 SET_DECL_LANGUAGE (decl, lang_c);
4084 /* Runtime library routines are, by definition, available in an
4085 external shared object. */
4086 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4087 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4089 DECL_CONTEXT (decl) = context;
4091 if (is_global)
4092 pushdecl_top_level (decl);
4093 else
4094 pushdecl (decl);
4096 /* A function in the user's namespace should have an explicit
4097 declaration before it is used. Mark the built-in function as
4098 anticipated but not actually declared. */
4099 if (name[0] != '_' || name[1] != '_')
4100 DECL_ANTICIPATED (decl) = 1;
4101 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
4103 size_t len = strlen (name);
4105 /* Treat __*_chk fortification functions as anticipated as well,
4106 unless they are __builtin_*. */
4107 if (len > strlen ("___chk")
4108 && memcmp (name + len - strlen ("_chk"),
4109 "_chk", strlen ("_chk") + 1) == 0)
4110 DECL_ANTICIPATED (decl) = 1;
4113 return decl;
4116 tree
4117 cxx_builtin_function (tree decl)
4119 tree id = DECL_NAME (decl);
4120 const char *name = IDENTIFIER_POINTER (id);
4121 /* All builtins that don't begin with an '_' should additionally
4122 go in the 'std' namespace. */
4123 if (name[0] != '_')
4125 tree decl2 = copy_node(decl);
4126 push_namespace (std_identifier);
4127 builtin_function_1 (decl2, std_node, false);
4128 pop_namespace ();
4131 return builtin_function_1 (decl, NULL_TREE, false);
4134 /* Like cxx_builtin_function, but guarantee the function is added to the global
4135 scope. This is to allow function specific options to add new machine
4136 dependent builtins when the target ISA changes via attribute((target(...)))
4137 which saves space on program startup if the program does not use non-generic
4138 ISAs. */
4140 tree
4141 cxx_builtin_function_ext_scope (tree decl)
4144 tree id = DECL_NAME (decl);
4145 const char *name = IDENTIFIER_POINTER (id);
4146 /* All builtins that don't begin with an '_' should additionally
4147 go in the 'std' namespace. */
4148 if (name[0] != '_')
4150 tree decl2 = copy_node(decl);
4151 push_namespace (std_identifier);
4152 builtin_function_1 (decl2, std_node, true);
4153 pop_namespace ();
4156 return builtin_function_1 (decl, NULL_TREE, true);
4159 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4160 function. Not called directly. */
4162 static tree
4163 build_library_fn (tree name, enum tree_code operator_code, tree type,
4164 int ecf_flags)
4166 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
4167 DECL_EXTERNAL (fn) = 1;
4168 TREE_PUBLIC (fn) = 1;
4169 DECL_ARTIFICIAL (fn) = 1;
4170 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
4171 SET_DECL_LANGUAGE (fn, lang_c);
4172 /* Runtime library routines are, by definition, available in an
4173 external shared object. */
4174 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
4175 DECL_VISIBILITY_SPECIFIED (fn) = 1;
4176 set_call_expr_flags (fn, ecf_flags);
4177 return fn;
4180 /* Returns the _DECL for a library function with C++ linkage. */
4182 static tree
4183 build_cp_library_fn (tree name, enum tree_code operator_code, tree type,
4184 int ecf_flags)
4186 tree fn = build_library_fn (name, operator_code, type, ecf_flags);
4187 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
4188 SET_DECL_LANGUAGE (fn, lang_cplusplus);
4189 return fn;
4192 /* Like build_library_fn, but takes a C string instead of an
4193 IDENTIFIER_NODE. */
4195 tree
4196 build_library_fn_ptr (const char* name, tree type, int ecf_flags)
4198 return build_library_fn (get_identifier (name), ERROR_MARK, type, ecf_flags);
4201 /* Like build_cp_library_fn, but takes a C string instead of an
4202 IDENTIFIER_NODE. */
4204 tree
4205 build_cp_library_fn_ptr (const char* name, tree type, int ecf_flags)
4207 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type,
4208 ecf_flags);
4211 /* Like build_library_fn, but also pushes the function so that we will
4212 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4213 may throw exceptions listed in RAISES. */
4215 tree
4216 push_library_fn (tree name, tree type, tree raises, int ecf_flags)
4218 tree fn;
4220 if (raises)
4221 type = build_exception_variant (type, raises);
4223 fn = build_library_fn (name, ERROR_MARK, type, ecf_flags);
4224 pushdecl_top_level (fn);
4225 return fn;
4228 /* Like build_cp_library_fn, but also pushes the function so that it
4229 will be found by normal lookup. */
4231 static tree
4232 push_cp_library_fn (enum tree_code operator_code, tree type,
4233 int ecf_flags)
4235 tree fn = build_cp_library_fn (ansi_opname (operator_code),
4236 operator_code,
4237 type, ecf_flags);
4238 pushdecl (fn);
4239 if (flag_tm)
4240 apply_tm_attr (fn, get_identifier ("transaction_safe"));
4241 return fn;
4244 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4245 a FUNCTION_TYPE. */
4247 tree
4248 push_void_library_fn (tree name, tree parmtypes, int ecf_flags)
4250 tree type = build_function_type (void_type_node, parmtypes);
4251 return push_library_fn (name, type, NULL_TREE, ecf_flags);
4254 /* Like push_library_fn, but also note that this function throws
4255 and does not return. Used for __throw_foo and the like. */
4257 tree
4258 push_throw_library_fn (tree name, tree type)
4260 tree fn = push_library_fn (name, type, NULL_TREE, ECF_NORETURN);
4261 return fn;
4264 /* When we call finish_struct for an anonymous union, we create
4265 default copy constructors and such. But, an anonymous union
4266 shouldn't have such things; this function undoes the damage to the
4267 anonymous union type T.
4269 (The reason that we create the synthesized methods is that we don't
4270 distinguish `union { int i; }' from `typedef union { int i; } U'.
4271 The first is an anonymous union; the second is just an ordinary
4272 union type.) */
4274 void
4275 fixup_anonymous_aggr (tree t)
4277 tree *q;
4279 /* Wipe out memory of synthesized methods. */
4280 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
4281 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
4282 TYPE_HAS_COPY_CTOR (t) = 0;
4283 TYPE_HAS_CONST_COPY_CTOR (t) = 0;
4284 TYPE_HAS_COPY_ASSIGN (t) = 0;
4285 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0;
4287 /* Splice the implicitly generated functions out of the TYPE_METHODS
4288 list. */
4289 q = &TYPE_METHODS (t);
4290 while (*q)
4292 if (DECL_ARTIFICIAL (*q))
4293 *q = TREE_CHAIN (*q);
4294 else
4295 q = &DECL_CHAIN (*q);
4298 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4299 if (TYPE_METHODS (t))
4301 tree decl = TYPE_MAIN_DECL (t);
4303 if (TREE_CODE (t) != UNION_TYPE)
4304 error_at (DECL_SOURCE_LOCATION (decl),
4305 "an anonymous struct cannot have function members");
4306 else
4307 error_at (DECL_SOURCE_LOCATION (decl),
4308 "an anonymous union cannot have function members");
4311 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4312 assignment operators (because they cannot have these methods themselves).
4313 For anonymous unions this is already checked because they are not allowed
4314 in any union, otherwise we have to check it. */
4315 if (TREE_CODE (t) != UNION_TYPE)
4317 tree field, type;
4319 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4320 if (TREE_CODE (field) == FIELD_DECL)
4322 type = TREE_TYPE (field);
4323 if (CLASS_TYPE_P (type))
4325 if (TYPE_NEEDS_CONSTRUCTING (type))
4326 error ("member %q+#D with constructor not allowed "
4327 "in anonymous aggregate", field);
4328 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4329 error ("member %q+#D with destructor not allowed "
4330 "in anonymous aggregate", field);
4331 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
4332 error ("member %q+#D with copy assignment operator "
4333 "not allowed in anonymous aggregate", field);
4339 /* Warn for an attribute located at LOCATION that appertains to the
4340 class type CLASS_TYPE that has not been properly placed after its
4341 class-key, in it class-specifier. */
4343 void
4344 warn_misplaced_attr_for_class_type (source_location location,
4345 tree class_type)
4347 gcc_assert (OVERLOAD_TYPE_P (class_type));
4349 if (warning_at (location, OPT_Wattributes,
4350 "attribute ignored in declaration "
4351 "of %q#T", class_type))
4352 inform (location,
4353 "attribute for %q#T must follow the %qs keyword",
4354 class_type, class_key_or_enum_as_string (class_type));
4357 /* Make sure that a declaration with no declarator is well-formed, i.e.
4358 just declares a tagged type or anonymous union.
4360 Returns the type declared; or NULL_TREE if none. */
4362 tree
4363 check_tag_decl (cp_decl_specifier_seq *declspecs,
4364 bool explicit_type_instantiation_p)
4366 int saw_friend = decl_spec_seq_has_spec_p (declspecs, ds_friend);
4367 int saw_typedef = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
4368 /* If a class, struct, or enum type is declared by the DECLSPECS
4369 (i.e, if a class-specifier, enum-specifier, or non-typename
4370 elaborated-type-specifier appears in the DECLSPECS),
4371 DECLARED_TYPE is set to the corresponding type. */
4372 tree declared_type = NULL_TREE;
4373 bool error_p = false;
4375 if (declspecs->multiple_types_p)
4376 error ("multiple types in one declaration");
4377 else if (declspecs->redefined_builtin_type)
4379 if (!in_system_header_at (input_location))
4380 permerror (declspecs->locations[ds_redefined_builtin_type_spec],
4381 "redeclaration of C++ built-in type %qT",
4382 declspecs->redefined_builtin_type);
4383 return NULL_TREE;
4386 if (declspecs->type
4387 && TYPE_P (declspecs->type)
4388 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
4389 && MAYBE_CLASS_TYPE_P (declspecs->type))
4390 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
4391 declared_type = declspecs->type;
4392 else if (declspecs->type == error_mark_node)
4393 error_p = true;
4394 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
4395 permerror (input_location, "declaration does not declare anything");
4396 else if (declared_type != NULL_TREE && type_uses_auto (declared_type))
4398 error ("%<auto%> can only be specified for variables "
4399 "or function declarations");
4400 return error_mark_node;
4402 /* Check for an anonymous union. */
4403 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
4404 && TYPE_ANONYMOUS_P (declared_type))
4406 /* 7/3 In a simple-declaration, the optional init-declarator-list
4407 can be omitted only when declaring a class (clause 9) or
4408 enumeration (7.2), that is, when the decl-specifier-seq contains
4409 either a class-specifier, an elaborated-type-specifier with
4410 a class-key (9.1), or an enum-specifier. In these cases and
4411 whenever a class-specifier or enum-specifier is present in the
4412 decl-specifier-seq, the identifiers in these specifiers are among
4413 the names being declared by the declaration (as class-name,
4414 enum-names, or enumerators, depending on the syntax). In such
4415 cases, and except for the declaration of an unnamed bit-field (9.6),
4416 the decl-specifier-seq shall introduce one or more names into the
4417 program, or shall redeclare a name introduced by a previous
4418 declaration. [Example:
4419 enum { }; // ill-formed
4420 typedef class { }; // ill-formed
4421 --end example] */
4422 if (saw_typedef)
4424 error ("missing type-name in typedef-declaration");
4425 return NULL_TREE;
4427 /* Anonymous unions are objects, so they can have specifiers. */;
4428 SET_ANON_AGGR_TYPE_P (declared_type);
4430 if (TREE_CODE (declared_type) != UNION_TYPE
4431 && !in_system_header_at (input_location))
4432 pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
4435 else
4437 if (decl_spec_seq_has_spec_p (declspecs, ds_inline)
4438 || decl_spec_seq_has_spec_p (declspecs, ds_virtual))
4439 error ("%qs can only be specified for functions",
4440 decl_spec_seq_has_spec_p (declspecs, ds_inline)
4441 ? "inline" : "virtual");
4442 else if (saw_friend
4443 && (!current_class_type
4444 || current_scope () != current_class_type))
4445 error ("%<friend%> can only be specified inside a class");
4446 else if (decl_spec_seq_has_spec_p (declspecs, ds_explicit))
4447 error ("%<explicit%> can only be specified for constructors");
4448 else if (declspecs->storage_class)
4449 error ("a storage class can only be specified for objects "
4450 "and functions");
4451 else if (decl_spec_seq_has_spec_p (declspecs, ds_const)
4452 || decl_spec_seq_has_spec_p (declspecs, ds_volatile)
4453 || decl_spec_seq_has_spec_p (declspecs, ds_restrict)
4454 || decl_spec_seq_has_spec_p (declspecs, ds_thread))
4455 error ("qualifiers can only be specified for objects "
4456 "and functions");
4457 else if (saw_typedef)
4458 warning (0, "%<typedef%> was ignored in this declaration");
4459 else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr))
4460 error ("%<constexpr%> cannot be used for type declarations");
4463 if (declspecs->attributes && warn_attributes && declared_type)
4465 location_t loc;
4466 if (!CLASS_TYPE_P (declared_type)
4467 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type))
4468 /* For a non-template class, use the name location. */
4469 loc = location_of (declared_type);
4470 else
4471 /* For a template class (an explicit instantiation), use the
4472 current location. */
4473 loc = input_location;
4475 if (explicit_type_instantiation_p)
4476 /* [dcl.attr.grammar]/4:
4478 No attribute-specifier-seq shall appertain to an explicit
4479 instantiation. */
4481 if (warning_at (loc, OPT_Wattributes,
4482 "attribute ignored in explicit instantiation %q#T",
4483 declared_type))
4484 inform (loc,
4485 "no attribute can be applied to "
4486 "an explicit instantiation");
4488 else
4489 warn_misplaced_attr_for_class_type (loc, declared_type);
4492 return declared_type;
4495 /* Called when a declaration is seen that contains no names to declare.
4496 If its type is a reference to a structure, union or enum inherited
4497 from a containing scope, shadow that tag name for the current scope
4498 with a forward reference.
4499 If its type defines a new named structure or union
4500 or defines an enum, it is valid but we need not do anything here.
4501 Otherwise, it is an error.
4503 C++: may have to grok the declspecs to learn about static,
4504 complain for anonymous unions.
4506 Returns the TYPE declared -- or NULL_TREE if none. */
4508 tree
4509 shadow_tag (cp_decl_specifier_seq *declspecs)
4511 tree t = check_tag_decl (declspecs,
4512 /*explicit_type_instantiation_p=*/false);
4514 if (!t)
4515 return NULL_TREE;
4517 if (maybe_process_partial_specialization (t) == error_mark_node)
4518 return NULL_TREE;
4520 /* This is where the variables in an anonymous union are
4521 declared. An anonymous union declaration looks like:
4522 union { ... } ;
4523 because there is no declarator after the union, the parser
4524 sends that declaration here. */
4525 if (ANON_AGGR_TYPE_P (t))
4527 fixup_anonymous_aggr (t);
4529 if (TYPE_FIELDS (t))
4531 tree decl = grokdeclarator (/*declarator=*/NULL,
4532 declspecs, NORMAL, 0, NULL);
4533 finish_anon_union (decl);
4537 return t;
4540 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4542 tree
4543 groktypename (cp_decl_specifier_seq *type_specifiers,
4544 const cp_declarator *declarator,
4545 bool is_template_arg)
4547 tree attrs;
4548 tree type;
4549 enum decl_context context
4550 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
4551 attrs = type_specifiers->attributes;
4552 type_specifiers->attributes = NULL_TREE;
4553 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
4554 if (attrs && type != error_mark_node)
4556 if (CLASS_TYPE_P (type))
4557 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
4558 "outside of definition", type);
4559 else if (MAYBE_CLASS_TYPE_P (type))
4560 /* A template type parameter or other dependent type. */
4561 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
4562 "type %qT without an associated declaration", type);
4563 else
4564 cplus_decl_attributes (&type, attrs, 0);
4566 return type;
4569 /* Process a DECLARATOR for a function-scope variable declaration,
4570 namespace-scope variable declaration, or function declaration.
4571 (Function definitions go through start_function; class member
4572 declarations appearing in the body of the class go through
4573 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4574 If an error occurs, the error_mark_node is returned instead.
4576 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4577 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4578 for an explicitly defaulted function, or SD_DELETED for an explicitly
4579 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4580 implicitly initialized via a default constructor. ATTRIBUTES and
4581 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4583 The scope represented by the context of the returned DECL is pushed
4584 (if it is not the global namespace) and is assigned to
4585 *PUSHED_SCOPE_P. The caller is then responsible for calling
4586 pop_scope on *PUSHED_SCOPE_P if it is set. */
4588 tree
4589 start_decl (const cp_declarator *declarator,
4590 cp_decl_specifier_seq *declspecs,
4591 int initialized,
4592 tree attributes,
4593 tree prefix_attributes,
4594 tree *pushed_scope_p)
4596 tree decl;
4597 tree context;
4598 bool was_public;
4599 int flags;
4600 bool alias;
4602 *pushed_scope_p = NULL_TREE;
4604 /* An object declared as __attribute__((deprecated)) suppresses
4605 warnings of uses of other deprecated items. */
4606 if (lookup_attribute ("deprecated", attributes))
4607 deprecated_state = DEPRECATED_SUPPRESS;
4609 attributes = chainon (attributes, prefix_attributes);
4611 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4612 &attributes);
4614 deprecated_state = DEPRECATED_NORMAL;
4616 if (decl == NULL_TREE || VOID_TYPE_P (decl)
4617 || decl == error_mark_node)
4618 return error_mark_node;
4620 context = CP_DECL_CONTEXT (decl);
4621 if (context != global_namespace)
4622 *pushed_scope_p = push_scope (context);
4624 if (initialized)
4625 /* Is it valid for this decl to have an initializer at all?
4626 If not, set INITIALIZED to zero, which will indirectly
4627 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4628 switch (TREE_CODE (decl))
4630 case TYPE_DECL:
4631 error ("typedef %qD is initialized (use decltype instead)", decl);
4632 return error_mark_node;
4634 case FUNCTION_DECL:
4635 if (initialized == SD_DELETED)
4636 /* We'll handle the rest of the semantics later, but we need to
4637 set this now so it's visible to duplicate_decls. */
4638 DECL_DELETED_FN (decl) = 1;
4639 break;
4641 default:
4642 break;
4645 if (initialized)
4647 if (! toplevel_bindings_p ()
4648 && DECL_EXTERNAL (decl))
4649 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4650 decl);
4651 DECL_EXTERNAL (decl) = 0;
4652 if (toplevel_bindings_p ())
4653 TREE_STATIC (decl) = 1;
4655 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0;
4657 if (alias && TREE_CODE (decl) == FUNCTION_DECL)
4658 record_key_method_defined (decl);
4660 /* If this is a typedef that names the class for linkage purposes
4661 (7.1.3p8), apply any attributes directly to the type. */
4662 if (TREE_CODE (decl) == TYPE_DECL
4663 && OVERLOAD_TYPE_P (TREE_TYPE (decl))
4664 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4665 flags = ATTR_FLAG_TYPE_IN_PLACE;
4666 else
4667 flags = 0;
4669 /* Set attributes here so if duplicate decl, will have proper attributes. */
4670 cplus_decl_attributes (&decl, attributes, flags);
4672 /* Dllimported symbols cannot be defined. Static data members (which
4673 can be initialized in-class and dllimported) go through grokfield,
4674 not here, so we don't need to exclude those decls when checking for
4675 a definition. */
4676 if (initialized && DECL_DLLIMPORT_P (decl))
4678 error ("definition of %q#D is marked %<dllimport%>", decl);
4679 DECL_DLLIMPORT_P (decl) = 0;
4682 /* If #pragma weak was used, mark the decl weak now. */
4683 if (!processing_template_decl)
4684 maybe_apply_pragma_weak (decl);
4686 if (TREE_CODE (decl) == FUNCTION_DECL
4687 && DECL_DECLARED_INLINE_P (decl)
4688 && DECL_UNINLINABLE (decl)
4689 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4690 warning (0, "inline function %q+D given attribute noinline", decl);
4692 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context)))
4694 bool this_tmpl = (processing_template_decl
4695 > template_class_depth (context));
4696 if (VAR_P (decl))
4698 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4699 if (field == NULL_TREE
4700 || !(VAR_P (field) || variable_template_p (field)))
4701 error ("%q+#D is not a static data member of %q#T", decl, context);
4702 else if (variable_template_p (field) && !this_tmpl)
4704 if (DECL_LANG_SPECIFIC (decl)
4705 && DECL_TEMPLATE_SPECIALIZATION (decl))
4706 /* OK, specialization was already checked. */;
4707 else
4709 error_at (DECL_SOURCE_LOCATION (decl),
4710 "non-member-template declaration of %qD", decl);
4711 inform (DECL_SOURCE_LOCATION (field), "does not match "
4712 "member template declaration here");
4713 return error_mark_node;
4716 else
4718 if (variable_template_p (field))
4719 field = DECL_TEMPLATE_RESULT (field);
4721 if (DECL_CONTEXT (field) != context)
4723 if (!same_type_p (DECL_CONTEXT (field), context))
4724 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4725 "to be defined as %<%T::%D%>",
4726 DECL_CONTEXT (field), DECL_NAME (decl),
4727 context, DECL_NAME (decl));
4728 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4730 /* Static data member are tricky; an in-class initialization
4731 still doesn't provide a definition, so the in-class
4732 declaration will have DECL_EXTERNAL set, but will have an
4733 initialization. Thus, duplicate_decls won't warn
4734 about this situation, and so we check here. */
4735 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4736 error ("duplicate initialization of %qD", decl);
4737 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4738 decl = field;
4739 if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr)
4740 && !DECL_DECLARED_CONSTEXPR_P (field))
4741 error ("%qD declared %<constexpr%> outside its class", field);
4744 else
4746 tree field = check_classfn (context, decl,
4747 this_tmpl
4748 ? current_template_parms
4749 : NULL_TREE);
4750 if (field && field != error_mark_node
4751 && duplicate_decls (decl, field,
4752 /*newdecl_is_friend=*/false))
4753 decl = field;
4756 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4757 DECL_IN_AGGR_P (decl) = 0;
4758 /* Do not mark DECL as an explicit specialization if it was not
4759 already marked as an instantiation; a declaration should
4760 never be marked as a specialization unless we know what
4761 template is being specialized. */
4762 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4764 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4765 if (TREE_CODE (decl) == FUNCTION_DECL)
4766 DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
4767 && DECL_DECLARED_INLINE_P (decl));
4768 else
4769 DECL_COMDAT (decl) = false;
4771 /* [temp.expl.spec] An explicit specialization of a static data
4772 member of a template is a definition if the declaration
4773 includes an initializer; otherwise, it is a declaration.
4775 We check for processing_specialization so this only applies
4776 to the new specialization syntax. */
4777 if (!initialized && processing_specialization)
4778 DECL_EXTERNAL (decl) = 1;
4781 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
4782 /* Aliases are definitions. */
4783 && !alias)
4784 permerror (input_location, "declaration of %q#D outside of class is not definition",
4785 decl);
4788 was_public = TREE_PUBLIC (decl);
4790 /* Enter this declaration into the symbol table. */
4791 decl = maybe_push_decl (decl);
4793 if (processing_template_decl)
4794 decl = push_template_decl (decl);
4795 if (decl == error_mark_node)
4796 return error_mark_node;
4798 if (VAR_P (decl)
4799 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4800 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4802 /* This is a const variable with implicit 'static'. Set
4803 DECL_THIS_STATIC so we can tell it from variables that are
4804 !TREE_PUBLIC because of the anonymous namespace. */
4805 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)) || errorcount);
4806 DECL_THIS_STATIC (decl) = 1;
4809 if (current_function_decl && VAR_P (decl)
4810 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
4812 bool ok = false;
4813 if (DECL_THREAD_LOCAL_P (decl))
4814 error ("%qD declared %<thread_local%> in %<constexpr%> function",
4815 decl);
4816 else if (TREE_STATIC (decl))
4817 error ("%qD declared %<static%> in %<constexpr%> function", decl);
4818 else
4819 ok = true;
4820 if (!ok)
4821 cp_function_chain->invalid_constexpr = true;
4824 if (!processing_template_decl && VAR_P (decl))
4825 start_decl_1 (decl, initialized);
4827 return decl;
4830 /* Process the declaration of a variable DECL. INITIALIZED is true
4831 iff DECL is explicitly initialized. (INITIALIZED is false if the
4832 variable is initialized via an implicitly-called constructor.)
4833 This function must be called for ordinary variables (including, for
4834 example, implicit instantiations of templates), but must not be
4835 called for template declarations. */
4837 void
4838 start_decl_1 (tree decl, bool initialized)
4840 tree type;
4841 bool complete_p;
4842 bool aggregate_definition_p;
4844 gcc_assert (!processing_template_decl);
4846 if (error_operand_p (decl))
4847 return;
4849 gcc_assert (VAR_P (decl));
4851 type = TREE_TYPE (decl);
4852 complete_p = COMPLETE_TYPE_P (type);
4853 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4855 /* If an explicit initializer is present, or if this is a definition
4856 of an aggregate, then we need a complete type at this point.
4857 (Scalars are always complete types, so there is nothing to
4858 check.) This code just sets COMPLETE_P; errors (if necessary)
4859 are issued below. */
4860 if ((initialized || aggregate_definition_p)
4861 && !complete_p
4862 && COMPLETE_TYPE_P (complete_type (type)))
4864 complete_p = true;
4865 /* We will not yet have set TREE_READONLY on DECL if the type
4866 was "const", but incomplete, before this point. But, now, we
4867 have a complete type, so we can try again. */
4868 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4871 if (initialized)
4872 /* Is it valid for this decl to have an initializer at all? */
4874 /* Don't allow initializations for incomplete types except for
4875 arrays which might be completed by the initialization. */
4876 if (complete_p)
4877 ; /* A complete type is ok. */
4878 else if (type_uses_auto (type))
4879 ; /* An auto type is ok. */
4880 else if (TREE_CODE (type) != ARRAY_TYPE)
4882 error ("variable %q#D has initializer but incomplete type", decl);
4883 type = TREE_TYPE (decl) = error_mark_node;
4885 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4887 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4888 error ("elements of array %q#D have incomplete type", decl);
4889 /* else we already gave an error in start_decl. */
4892 else if (aggregate_definition_p && !complete_p)
4894 if (type_uses_auto (type))
4895 error ("declaration of %q#D has no initializer", decl);
4896 else
4897 error ("aggregate %q#D has incomplete type and cannot be defined",
4898 decl);
4899 /* Change the type so that assemble_variable will give
4900 DECL an rtl we can live with: (mem (const_int 0)). */
4901 type = TREE_TYPE (decl) = error_mark_node;
4904 /* Create a new scope to hold this declaration if necessary.
4905 Whether or not a new scope is necessary cannot be determined
4906 until after the type has been completed; if the type is a
4907 specialization of a class template it is not until after
4908 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4909 will be set correctly. */
4910 maybe_push_cleanup_level (type);
4913 /* Handle initialization of references. DECL, TYPE, and INIT have the
4914 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4915 but will be set to a new CLEANUP_STMT if a temporary is created
4916 that must be destroyed subsequently.
4918 Returns an initializer expression to use to initialize DECL, or
4919 NULL if the initialization can be performed statically.
4921 Quotes on semantics can be found in ARM 8.4.3. */
4923 static tree
4924 grok_reference_init (tree decl, tree type, tree init, int flags)
4926 if (init == NULL_TREE)
4928 if ((DECL_LANG_SPECIFIC (decl) == 0
4929 || DECL_IN_AGGR_P (decl) == 0)
4930 && ! DECL_THIS_EXTERN (decl))
4931 error ("%qD declared as reference but not initialized", decl);
4932 return NULL_TREE;
4935 if (TREE_CODE (init) == TREE_LIST)
4936 init = build_x_compound_expr_from_list (init, ELK_INIT,
4937 tf_warning_or_error);
4939 tree ttype = TREE_TYPE (type);
4940 if (TREE_CODE (ttype) != ARRAY_TYPE
4941 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4942 /* Note: default conversion is only called in very special cases. */
4943 init = decay_conversion (init, tf_warning_or_error);
4945 /* check_initializer handles this for non-reference variables, but for
4946 references we need to do it here or the initializer will get the
4947 incomplete array type and confuse later calls to
4948 cp_complete_array_type. */
4949 if (TREE_CODE (ttype) == ARRAY_TYPE
4950 && TYPE_DOMAIN (ttype) == NULL_TREE
4951 && (BRACE_ENCLOSED_INITIALIZER_P (init)
4952 || TREE_CODE (init) == STRING_CST))
4954 cp_complete_array_type (&ttype, init, false);
4955 if (ttype != TREE_TYPE (type))
4956 type = cp_build_reference_type (ttype, TYPE_REF_IS_RVALUE (type));
4959 /* Convert INIT to the reference type TYPE. This may involve the
4960 creation of a temporary, whose lifetime must be the same as that
4961 of the reference. If so, a DECL_EXPR for the temporary will be
4962 added just after the DECL_EXPR for DECL. That's why we don't set
4963 DECL_INITIAL for local references (instead assigning to them
4964 explicitly); we need to allow the temporary to be initialized
4965 first. */
4966 return initialize_reference (type, init, flags,
4967 tf_warning_or_error);
4970 /* Designated initializers in arrays are not supported in GNU C++.
4971 The parser cannot detect this error since it does not know whether
4972 a given brace-enclosed initializer is for a class type or for an
4973 array. This function checks that CE does not use a designated
4974 initializer. If it does, an error is issued. Returns true if CE
4975 is valid, i.e., does not have a designated initializer. */
4977 static bool
4978 check_array_designated_initializer (constructor_elt *ce,
4979 unsigned HOST_WIDE_INT index)
4981 /* Designated initializers for array elements are not supported. */
4982 if (ce->index)
4984 /* The parser only allows identifiers as designated
4985 initializers. */
4986 if (ce->index == error_mark_node)
4988 error ("name used in a GNU-style designated "
4989 "initializer for an array");
4990 return false;
4992 else if (identifier_p (ce->index))
4994 error ("name %qD used in a GNU-style designated "
4995 "initializer for an array", ce->index);
4996 return false;
4999 ce->index = cxx_constant_value (ce->index);
5001 if (TREE_CODE (ce->index) == INTEGER_CST)
5003 /* A C99 designator is OK if it matches the current index. */
5004 if (wi::eq_p (ce->index, index))
5005 return true;
5006 else
5007 sorry ("non-trivial designated initializers not supported");
5009 else
5010 gcc_unreachable ();
5012 return false;
5015 return true;
5018 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5019 array until we finish parsing the initializer. If that's the
5020 situation we're in, update DECL accordingly. */
5022 static void
5023 maybe_deduce_size_from_array_init (tree decl, tree init)
5025 tree type = TREE_TYPE (decl);
5027 if (TREE_CODE (type) == ARRAY_TYPE
5028 && TYPE_DOMAIN (type) == NULL_TREE
5029 && TREE_CODE (decl) != TYPE_DECL)
5031 /* do_default is really a C-ism to deal with tentative definitions.
5032 But let's leave it here to ease the eventual merge. */
5033 int do_default = !DECL_EXTERNAL (decl);
5034 tree initializer = init ? init : DECL_INITIAL (decl);
5035 int failure = 0;
5037 /* Check that there are no designated initializers in INIT, as
5038 those are not supported in GNU C++, and as the middle-end
5039 will crash if presented with a non-numeric designated
5040 initializer. */
5041 if (initializer && BRACE_ENCLOSED_INITIALIZER_P (initializer))
5043 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initializer);
5044 constructor_elt *ce;
5045 HOST_WIDE_INT i;
5046 FOR_EACH_VEC_SAFE_ELT (v, i, ce)
5047 if (!check_array_designated_initializer (ce, i))
5048 failure = 1;
5051 if (!failure)
5053 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
5054 do_default);
5055 if (failure == 1)
5057 error ("initializer fails to determine size of %qD", decl);
5059 else if (failure == 2)
5061 if (do_default)
5063 error ("array size missing in %qD", decl);
5065 /* If a `static' var's size isn't known, make it extern as
5066 well as static, so it does not get allocated. If it's not
5067 `static', then don't mark it extern; finish_incomplete_decl
5068 will give it a default size and it will get allocated. */
5069 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
5070 DECL_EXTERNAL (decl) = 1;
5072 else if (failure == 3)
5074 error ("zero-size array %qD", decl);
5078 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
5080 relayout_decl (decl);
5084 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5085 any appropriate error messages regarding the layout. */
5087 static void
5088 layout_var_decl (tree decl)
5090 tree type;
5092 type = TREE_TYPE (decl);
5093 if (type == error_mark_node)
5094 return;
5096 /* If we haven't already laid out this declaration, do so now.
5097 Note that we must not call complete type for an external object
5098 because it's type might involve templates that we are not
5099 supposed to instantiate yet. (And it's perfectly valid to say
5100 `extern X x' for some incomplete type `X'.) */
5101 if (!DECL_EXTERNAL (decl))
5102 complete_type (type);
5103 if (!DECL_SIZE (decl)
5104 && TREE_TYPE (decl) != error_mark_node
5105 && (COMPLETE_TYPE_P (type)
5106 || (TREE_CODE (type) == ARRAY_TYPE
5107 && !TYPE_DOMAIN (type)
5108 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
5109 layout_decl (decl, 0);
5111 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
5113 /* An automatic variable with an incomplete type: that is an error.
5114 Don't talk about array types here, since we took care of that
5115 message in grokdeclarator. */
5116 error ("storage size of %qD isn%'t known", decl);
5117 TREE_TYPE (decl) = error_mark_node;
5119 #if 0
5120 /* Keep this code around in case we later want to control debug info
5121 based on whether a type is "used". (jason 1999-11-11) */
5123 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
5124 /* Let debugger know it should output info for this type. */
5125 note_debug_info_needed (ttype);
5127 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
5128 note_debug_info_needed (DECL_CONTEXT (decl));
5129 #endif
5131 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
5132 && DECL_SIZE (decl) != NULL_TREE
5133 && ! TREE_CONSTANT (DECL_SIZE (decl)))
5135 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
5136 constant_expression_warning (DECL_SIZE (decl));
5137 else
5139 error ("storage size of %qD isn%'t constant", decl);
5140 TREE_TYPE (decl) = error_mark_node;
5145 /* If a local static variable is declared in an inline function, or if
5146 we have a weak definition, we must endeavor to create only one
5147 instance of the variable at link-time. */
5149 void
5150 maybe_commonize_var (tree decl)
5152 /* Static data in a function with comdat linkage also has comdat
5153 linkage. */
5154 if (TREE_STATIC (decl)
5155 /* Don't mess with __FUNCTION__. */
5156 && ! DECL_ARTIFICIAL (decl)
5157 && DECL_FUNCTION_SCOPE_P (decl)
5158 && vague_linkage_p (DECL_CONTEXT (decl)))
5160 if (flag_weak)
5162 /* With weak symbols, we simply make the variable COMDAT;
5163 that will cause copies in multiple translations units to
5164 be merged. */
5165 comdat_linkage (decl);
5167 else
5169 if (DECL_INITIAL (decl) == NULL_TREE
5170 || DECL_INITIAL (decl) == error_mark_node)
5172 /* Without weak symbols, we can use COMMON to merge
5173 uninitialized variables. */
5174 TREE_PUBLIC (decl) = 1;
5175 DECL_COMMON (decl) = 1;
5177 else
5179 /* While for initialized variables, we must use internal
5180 linkage -- which means that multiple copies will not
5181 be merged. */
5182 TREE_PUBLIC (decl) = 0;
5183 DECL_COMMON (decl) = 0;
5184 if (warning_at (DECL_SOURCE_LOCATION (decl), 0,
5185 "sorry: semantics of inline function static "
5186 "data %q#D are wrong (you%'ll wind up "
5187 "with multiple copies)", decl))
5188 inform (DECL_SOURCE_LOCATION (decl),
5189 "you can work around this by removing the initializer");
5195 /* Issue an error message if DECL is an uninitialized const variable. */
5197 static void
5198 check_for_uninitialized_const_var (tree decl)
5200 tree type = strip_array_types (TREE_TYPE (decl));
5202 /* ``Unless explicitly declared extern, a const object does not have
5203 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5204 7.1.6 */
5205 if (VAR_P (decl)
5206 && TREE_CODE (type) != REFERENCE_TYPE
5207 && (CP_TYPE_CONST_P (type) || var_in_constexpr_fn (decl))
5208 && !DECL_INITIAL (decl))
5210 tree field = default_init_uninitialized_part (type);
5211 if (!field)
5212 return;
5214 if (CP_TYPE_CONST_P (type))
5215 permerror (DECL_SOURCE_LOCATION (decl),
5216 "uninitialized const %qD", decl);
5217 else
5219 error_at (DECL_SOURCE_LOCATION (decl),
5220 "uninitialized variable %qD in %<constexpr%> function",
5221 decl);
5222 cp_function_chain->invalid_constexpr = true;
5225 if (CLASS_TYPE_P (type))
5227 tree defaulted_ctor;
5229 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
5230 "%q#T has no user-provided default constructor", type);
5231 defaulted_ctor = in_class_defaulted_default_constructor (type);
5232 if (defaulted_ctor)
5233 inform (DECL_SOURCE_LOCATION (defaulted_ctor),
5234 "constructor is not user-provided because it is "
5235 "explicitly defaulted in the class body");
5236 inform (0, "and the implicitly-defined constructor does not "
5237 "initialize %q+#D", field);
5242 /* Structure holding the current initializer being processed by reshape_init.
5243 CUR is a pointer to the current element being processed, END is a pointer
5244 after the last element present in the initializer. */
5245 typedef struct reshape_iterator_t
5247 constructor_elt *cur;
5248 constructor_elt *end;
5249 } reshape_iter;
5251 static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t);
5253 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5254 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5255 initialized. If there are no more such fields, the return value
5256 will be NULL. */
5258 tree
5259 next_initializable_field (tree field)
5261 while (field
5262 && (TREE_CODE (field) != FIELD_DECL
5263 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
5264 || DECL_ARTIFICIAL (field)))
5265 field = DECL_CHAIN (field);
5267 return field;
5270 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5271 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5272 INTEGER_CST representing the size of the array minus one (the maximum index),
5273 or NULL_TREE if the array was declared without specifying the size. D is
5274 the iterator within the constructor. */
5276 static tree
5277 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d,
5278 tsubst_flags_t complain)
5280 tree new_init;
5281 bool sized_array_p = (max_index && TREE_CONSTANT (max_index));
5282 unsigned HOST_WIDE_INT max_index_cst = 0;
5283 unsigned HOST_WIDE_INT index;
5285 /* The initializer for an array is always a CONSTRUCTOR. */
5286 new_init = build_constructor (init_list_type_node, NULL);
5288 if (sized_array_p)
5290 /* Minus 1 is used for zero sized arrays. */
5291 if (integer_all_onesp (max_index))
5292 return new_init;
5294 if (tree_fits_uhwi_p (max_index))
5295 max_index_cst = tree_to_uhwi (max_index);
5296 /* sizetype is sign extended, not zero extended. */
5297 else
5298 max_index_cst = tree_to_uhwi (fold_convert (size_type_node, max_index));
5301 /* Loop until there are no more initializers. */
5302 for (index = 0;
5303 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
5304 ++index)
5306 tree elt_init;
5307 constructor_elt *old_cur = d->cur;
5309 check_array_designated_initializer (d->cur, index);
5310 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false,
5311 complain);
5312 if (elt_init == error_mark_node)
5313 return error_mark_node;
5314 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
5315 size_int (index), elt_init);
5316 if (!TREE_CONSTANT (elt_init))
5317 TREE_CONSTANT (new_init) = false;
5319 /* This can happen with an invalid initializer (c++/54501). */
5320 if (d->cur == old_cur && !sized_array_p)
5321 break;
5324 return new_init;
5327 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5328 Parameters are the same of reshape_init_r. */
5330 static tree
5331 reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain)
5333 tree max_index = NULL_TREE;
5335 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
5337 if (TYPE_DOMAIN (type))
5338 max_index = array_type_nelts (type);
5340 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5343 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5344 Parameters are the same of reshape_init_r. */
5346 static tree
5347 reshape_init_vector (tree type, reshape_iter *d, tsubst_flags_t complain)
5349 tree max_index = NULL_TREE;
5351 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
5353 if (COMPOUND_LITERAL_P (d->cur->value))
5355 tree value = d->cur->value;
5356 if (!same_type_p (TREE_TYPE (value), type))
5358 if (complain & tf_error)
5359 error ("invalid type %qT as initializer for a vector of type %qT",
5360 TREE_TYPE (d->cur->value), type);
5361 value = error_mark_node;
5363 ++d->cur;
5364 return value;
5367 /* For a vector, we initialize it as an array of the appropriate size. */
5368 if (TREE_CODE (type) == VECTOR_TYPE)
5369 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1);
5371 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5374 /* Subroutine of reshape_init_r, processes the initializers for classes
5375 or union. Parameters are the same of reshape_init_r. */
5377 static tree
5378 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
5379 tsubst_flags_t complain)
5381 tree field;
5382 tree new_init;
5384 gcc_assert (CLASS_TYPE_P (type));
5386 /* The initializer for a class is always a CONSTRUCTOR. */
5387 new_init = build_constructor (init_list_type_node, NULL);
5388 field = next_initializable_field (TYPE_FIELDS (type));
5390 if (!field)
5392 /* [dcl.init.aggr]
5394 An initializer for an aggregate member that is an
5395 empty class shall have the form of an empty
5396 initializer-list {}. */
5397 if (!first_initializer_p)
5399 if (complain & tf_error)
5400 error ("initializer for %qT must be brace-enclosed", type);
5401 return error_mark_node;
5403 return new_init;
5406 /* Loop through the initializable fields, gathering initializers. */
5407 while (d->cur != d->end)
5409 tree field_init;
5410 constructor_elt *old_cur = d->cur;
5412 /* Handle designated initializers, as an extension. */
5413 if (d->cur->index)
5415 if (d->cur->index == error_mark_node)
5416 return error_mark_node;
5418 if (TREE_CODE (d->cur->index) == FIELD_DECL)
5419 /* We already reshaped this. */
5420 gcc_assert (d->cur->index == field);
5421 else if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
5422 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
5423 else
5425 if (complain & tf_error)
5426 error ("%<[%E] =%> used in a GNU-style designated initializer"
5427 " for class %qT", d->cur->index, type);
5428 return error_mark_node;
5431 if (!field || TREE_CODE (field) != FIELD_DECL)
5433 if (complain & tf_error)
5434 error ("%qT has no non-static data member named %qD", type,
5435 d->cur->index);
5436 return error_mark_node;
5440 /* If we processed all the member of the class, we are done. */
5441 if (!field)
5442 break;
5444 field_init = reshape_init_r (TREE_TYPE (field), d,
5445 /*first_initializer_p=*/false, complain);
5446 if (field_init == error_mark_node)
5447 return error_mark_node;
5449 if (d->cur == old_cur && d->cur->index)
5451 /* This can happen with an invalid initializer for a flexible
5452 array member (c++/54441). */
5453 if (complain & tf_error)
5454 error ("invalid initializer for %q#D", field);
5455 return error_mark_node;
5458 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
5460 /* [dcl.init.aggr]
5462 When a union is initialized with a brace-enclosed
5463 initializer, the braces shall only contain an
5464 initializer for the first member of the union. */
5465 if (TREE_CODE (type) == UNION_TYPE)
5466 break;
5468 field = next_initializable_field (DECL_CHAIN (field));
5471 return new_init;
5474 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5475 designators are not valid; either complain or return true to indicate
5476 that reshape_init_r should return error_mark_node. */
5478 static bool
5479 has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
5481 if (d->cur->index)
5483 if (complain & tf_error)
5484 error ("C99 designator %qE outside aggregate initializer",
5485 d->cur->index);
5486 else
5487 return true;
5489 return false;
5492 /* Subroutine of reshape_init, which processes a single initializer (part of
5493 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5494 iterator within the CONSTRUCTOR which points to the initializer to process.
5495 FIRST_INITIALIZER_P is true if this is the first initializer of the
5496 outermost CONSTRUCTOR node. */
5498 static tree
5499 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
5500 tsubst_flags_t complain)
5502 tree init = d->cur->value;
5504 if (error_operand_p (init))
5505 return error_mark_node;
5507 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
5508 && has_designator_problem (d, complain))
5509 return error_mark_node;
5511 if (TREE_CODE (type) == COMPLEX_TYPE)
5513 /* A complex type can be initialized from one or two initializers,
5514 but braces are not elided. */
5515 d->cur++;
5516 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5518 if (CONSTRUCTOR_NELTS (init) > 2)
5520 if (complain & tf_error)
5521 error ("too many initializers for %qT", type);
5522 else
5523 return error_mark_node;
5526 else if (first_initializer_p && d->cur != d->end)
5528 vec<constructor_elt, va_gc> *v = 0;
5529 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
5530 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
5531 if (has_designator_problem (d, complain))
5532 return error_mark_node;
5533 d->cur++;
5534 init = build_constructor (init_list_type_node, v);
5536 return init;
5539 /* A non-aggregate type is always initialized with a single
5540 initializer. */
5541 if (!CP_AGGREGATE_TYPE_P (type))
5543 /* It is invalid to initialize a non-aggregate type with a
5544 brace-enclosed initializer before C++0x.
5545 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5546 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5547 a CONSTRUCTOR (with a record type). */
5548 if (TREE_CODE (init) == CONSTRUCTOR
5549 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
5551 if (SCALAR_TYPE_P (type))
5553 if (cxx_dialect < cxx11
5554 /* Isn't value-initialization. */
5555 || CONSTRUCTOR_NELTS (init) > 0)
5557 if (complain & tf_error)
5558 error ("braces around scalar initializer for type %qT",
5559 type);
5560 init = error_mark_node;
5563 else
5564 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5567 d->cur++;
5568 return init;
5571 /* "If T is a class type and the initializer list has a single element of
5572 type cv U, where U is T or a class derived from T, the object is
5573 initialized from that element." Even if T is an aggregate. */
5574 if (cxx_dialect >= cxx11 && (CLASS_TYPE_P (type) || VECTOR_TYPE_P (type))
5575 && first_initializer_p
5576 && d->end - d->cur == 1
5577 && reference_related_p (type, TREE_TYPE (init)))
5579 d->cur++;
5580 return init;
5583 /* [dcl.init.aggr]
5585 All implicit type conversions (clause _conv_) are considered when
5586 initializing the aggregate member with an initializer from an
5587 initializer-list. If the initializer can initialize a member,
5588 the member is initialized. Otherwise, if the member is itself a
5589 non-empty subaggregate, brace elision is assumed and the
5590 initializer is considered for the initialization of the first
5591 member of the subaggregate. */
5592 if (TREE_CODE (init) != CONSTRUCTOR
5593 /* But don't try this for the first initializer, since that would be
5594 looking through the outermost braces; A a2 = { a1 }; is not a
5595 valid aggregate initialization. */
5596 && !first_initializer_p
5597 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
5598 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL,
5599 complain)))
5601 d->cur++;
5602 return init;
5605 /* [dcl.init.string]
5607 A char array (whether plain char, signed char, or unsigned char)
5608 can be initialized by a string-literal (optionally enclosed in
5609 braces); a wchar_t array can be initialized by a wide
5610 string-literal (optionally enclosed in braces). */
5611 if (TREE_CODE (type) == ARRAY_TYPE
5612 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
5614 tree str_init = init;
5616 /* Strip one level of braces if and only if they enclose a single
5617 element (as allowed by [dcl.init.string]). */
5618 if (!first_initializer_p
5619 && TREE_CODE (str_init) == CONSTRUCTOR
5620 && vec_safe_length (CONSTRUCTOR_ELTS (str_init)) == 1)
5622 str_init = (*CONSTRUCTOR_ELTS (str_init))[0].value;
5625 /* If it's a string literal, then it's the initializer for the array
5626 as a whole. Otherwise, continue with normal initialization for
5627 array types (one value per array element). */
5628 if (TREE_CODE (str_init) == STRING_CST)
5630 if (has_designator_problem (d, complain))
5631 return error_mark_node;
5632 d->cur++;
5633 return str_init;
5637 /* The following cases are about aggregates. If we are not within a full
5638 initializer already, and there is not a CONSTRUCTOR, it means that there
5639 is a missing set of braces (that is, we are processing the case for
5640 which reshape_init exists). */
5641 if (!first_initializer_p)
5643 if (TREE_CODE (init) == CONSTRUCTOR)
5645 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
5646 /* There is no need to reshape pointer-to-member function
5647 initializers, as they are always constructed correctly
5648 by the front end. */
5650 else if (COMPOUND_LITERAL_P (init))
5651 /* For a nested compound literal, there is no need to reshape since
5652 brace elision is not allowed. Even if we decided to allow it,
5653 we should add a call to reshape_init in finish_compound_literal,
5654 before calling digest_init, so changing this code would still
5655 not be necessary. */
5656 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
5657 else
5659 ++d->cur;
5660 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5661 return reshape_init (type, init, complain);
5665 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
5666 type);
5669 /* Dispatch to specialized routines. */
5670 if (CLASS_TYPE_P (type))
5671 return reshape_init_class (type, d, first_initializer_p, complain);
5672 else if (TREE_CODE (type) == ARRAY_TYPE)
5673 return reshape_init_array (type, d, complain);
5674 else if (TREE_CODE (type) == VECTOR_TYPE)
5675 return reshape_init_vector (type, d, complain);
5676 else
5677 gcc_unreachable();
5680 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5681 brace-enclosed aggregate initializer.
5683 INIT is the CONSTRUCTOR containing the list of initializers describing
5684 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5685 It may not presently match the shape of the TYPE; for example:
5687 struct S { int a; int b; };
5688 struct S a[] = { 1, 2, 3, 4 };
5690 Here INIT will hold a vector of four elements, rather than a
5691 vector of two elements, each itself a vector of two elements. This
5692 routine transforms INIT from the former form into the latter. The
5693 revised CONSTRUCTOR node is returned. */
5695 tree
5696 reshape_init (tree type, tree init, tsubst_flags_t complain)
5698 vec<constructor_elt, va_gc> *v;
5699 reshape_iter d;
5700 tree new_init;
5702 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5704 v = CONSTRUCTOR_ELTS (init);
5706 /* An empty constructor does not need reshaping, and it is always a valid
5707 initializer. */
5708 if (vec_safe_is_empty (v))
5709 return init;
5711 /* Recurse on this CONSTRUCTOR. */
5712 d.cur = &(*v)[0];
5713 d.end = d.cur + v->length ();
5715 new_init = reshape_init_r (type, &d, true, complain);
5716 if (new_init == error_mark_node)
5717 return error_mark_node;
5719 /* Make sure all the element of the constructor were used. Otherwise,
5720 issue an error about exceeding initializers. */
5721 if (d.cur != d.end)
5723 if (complain & tf_error)
5724 error ("too many initializers for %qT", type);
5725 else
5726 return error_mark_node;
5729 return new_init;
5732 /* Verify array initializer. Returns true if errors have been reported. */
5734 bool
5735 check_array_initializer (tree decl, tree type, tree init)
5737 tree element_type = TREE_TYPE (type);
5739 /* The array type itself need not be complete, because the
5740 initializer may tell us how many elements are in the array.
5741 But, the elements of the array must be complete. */
5742 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5744 if (decl)
5745 error ("elements of array %q#D have incomplete type", decl);
5746 else
5747 error ("elements of array %q#T have incomplete type", type);
5748 return true;
5750 /* A compound literal can't have variable size. */
5751 if (init && !decl
5752 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5753 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5755 error ("variable-sized compound literal");
5756 return true;
5758 return false;
5761 /* Subroutine of check_initializer; args are passed down from that function.
5762 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5764 static tree
5765 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5768 gcc_assert (stmts_are_full_exprs_p ());
5769 return build_aggr_init (decl, init, flags, tf_warning_or_error);
5772 /* Verify INIT (the initializer for DECL), and record the
5773 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5774 grok_reference_init.
5776 If the return value is non-NULL, it is an expression that must be
5777 evaluated dynamically to initialize DECL. */
5779 static tree
5780 check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups)
5782 tree type = TREE_TYPE (decl);
5783 tree init_code = NULL;
5784 tree core_type;
5786 /* Things that are going to be initialized need to have complete
5787 type. */
5788 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5790 if (DECL_HAS_VALUE_EXPR_P (decl))
5792 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5793 it doesn't have storage to be initialized. */
5794 gcc_assert (init == NULL_TREE);
5795 return NULL_TREE;
5798 if (type == error_mark_node)
5799 /* We will have already complained. */
5800 return NULL_TREE;
5802 if (TREE_CODE (type) == ARRAY_TYPE)
5804 if (check_array_initializer (decl, type, init))
5805 return NULL_TREE;
5807 else if (!COMPLETE_TYPE_P (type))
5809 error ("%q#D has incomplete type", decl);
5810 TREE_TYPE (decl) = error_mark_node;
5811 return NULL_TREE;
5813 else
5814 /* There is no way to make a variable-sized class type in GNU C++. */
5815 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5817 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5819 int init_len = vec_safe_length (CONSTRUCTOR_ELTS (init));
5820 if (SCALAR_TYPE_P (type))
5822 if (init_len == 0)
5824 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5825 init = build_zero_init (type, NULL_TREE, false);
5827 else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
5829 error ("scalar object %qD requires one element in initializer",
5830 decl);
5831 TREE_TYPE (decl) = error_mark_node;
5832 return NULL_TREE;
5837 if (TREE_CODE (decl) == CONST_DECL)
5839 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5841 DECL_INITIAL (decl) = init;
5843 gcc_assert (init != NULL_TREE);
5844 init = NULL_TREE;
5846 else if (!init && DECL_REALLY_EXTERN (decl))
5848 else if (init || type_build_ctor_call (type)
5849 || TREE_CODE (type) == REFERENCE_TYPE)
5851 if (TREE_CODE (type) == REFERENCE_TYPE)
5853 init = grok_reference_init (decl, type, init, flags);
5854 flags |= LOOKUP_ALREADY_DIGESTED;
5856 else if (!init)
5857 check_for_uninitialized_const_var (decl);
5858 /* Do not reshape constructors of vectors (they don't need to be
5859 reshaped. */
5860 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
5862 if (is_std_init_list (type))
5864 init = perform_implicit_conversion (type, init,
5865 tf_warning_or_error);
5866 flags |= LOOKUP_ALREADY_DIGESTED;
5868 else if (TYPE_NON_AGGREGATE_CLASS (type))
5870 /* Don't reshape if the class has constructors. */
5871 if (cxx_dialect == cxx98)
5872 error ("in C++98 %qD must be initialized by constructor, "
5873 "not by %<{...}%>",
5874 decl);
5876 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5878 error ("opaque vector types cannot be initialized");
5879 init = error_mark_node;
5881 else
5883 init = reshape_init (type, init, tf_warning_or_error);
5884 flags |= LOOKUP_NO_NARROWING;
5887 else if (TREE_CODE (init) == TREE_LIST
5888 && TREE_TYPE (init) != unknown_type_node
5889 && !MAYBE_CLASS_TYPE_P (type))
5891 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5893 /* We get here with code like `int a (2);' */
5894 init = build_x_compound_expr_from_list (init, ELK_INIT,
5895 tf_warning_or_error);
5898 /* If DECL has an array type without a specific bound, deduce the
5899 array size from the initializer. */
5900 maybe_deduce_size_from_array_init (decl, init);
5901 type = TREE_TYPE (decl);
5902 if (type == error_mark_node)
5903 return NULL_TREE;
5905 if ((type_build_ctor_call (type) || CLASS_TYPE_P (type))
5906 && !(flags & LOOKUP_ALREADY_DIGESTED)
5907 && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
5908 && CP_AGGREGATE_TYPE_P (type)
5909 && (CLASS_TYPE_P (type)
5910 || !TYPE_NEEDS_CONSTRUCTING (type)
5911 || type_has_extended_temps (type))))
5913 init_code = build_aggr_init_full_exprs (decl, init, flags);
5915 /* A constructor call is a non-trivial initializer even if
5916 it isn't explicitly written. */
5917 if (TREE_SIDE_EFFECTS (init_code))
5918 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = true;
5920 /* If this is a constexpr initializer, expand_default_init will
5921 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5922 case, pull the initializer back out and pass it down into
5923 store_init_value. */
5924 while (TREE_CODE (init_code) == EXPR_STMT
5925 || TREE_CODE (init_code) == CONVERT_EXPR)
5926 init_code = TREE_OPERAND (init_code, 0);
5927 if (TREE_CODE (init_code) == INIT_EXPR)
5929 init = TREE_OPERAND (init_code, 1);
5930 init_code = NULL_TREE;
5931 /* Don't call digest_init; it's unnecessary and will complain
5932 about aggregate initialization of non-aggregate classes. */
5933 flags |= LOOKUP_ALREADY_DIGESTED;
5935 else if (DECL_DECLARED_CONSTEXPR_P (decl))
5937 /* Declared constexpr, but no suitable initializer; massage
5938 init appropriately so we can pass it into store_init_value
5939 for the error. */
5940 if (CLASS_TYPE_P (type)
5941 && (!init || TREE_CODE (init) == TREE_LIST))
5943 init = build_functional_cast (type, init, tf_none);
5944 if (TREE_CODE (init) == TARGET_EXPR)
5945 TARGET_EXPR_DIRECT_INIT_P (init) = true;
5947 init_code = NULL_TREE;
5949 else
5950 init = NULL_TREE;
5953 if (init && TREE_CODE (init) != TREE_VEC)
5955 /* In aggregate initialization of a variable, each element
5956 initialization is a full-expression because there is no
5957 enclosing expression. */
5958 gcc_assert (stmts_are_full_exprs_p ());
5960 init_code = store_init_value (decl, init, cleanups, flags);
5962 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5963 && DECL_INITIAL (decl)
5964 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5965 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5966 warning (0, "array %qD initialized by parenthesized string literal %qE",
5967 decl, DECL_INITIAL (decl));
5968 init = NULL;
5971 else
5973 if (CLASS_TYPE_P (core_type = strip_array_types (type))
5974 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
5975 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
5976 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
5977 /*complain=*/true);
5979 check_for_uninitialized_const_var (decl);
5982 if (init && init != error_mark_node)
5983 init_code = build2 (INIT_EXPR, type, decl, init);
5985 if (init_code)
5987 /* We might have set these in cp_finish_decl. */
5988 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = false;
5989 TREE_CONSTANT (decl) = false;
5992 if (init_code && DECL_IN_AGGR_P (decl))
5994 static int explained = 0;
5996 if (cxx_dialect < cxx11)
5997 error ("initializer invalid for static member with constructor");
5998 else
5999 error ("non-constant in-class initialization invalid for static "
6000 "member %qD", decl);
6001 if (!explained)
6003 inform (input_location,
6004 "(an out of class initialization is required)");
6005 explained = 1;
6007 return NULL_TREE;
6010 return init_code;
6013 /* If DECL is not a local variable, give it RTL. */
6015 static void
6016 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
6018 int toplev = toplevel_bindings_p ();
6019 int defer_p;
6020 const char *filename;
6022 /* Set the DECL_ASSEMBLER_NAME for the object. */
6023 if (asmspec)
6025 /* The `register' keyword, when used together with an
6026 asm-specification, indicates that the variable should be
6027 placed in a particular register. */
6028 if (VAR_P (decl) && DECL_REGISTER (decl))
6030 set_user_assembler_name (decl, asmspec);
6031 DECL_HARD_REGISTER (decl) = 1;
6033 else
6035 if (TREE_CODE (decl) == FUNCTION_DECL
6036 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
6037 set_builtin_user_assembler_name (decl, asmspec);
6038 set_user_assembler_name (decl, asmspec);
6042 /* Handle non-variables up front. */
6043 if (!VAR_P (decl))
6045 rest_of_decl_compilation (decl, toplev, at_eof);
6046 return;
6049 /* If we see a class member here, it should be a static data
6050 member. */
6051 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
6053 gcc_assert (TREE_STATIC (decl));
6054 /* An in-class declaration of a static data member should be
6055 external; it is only a declaration, and not a definition. */
6056 if (init == NULL_TREE)
6057 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
6060 /* We don't create any RTL for local variables. */
6061 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6062 return;
6064 /* We defer emission of local statics until the corresponding
6065 DECL_EXPR is expanded. */
6066 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
6068 /* We try to defer namespace-scope static constants so that they are
6069 not emitted into the object file unnecessarily. */
6070 filename = LOCATION_FILE (input_location);
6071 if (!DECL_VIRTUAL_P (decl)
6072 && TREE_READONLY (decl)
6073 && DECL_INITIAL (decl) != NULL_TREE
6074 && DECL_INITIAL (decl) != error_mark_node
6075 && filename != NULL
6076 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
6077 && toplev
6078 && !TREE_PUBLIC (decl))
6080 /* Fool with the linkage of static consts according to #pragma
6081 interface. */
6082 struct c_fileinfo *finfo = get_fileinfo (filename);
6083 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
6085 TREE_PUBLIC (decl) = 1;
6086 DECL_EXTERNAL (decl) = finfo->interface_only;
6089 defer_p = 1;
6091 /* Likewise for template instantiations. */
6092 else if (DECL_LANG_SPECIFIC (decl)
6093 && DECL_IMPLICIT_INSTANTIATION (decl))
6094 defer_p = 1;
6096 /* If we're not deferring, go ahead and assemble the variable. */
6097 if (!defer_p)
6098 rest_of_decl_compilation (decl, toplev, at_eof);
6101 /* walk_tree helper for wrap_temporary_cleanups, below. */
6103 static tree
6104 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
6106 /* Stop at types or full-expression boundaries. */
6107 if (TYPE_P (*stmt_p)
6108 || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR)
6110 *walk_subtrees = 0;
6111 return NULL_TREE;
6114 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
6116 tree guard = (tree)data;
6117 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
6119 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
6120 /* Tell honor_protect_cleanup_actions to handle this as a separate
6121 cleanup. */
6122 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
6124 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
6127 return NULL_TREE;
6130 /* We're initializing a local variable which has a cleanup GUARD. If there
6131 are any temporaries used in the initializer INIT of this variable, we
6132 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6133 variable will be cleaned up properly if one of them throws.
6135 Unfortunately, there's no way to express this properly in terms of
6136 nesting, as the regions for the temporaries overlap the region for the
6137 variable itself; if there are two temporaries, the variable needs to be
6138 the first thing destroyed if either of them throws. However, we only
6139 want to run the variable's cleanup if it actually got constructed. So
6140 we need to guard the temporary cleanups with the variable's cleanup if
6141 they are run on the normal path, but not if they are run on the
6142 exceptional path. We implement this by telling
6143 honor_protect_cleanup_actions to strip the variable cleanup from the
6144 exceptional path. */
6146 static void
6147 wrap_temporary_cleanups (tree init, tree guard)
6149 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
6152 /* Generate code to initialize DECL (a local variable). */
6154 static void
6155 initialize_local_var (tree decl, tree init)
6157 tree type = TREE_TYPE (decl);
6158 tree cleanup;
6159 int already_used;
6161 gcc_assert (VAR_P (decl)
6162 || TREE_CODE (decl) == RESULT_DECL);
6163 gcc_assert (!TREE_STATIC (decl));
6165 if (DECL_SIZE (decl) == NULL_TREE)
6167 /* If we used it already as memory, it must stay in memory. */
6168 DECL_INITIAL (decl) = NULL_TREE;
6169 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
6170 return;
6173 if (type == error_mark_node)
6174 return;
6176 /* Compute and store the initial value. */
6177 already_used = TREE_USED (decl) || TREE_USED (type);
6178 if (TREE_USED (type))
6179 DECL_READ_P (decl) = 1;
6181 /* Generate a cleanup, if necessary. */
6182 cleanup = cxx_maybe_build_cleanup (decl, tf_warning_or_error);
6184 /* Perform the initialization. */
6185 if (init)
6187 tree rinit = (TREE_CODE (init) == INIT_EXPR
6188 ? TREE_OPERAND (init, 1) : NULL_TREE);
6189 if (rinit && !TREE_SIDE_EFFECTS (rinit))
6191 /* Stick simple initializers in DECL_INITIAL so that
6192 -Wno-init-self works (c++/34772). */
6193 gcc_assert (TREE_OPERAND (init, 0) == decl);
6194 DECL_INITIAL (decl) = rinit;
6196 if (warn_init_self && TREE_CODE (type) == REFERENCE_TYPE)
6198 STRIP_NOPS (rinit);
6199 if (rinit == decl)
6200 warning_at (DECL_SOURCE_LOCATION (decl),
6201 OPT_Winit_self,
6202 "reference %qD is initialized with itself", decl);
6205 else
6207 int saved_stmts_are_full_exprs_p;
6209 /* If we're only initializing a single object, guard the
6210 destructors of any temporaries used in its initializer with
6211 its destructor. This isn't right for arrays because each
6212 element initialization is a full-expression. */
6213 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
6214 wrap_temporary_cleanups (init, cleanup);
6216 gcc_assert (building_stmt_list_p ());
6217 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
6218 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
6219 finish_expr_stmt (init);
6220 current_stmt_tree ()->stmts_are_full_exprs_p =
6221 saved_stmts_are_full_exprs_p;
6225 /* Set this to 0 so we can tell whether an aggregate which was
6226 initialized was ever used. Don't do this if it has a
6227 destructor, so we don't complain about the 'resource
6228 allocation is initialization' idiom. Now set
6229 attribute((unused)) on types so decls of that type will be
6230 marked used. (see TREE_USED, above.) */
6231 if (TYPE_NEEDS_CONSTRUCTING (type)
6232 && ! already_used
6233 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
6234 && DECL_NAME (decl))
6235 TREE_USED (decl) = 0;
6236 else if (already_used)
6237 TREE_USED (decl) = 1;
6239 if (cleanup)
6240 finish_decl_cleanup (decl, cleanup);
6243 /* DECL is a VAR_DECL for a compiler-generated variable with static
6244 storage duration (like a virtual table) whose initializer is a
6245 compile-time constant. Initialize the variable and provide it to the
6246 back end. */
6248 void
6249 initialize_artificial_var (tree decl, vec<constructor_elt, va_gc> *v)
6251 tree init;
6252 gcc_assert (DECL_ARTIFICIAL (decl));
6253 init = build_constructor (TREE_TYPE (decl), v);
6254 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
6255 DECL_INITIAL (decl) = init;
6256 DECL_INITIALIZED_P (decl) = 1;
6257 determine_visibility (decl);
6258 layout_var_decl (decl);
6259 maybe_commonize_var (decl);
6260 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
6263 /* INIT is the initializer for a variable, as represented by the
6264 parser. Returns true iff INIT is type-dependent. */
6266 static bool
6267 type_dependent_init_p (tree init)
6269 if (TREE_CODE (init) == TREE_LIST)
6270 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6271 return any_type_dependent_elements_p (init);
6272 else if (TREE_CODE (init) == CONSTRUCTOR)
6273 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6275 vec<constructor_elt, va_gc> *elts;
6276 size_t nelts;
6277 size_t i;
6279 elts = CONSTRUCTOR_ELTS (init);
6280 nelts = vec_safe_length (elts);
6281 for (i = 0; i < nelts; ++i)
6282 if (type_dependent_init_p ((*elts)[i].value))
6283 return true;
6285 else
6286 /* It must be a simple expression, e.g., int i = 3; */
6287 return type_dependent_expression_p (init);
6289 return false;
6292 /* INIT is the initializer for a variable, as represented by the
6293 parser. Returns true iff INIT is value-dependent. */
6295 static bool
6296 value_dependent_init_p (tree init)
6298 if (TREE_CODE (init) == TREE_LIST)
6299 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6300 return any_value_dependent_elements_p (init);
6301 else if (TREE_CODE (init) == CONSTRUCTOR)
6302 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6304 vec<constructor_elt, va_gc> *elts;
6305 size_t nelts;
6306 size_t i;
6308 elts = CONSTRUCTOR_ELTS (init);
6309 nelts = vec_safe_length (elts);
6310 for (i = 0; i < nelts; ++i)
6311 if (value_dependent_init_p ((*elts)[i].value))
6312 return true;
6314 else
6315 /* It must be a simple expression, e.g., int i = 3; */
6316 return value_dependent_expression_p (init);
6318 return false;
6321 /* Finish processing of a declaration;
6322 install its line number and initial value.
6323 If the length of an array type is not known before,
6324 it must be determined now, from the initial value, or it is an error.
6326 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6327 true, then INIT is an integral constant expression.
6329 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6330 if the (init) syntax was used. */
6332 void
6333 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
6334 tree asmspec_tree, int flags)
6336 tree type;
6337 vec<tree, va_gc> *cleanups = NULL;
6338 const char *asmspec = NULL;
6339 int was_readonly = 0;
6340 bool var_definition_p = false;
6341 tree auto_node;
6343 if (decl == error_mark_node)
6344 return;
6345 else if (! decl)
6347 if (init)
6348 error ("assignment (not initialization) in declaration");
6349 return;
6352 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
6353 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6354 gcc_assert (TREE_CODE (decl) != PARM_DECL);
6356 type = TREE_TYPE (decl);
6357 if (type == error_mark_node)
6358 return;
6360 /* If a name was specified, get the string. */
6361 if (at_namespace_scope_p ())
6362 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
6363 if (asmspec_tree && asmspec_tree != error_mark_node)
6364 asmspec = TREE_STRING_POINTER (asmspec_tree);
6366 if (current_class_type
6367 && CP_DECL_CONTEXT (decl) == current_class_type
6368 && TYPE_BEING_DEFINED (current_class_type)
6369 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type)
6370 && (DECL_INITIAL (decl) || init))
6371 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
6373 if (TREE_CODE (decl) != FUNCTION_DECL
6374 && (auto_node = type_uses_auto (type)))
6376 tree d_init;
6377 if (init == NULL_TREE)
6379 if (DECL_LANG_SPECIFIC (decl)
6380 && DECL_TEMPLATE_INSTANTIATION (decl)
6381 && !DECL_TEMPLATE_INSTANTIATED (decl))
6383 /* init is null because we're deferring instantiating the
6384 initializer until we need it. Well, we need it now. */
6385 instantiate_decl (decl, /*defer_ok*/true, /*expl*/false);
6386 return;
6389 error ("declaration of %q#D has no initializer", decl);
6390 TREE_TYPE (decl) = error_mark_node;
6391 return;
6393 d_init = init;
6394 if (TREE_CODE (d_init) == TREE_LIST)
6395 d_init = build_x_compound_expr_from_list (d_init, ELK_INIT,
6396 tf_warning_or_error);
6397 d_init = resolve_nondeduced_context (d_init);
6398 type = TREE_TYPE (decl) = do_auto_deduction (type, d_init,
6399 auto_node);
6400 if (type == error_mark_node)
6401 return;
6402 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
6405 if (!ensure_literal_type_for_constexpr_object (decl))
6406 DECL_DECLARED_CONSTEXPR_P (decl) = 0;
6408 if (VAR_P (decl)
6409 && DECL_CLASS_SCOPE_P (decl)
6410 && DECL_INITIALIZED_IN_CLASS_P (decl))
6411 check_static_variable_definition (decl, type);
6413 if (init && TREE_CODE (decl) == FUNCTION_DECL)
6415 tree clone;
6416 if (init == ridpointers[(int)RID_DELETE])
6418 /* FIXME check this is 1st decl. */
6419 DECL_DELETED_FN (decl) = 1;
6420 DECL_DECLARED_INLINE_P (decl) = 1;
6421 DECL_INITIAL (decl) = error_mark_node;
6422 FOR_EACH_CLONE (clone, decl)
6424 DECL_DELETED_FN (clone) = 1;
6425 DECL_DECLARED_INLINE_P (clone) = 1;
6426 DECL_INITIAL (clone) = error_mark_node;
6428 init = NULL_TREE;
6430 else if (init == ridpointers[(int)RID_DEFAULT])
6432 if (defaultable_fn_check (decl))
6433 DECL_DEFAULTED_FN (decl) = 1;
6434 else
6435 DECL_INITIAL (decl) = NULL_TREE;
6439 if (init && VAR_P (decl))
6441 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
6442 /* If DECL is a reference, then we want to know whether init is a
6443 reference constant; init_const_expr_p as passed tells us whether
6444 it's an rvalue constant. */
6445 if (TREE_CODE (type) == REFERENCE_TYPE)
6446 init_const_expr_p = potential_constant_expression (init);
6447 if (init_const_expr_p)
6449 /* Set these flags now for templates. We'll update the flags in
6450 store_init_value for instantiations. */
6451 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
6452 if (decl_maybe_constant_var_p (decl))
6453 TREE_CONSTANT (decl) = 1;
6457 if (processing_template_decl)
6459 bool type_dependent_p;
6461 /* Add this declaration to the statement-tree. */
6462 if (at_function_scope_p ())
6463 add_decl_expr (decl);
6465 type_dependent_p = dependent_type_p (type);
6467 if (check_for_bare_parameter_packs (init))
6469 init = NULL_TREE;
6470 DECL_INITIAL (decl) = NULL_TREE;
6473 /* Generally, initializers in templates are expanded when the
6474 template is instantiated. But, if DECL is a variable constant
6475 then it can be used in future constant expressions, so its value
6476 must be available. */
6478 if (!VAR_P (decl) || dependent_type_p (type))
6479 /* We can't do anything if the decl has dependent type. */;
6480 else if (init
6481 && init_const_expr_p
6482 && !type_dependent_p
6483 && TREE_CODE (type) != REFERENCE_TYPE
6484 && decl_maybe_constant_var_p (decl)
6485 && !type_dependent_init_p (init)
6486 && !value_dependent_init_p (init))
6488 /* This variable seems to be a non-dependent constant, so process
6489 its initializer. If check_initializer returns non-null the
6490 initialization wasn't constant after all. */
6491 tree init_code;
6492 cleanups = make_tree_vector ();
6493 init_code = check_initializer (decl, init, flags, &cleanups);
6494 if (init_code == NULL_TREE)
6495 init = NULL_TREE;
6496 release_tree_vector (cleanups);
6498 else if (!DECL_PRETTY_FUNCTION_P (decl))
6500 /* Deduce array size even if the initializer is dependent. */
6501 maybe_deduce_size_from_array_init (decl, init);
6502 /* And complain about multiple initializers. */
6503 if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init)
6504 && !MAYBE_CLASS_TYPE_P (type))
6505 init = build_x_compound_expr_from_list (init, ELK_INIT,
6506 tf_warning_or_error);
6509 if (init)
6510 DECL_INITIAL (decl) = init;
6511 return;
6514 /* Just store non-static data member initializers for later. */
6515 if (init && TREE_CODE (decl) == FIELD_DECL)
6516 DECL_INITIAL (decl) = init;
6518 /* Take care of TYPE_DECLs up front. */
6519 if (TREE_CODE (decl) == TYPE_DECL)
6521 if (type != error_mark_node
6522 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
6524 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
6525 warning (0, "shadowing previous type declaration of %q#D", decl);
6526 set_identifier_type_value (DECL_NAME (decl), decl);
6529 /* If we have installed this as the canonical typedef for this
6530 type, and that type has not been defined yet, delay emitting
6531 the debug information for it, as we will emit it later. */
6532 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
6533 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
6534 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
6536 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl),
6537 at_eof);
6538 return;
6541 /* A reference will be modified here, as it is initialized. */
6542 if (! DECL_EXTERNAL (decl)
6543 && TREE_READONLY (decl)
6544 && TREE_CODE (type) == REFERENCE_TYPE)
6546 was_readonly = 1;
6547 TREE_READONLY (decl) = 0;
6550 if (VAR_P (decl))
6552 /* If this is a local variable that will need a mangled name,
6553 register it now. We must do this before processing the
6554 initializer for the variable, since the initialization might
6555 require a guard variable, and since the mangled name of the
6556 guard variable will depend on the mangled name of this
6557 variable. */
6558 if (DECL_FUNCTION_SCOPE_P (decl)
6559 && TREE_STATIC (decl)
6560 && !DECL_ARTIFICIAL (decl))
6562 push_local_name (decl);
6563 if (DECL_CONSTRUCTOR_P (current_function_decl)
6564 || DECL_DESTRUCTOR_P (current_function_decl))
6565 /* Normally local_decls is populated during GIMPLE lowering,
6566 but [cd]tors are never actually compiled directly. We need
6567 to put statics on the list so we can deal with the label
6568 address extension. FIXME. */
6569 add_local_decl (cfun, decl);
6572 /* Convert the initializer to the type of DECL, if we have not
6573 already initialized DECL. */
6574 if (!DECL_INITIALIZED_P (decl)
6575 /* If !DECL_EXTERNAL then DECL is being defined. In the
6576 case of a static data member initialized inside the
6577 class-specifier, there can be an initializer even if DECL
6578 is *not* defined. */
6579 && (!DECL_EXTERNAL (decl) || init))
6581 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6583 tree jclass
6584 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6585 /* Allow libjava/prims.cc define primitive classes. */
6586 if (init != NULL_TREE
6587 || jclass == NULL_TREE
6588 || TREE_CODE (jclass) != TYPE_DECL
6589 || !POINTER_TYPE_P (TREE_TYPE (jclass))
6590 || !same_type_ignoring_top_level_qualifiers_p
6591 (type, TREE_TYPE (TREE_TYPE (jclass))))
6592 error ("Java object %qD not allocated with %<new%>", decl);
6593 init = NULL_TREE;
6595 cleanups = make_tree_vector ();
6596 init = check_initializer (decl, init, flags, &cleanups);
6598 /* Handle:
6600 [dcl.init]
6602 The memory occupied by any object of static storage
6603 duration is zero-initialized at program startup before
6604 any other initialization takes place.
6606 We cannot create an appropriate initializer until after
6607 the type of DECL is finalized. If DECL_INITIAL is set,
6608 then the DECL is statically initialized, and any
6609 necessary zero-initialization has already been performed. */
6610 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
6611 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
6612 /*nelts=*/NULL_TREE,
6613 /*static_storage_p=*/true);
6614 /* Remember that the initialization for this variable has
6615 taken place. */
6616 DECL_INITIALIZED_P (decl) = 1;
6617 /* This declaration is the definition of this variable,
6618 unless we are initializing a static data member within
6619 the class specifier. */
6620 if (!DECL_EXTERNAL (decl))
6621 var_definition_p = true;
6623 /* If the variable has an array type, lay out the type, even if
6624 there is no initializer. It is valid to index through the
6625 array, and we must get TYPE_ALIGN set correctly on the array
6626 type. */
6627 else if (TREE_CODE (type) == ARRAY_TYPE)
6628 layout_type (type);
6630 if (TREE_STATIC (decl)
6631 && !at_function_scope_p ()
6632 && current_function_decl == NULL)
6633 /* So decl is a global variable or a static member of a
6634 non local class. Record the types it uses
6635 so that we can decide later to emit debug info for them. */
6636 record_types_used_by_current_var_decl (decl);
6638 else if (TREE_CODE (decl) == FIELD_DECL
6639 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
6640 error ("non-static data member %qD has Java class type", decl);
6642 /* Add this declaration to the statement-tree. This needs to happen
6643 after the call to check_initializer so that the DECL_EXPR for a
6644 reference temp is added before the DECL_EXPR for the reference itself. */
6645 if (DECL_FUNCTION_SCOPE_P (decl))
6647 /* If we're building a variable sized type, and we might be
6648 reachable other than via the top of the current binding
6649 level, then create a new BIND_EXPR so that we deallocate
6650 the object at the right time. */
6651 if (VAR_P (decl)
6652 && DECL_SIZE (decl)
6653 && !TREE_CONSTANT (DECL_SIZE (decl))
6654 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
6656 tree bind;
6657 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
6658 TREE_SIDE_EFFECTS (bind) = 1;
6659 add_stmt (bind);
6660 BIND_EXPR_BODY (bind) = push_stmt_list ();
6662 add_decl_expr (decl);
6665 /* Let the middle end know about variables and functions -- but not
6666 static data members in uninstantiated class templates. */
6667 if (VAR_OR_FUNCTION_DECL_P (decl))
6669 if (VAR_P (decl))
6671 layout_var_decl (decl);
6672 maybe_commonize_var (decl);
6675 /* This needs to happen after the linkage is set. */
6676 determine_visibility (decl);
6678 if (var_definition_p && TREE_STATIC (decl))
6680 /* If a TREE_READONLY variable needs initialization
6681 at runtime, it is no longer readonly and we need to
6682 avoid MEM_READONLY_P being set on RTL created for it. */
6683 if (init)
6685 if (TREE_READONLY (decl))
6686 TREE_READONLY (decl) = 0;
6687 was_readonly = 0;
6689 else if (was_readonly)
6690 TREE_READONLY (decl) = 1;
6692 /* Likewise if it needs destruction. */
6693 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
6694 TREE_READONLY (decl) = 0;
6697 make_rtl_for_nonlocal_decl (decl, init, asmspec);
6699 /* Check for abstractness of the type. Notice that there is no
6700 need to strip array types here since the check for those types
6701 is already done within create_array_type_for_decl. */
6702 abstract_virtuals_error (decl, type);
6704 if (TREE_TYPE (decl) == error_mark_node)
6705 /* No initialization required. */
6707 else if (TREE_CODE (decl) == FUNCTION_DECL)
6709 if (init)
6711 if (init == ridpointers[(int)RID_DEFAULT])
6713 /* An out-of-class default definition is defined at
6714 the point where it is explicitly defaulted. */
6715 if (DECL_DELETED_FN (decl))
6716 maybe_explain_implicit_delete (decl);
6717 else if (DECL_INITIAL (decl) == error_mark_node)
6718 synthesize_method (decl);
6720 else
6721 error ("function %q#D is initialized like a variable", decl);
6723 /* else no initialization required. */
6725 else if (DECL_EXTERNAL (decl)
6726 && ! (DECL_LANG_SPECIFIC (decl)
6727 && DECL_NOT_REALLY_EXTERN (decl)))
6729 if (init)
6730 DECL_INITIAL (decl) = init;
6732 /* A variable definition. */
6733 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6734 /* Initialize the local variable. */
6735 initialize_local_var (decl, init);
6737 /* If a variable is defined, and then a subsequent
6738 definition with external linkage is encountered, we will
6739 get here twice for the same variable. We want to avoid
6740 calling expand_static_init more than once. For variables
6741 that are not static data members, we can call
6742 expand_static_init only when we actually process the
6743 initializer. It is not legal to redeclare a static data
6744 member, so this issue does not arise in that case. */
6745 else if (var_definition_p && TREE_STATIC (decl))
6746 expand_static_init (decl, init);
6749 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6750 reference, insert it in the statement-tree now. */
6751 if (cleanups)
6753 unsigned i; tree t;
6754 FOR_EACH_VEC_ELT (*cleanups, i, t)
6755 push_cleanup (decl, t, false);
6756 release_tree_vector (cleanups);
6759 if (was_readonly)
6760 TREE_READONLY (decl) = 1;
6762 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
6765 /* Returns a declaration for a VAR_DECL as if:
6767 extern "C" TYPE NAME;
6769 had been seen. Used to create compiler-generated global
6770 variables. */
6772 static tree
6773 declare_global_var (tree name, tree type)
6775 tree decl;
6777 push_to_top_level ();
6778 decl = build_decl (input_location, VAR_DECL, name, type);
6779 TREE_PUBLIC (decl) = 1;
6780 DECL_EXTERNAL (decl) = 1;
6781 DECL_ARTIFICIAL (decl) = 1;
6782 /* If the user has explicitly declared this variable (perhaps
6783 because the code we are compiling is part of a low-level runtime
6784 library), then it is possible that our declaration will be merged
6785 with theirs by pushdecl. */
6786 decl = pushdecl (decl);
6787 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
6788 pop_from_top_level ();
6790 return decl;
6793 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6794 if "__cxa_atexit" is not being used) corresponding to the function
6795 to be called when the program exits. */
6797 static tree
6798 get_atexit_fn_ptr_type (void)
6800 tree fn_type;
6802 if (!atexit_fn_ptr_type_node)
6804 tree arg_type;
6805 if (flag_use_cxa_atexit
6806 && !targetm.cxx.use_atexit_for_cxa_atexit ())
6807 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6808 arg_type = ptr_type_node;
6809 else
6810 /* The parameter to "atexit" is "void (*)(void)". */
6811 arg_type = NULL_TREE;
6813 fn_type = build_function_type_list (void_type_node,
6814 arg_type, NULL_TREE);
6815 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
6818 return atexit_fn_ptr_type_node;
6821 /* Returns a pointer to the `atexit' function. Note that if
6822 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6823 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6825 static tree
6826 get_atexit_node (void)
6828 tree atexit_fndecl;
6829 tree fn_type;
6830 tree fn_ptr_type;
6831 const char *name;
6832 bool use_aeabi_atexit;
6834 if (atexit_node)
6835 return atexit_node;
6837 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6839 /* The declaration for `__cxa_atexit' is:
6841 int __cxa_atexit (void (*)(void *), void *, void *)
6843 We build up the argument types and then the function type
6844 itself. */
6845 tree argtype0, argtype1, argtype2;
6847 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
6848 /* First, build the pointer-to-function type for the first
6849 argument. */
6850 fn_ptr_type = get_atexit_fn_ptr_type ();
6851 /* Then, build the rest of the argument types. */
6852 argtype2 = ptr_type_node;
6853 if (use_aeabi_atexit)
6855 argtype1 = fn_ptr_type;
6856 argtype0 = ptr_type_node;
6858 else
6860 argtype1 = ptr_type_node;
6861 argtype0 = fn_ptr_type;
6863 /* And the final __cxa_atexit type. */
6864 fn_type = build_function_type_list (integer_type_node,
6865 argtype0, argtype1, argtype2,
6866 NULL_TREE);
6867 if (use_aeabi_atexit)
6868 name = "__aeabi_atexit";
6869 else
6870 name = "__cxa_atexit";
6872 else
6874 /* The declaration for `atexit' is:
6876 int atexit (void (*)());
6878 We build up the argument types and then the function type
6879 itself. */
6880 fn_ptr_type = get_atexit_fn_ptr_type ();
6881 /* Build the final atexit type. */
6882 fn_type = build_function_type_list (integer_type_node,
6883 fn_ptr_type, NULL_TREE);
6884 name = "atexit";
6887 /* Now, build the function declaration. */
6888 push_lang_context (lang_name_c);
6889 atexit_fndecl = build_library_fn_ptr (name, fn_type, ECF_LEAF | ECF_NOTHROW);
6890 mark_used (atexit_fndecl);
6891 pop_lang_context ();
6892 atexit_node = decay_conversion (atexit_fndecl, tf_warning_or_error);
6894 return atexit_node;
6897 /* Like get_atexit_node, but for thread-local cleanups. */
6899 static tree
6900 get_thread_atexit_node (void)
6902 /* The declaration for `__cxa_thread_atexit' is:
6904 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6905 tree fn_type = build_function_type_list (integer_type_node,
6906 get_atexit_fn_ptr_type (),
6907 ptr_type_node, ptr_type_node,
6908 NULL_TREE);
6910 /* Now, build the function declaration. */
6911 tree atexit_fndecl = build_library_fn_ptr ("__cxa_thread_atexit", fn_type,
6912 ECF_LEAF | ECF_NOTHROW);
6913 return decay_conversion (atexit_fndecl, tf_warning_or_error);
6916 /* Returns the __dso_handle VAR_DECL. */
6918 static tree
6919 get_dso_handle_node (void)
6921 if (dso_handle_node)
6922 return dso_handle_node;
6924 /* Declare the variable. */
6925 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6926 ptr_type_node);
6928 #ifdef HAVE_GAS_HIDDEN
6929 if (dso_handle_node != error_mark_node)
6931 DECL_VISIBILITY (dso_handle_node) = VISIBILITY_HIDDEN;
6932 DECL_VISIBILITY_SPECIFIED (dso_handle_node) = 1;
6934 #endif
6936 return dso_handle_node;
6939 /* Begin a new function with internal linkage whose job will be simply
6940 to destroy some particular variable. */
6942 static GTY(()) int start_cleanup_cnt;
6944 static tree
6945 start_cleanup_fn (void)
6947 char name[32];
6948 tree fntype;
6949 tree fndecl;
6950 bool use_cxa_atexit = flag_use_cxa_atexit
6951 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6953 push_to_top_level ();
6955 /* No need to mangle this. */
6956 push_lang_context (lang_name_c);
6958 /* Build the name of the function. */
6959 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6960 /* Build the function declaration. */
6961 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6962 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6963 /* It's a function with internal linkage, generated by the
6964 compiler. */
6965 TREE_PUBLIC (fndecl) = 0;
6966 DECL_ARTIFICIAL (fndecl) = 1;
6967 /* Make the function `inline' so that it is only emitted if it is
6968 actually needed. It is unlikely that it will be inlined, since
6969 it is only called via a function pointer, but we avoid unnecessary
6970 emissions this way. */
6971 DECL_DECLARED_INLINE_P (fndecl) = 1;
6972 DECL_INTERFACE_KNOWN (fndecl) = 1;
6973 /* Build the parameter. */
6974 if (use_cxa_atexit)
6976 tree parmdecl;
6978 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6979 DECL_CONTEXT (parmdecl) = fndecl;
6980 TREE_USED (parmdecl) = 1;
6981 DECL_READ_P (parmdecl) = 1;
6982 DECL_ARGUMENTS (fndecl) = parmdecl;
6985 pushdecl (fndecl);
6986 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6988 pop_lang_context ();
6990 return current_function_decl;
6993 /* Finish the cleanup function begun by start_cleanup_fn. */
6995 static void
6996 end_cleanup_fn (void)
6998 expand_or_defer_fn (finish_function (0));
7000 pop_from_top_level ();
7003 /* Generate code to handle the destruction of DECL, an object with
7004 static storage duration. */
7006 tree
7007 register_dtor_fn (tree decl)
7009 tree cleanup;
7010 tree addr;
7011 tree compound_stmt;
7012 tree fcall;
7013 tree type;
7014 bool ob_parm, dso_parm, use_dtor;
7015 tree arg0, arg1, arg2;
7016 tree atex_node;
7018 type = TREE_TYPE (decl);
7019 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
7020 return void_node;
7022 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7023 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7024 destructor to "__cxa_atexit"; we don't have to build a temporary
7025 function to do the cleanup. */
7026 dso_parm = (flag_use_cxa_atexit
7027 && !targetm.cxx.use_atexit_for_cxa_atexit ());
7028 ob_parm = (DECL_THREAD_LOCAL_P (decl) || dso_parm);
7029 use_dtor = ob_parm && CLASS_TYPE_P (type);
7030 if (use_dtor)
7032 int idx;
7034 /* Find the destructor. */
7035 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
7036 gcc_assert (idx >= 0);
7037 cleanup = (*CLASSTYPE_METHOD_VEC (type))[idx];
7038 /* Make sure it is accessible. */
7039 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup,
7040 tf_warning_or_error);
7042 else
7044 /* Call build_cleanup before we enter the anonymous function so
7045 that any access checks will be done relative to the current
7046 scope, rather than the scope of the anonymous function. */
7047 build_cleanup (decl);
7049 /* Now start the function. */
7050 cleanup = start_cleanup_fn ();
7052 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7053 to the original function, rather than the anonymous one. That
7054 will make the back end think that nested functions are in use,
7055 which causes confusion. */
7056 push_deferring_access_checks (dk_no_check);
7057 fcall = build_cleanup (decl);
7058 pop_deferring_access_checks ();
7060 /* Create the body of the anonymous function. */
7061 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
7062 finish_expr_stmt (fcall);
7063 finish_compound_stmt (compound_stmt);
7064 end_cleanup_fn ();
7067 /* Call atexit with the cleanup function. */
7068 mark_used (cleanup);
7069 cleanup = build_address (cleanup);
7071 if (DECL_THREAD_LOCAL_P (decl))
7072 atex_node = get_thread_atexit_node ();
7073 else
7074 atex_node = get_atexit_node ();
7076 if (use_dtor)
7078 /* We must convert CLEANUP to the type that "__cxa_atexit"
7079 expects. */
7080 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
7081 /* "__cxa_atexit" will pass the address of DECL to the
7082 cleanup function. */
7083 mark_used (decl);
7084 addr = build_address (decl);
7085 /* The declared type of the parameter to "__cxa_atexit" is
7086 "void *". For plain "T*", we could just let the
7087 machinery in cp_build_function_call convert it -- but if the
7088 type is "cv-qualified T *", then we need to convert it
7089 before passing it in, to avoid spurious errors. */
7090 addr = build_nop (ptr_type_node, addr);
7092 else
7093 /* Since the cleanup functions we build ignore the address
7094 they're given, there's no reason to pass the actual address
7095 in, and, in general, it's cheaper to pass NULL than any
7096 other value. */
7097 addr = null_pointer_node;
7099 if (dso_parm)
7100 arg2 = cp_build_addr_expr (get_dso_handle_node (),
7101 tf_warning_or_error);
7102 else if (ob_parm)
7103 /* Just pass NULL to the dso handle parm if we don't actually
7104 have a DSO handle on this target. */
7105 arg2 = null_pointer_node;
7106 else
7107 arg2 = NULL_TREE;
7109 if (ob_parm)
7111 if (!DECL_THREAD_LOCAL_P (decl)
7112 && targetm.cxx.use_aeabi_atexit ())
7114 arg1 = cleanup;
7115 arg0 = addr;
7117 else
7119 arg1 = addr;
7120 arg0 = cleanup;
7123 else
7125 arg0 = cleanup;
7126 arg1 = NULL_TREE;
7128 return cp_build_function_call_nary (atex_node, tf_warning_or_error,
7129 arg0, arg1, arg2, NULL_TREE);
7132 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7133 is its initializer. Generate code to handle the construction
7134 and destruction of DECL. */
7136 static void
7137 expand_static_init (tree decl, tree init)
7139 gcc_assert (VAR_P (decl));
7140 gcc_assert (TREE_STATIC (decl));
7142 /* Some variables require no dynamic initialization. */
7143 if (!init
7144 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
7146 /* Make sure the destructor is callable. */
7147 cxx_maybe_build_cleanup (decl, tf_warning_or_error);
7148 return;
7151 if (DECL_THREAD_LOCAL_P (decl) && DECL_GNU_TLS_P (decl)
7152 && !DECL_FUNCTION_SCOPE_P (decl))
7154 if (init)
7155 error ("non-local variable %qD declared %<__thread%> "
7156 "needs dynamic initialization", decl);
7157 else
7158 error ("non-local variable %qD declared %<__thread%> "
7159 "has a non-trivial destructor", decl);
7160 static bool informed;
7161 if (!informed)
7163 inform (DECL_SOURCE_LOCATION (decl),
7164 "C++11 %<thread_local%> allows dynamic initialization "
7165 "and destruction");
7166 informed = true;
7168 return;
7171 if (DECL_FUNCTION_SCOPE_P (decl))
7173 /* Emit code to perform this initialization but once. */
7174 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
7175 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
7176 tree guard, guard_addr;
7177 tree flag, begin;
7178 /* We don't need thread-safety code for thread-local vars. */
7179 bool thread_guard = (flag_threadsafe_statics
7180 && !DECL_THREAD_LOCAL_P (decl));
7182 /* Emit code to perform this initialization but once. This code
7183 looks like:
7185 static <type> guard;
7186 if (!guard.first_byte) {
7187 if (__cxa_guard_acquire (&guard)) {
7188 bool flag = false;
7189 try {
7190 // Do initialization.
7191 flag = true; __cxa_guard_release (&guard);
7192 // Register variable for destruction at end of program.
7193 } catch {
7194 if (!flag) __cxa_guard_abort (&guard);
7198 Note that the `flag' variable is only set to 1 *after* the
7199 initialization is complete. This ensures that an exception,
7200 thrown during the construction, will cause the variable to
7201 reinitialized when we pass through this code again, as per:
7203 [stmt.dcl]
7205 If the initialization exits by throwing an exception, the
7206 initialization is not complete, so it will be tried again
7207 the next time control enters the declaration.
7209 This process should be thread-safe, too; multiple threads
7210 should not be able to initialize the variable more than
7211 once. */
7213 /* Create the guard variable. */
7214 guard = get_guard (decl);
7216 /* This optimization isn't safe on targets with relaxed memory
7217 consistency. On such targets we force synchronization in
7218 __cxa_guard_acquire. */
7219 if (!targetm.relaxed_ordering || !thread_guard)
7221 /* Begin the conditional initialization. */
7222 if_stmt = begin_if_stmt ();
7223 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
7224 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
7227 if (thread_guard)
7229 tree vfntype = NULL_TREE;
7230 tree acquire_name, release_name, abort_name;
7231 tree acquire_fn, release_fn, abort_fn;
7232 guard_addr = build_address (guard);
7234 acquire_name = get_identifier ("__cxa_guard_acquire");
7235 release_name = get_identifier ("__cxa_guard_release");
7236 abort_name = get_identifier ("__cxa_guard_abort");
7237 acquire_fn = identifier_global_value (acquire_name);
7238 release_fn = identifier_global_value (release_name);
7239 abort_fn = identifier_global_value (abort_name);
7240 if (!acquire_fn)
7241 acquire_fn = push_library_fn
7242 (acquire_name, build_function_type_list (integer_type_node,
7243 TREE_TYPE (guard_addr),
7244 NULL_TREE),
7245 NULL_TREE, ECF_NOTHROW | ECF_LEAF);
7246 if (!release_fn || !abort_fn)
7247 vfntype = build_function_type_list (void_type_node,
7248 TREE_TYPE (guard_addr),
7249 NULL_TREE);
7250 if (!release_fn)
7251 release_fn = push_library_fn (release_name, vfntype, NULL_TREE,
7252 ECF_NOTHROW | ECF_LEAF);
7253 if (!abort_fn)
7254 abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE,
7255 ECF_NOTHROW | ECF_LEAF);
7257 inner_if_stmt = begin_if_stmt ();
7258 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
7259 inner_if_stmt);
7261 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
7262 begin = get_target_expr (boolean_false_node);
7263 flag = TARGET_EXPR_SLOT (begin);
7265 TARGET_EXPR_CLEANUP (begin)
7266 = build3 (COND_EXPR, void_type_node, flag,
7267 void_node,
7268 build_call_n (abort_fn, 1, guard_addr));
7269 CLEANUP_EH_ONLY (begin) = 1;
7271 /* Do the initialization itself. */
7272 init = add_stmt_to_compound (begin, init);
7273 init = add_stmt_to_compound
7274 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
7275 init = add_stmt_to_compound
7276 (init, build_call_n (release_fn, 1, guard_addr));
7278 else
7279 init = add_stmt_to_compound (init, set_guard (guard));
7281 /* Use atexit to register a function for destroying this static
7282 variable. */
7283 init = add_stmt_to_compound (init, register_dtor_fn (decl));
7285 finish_expr_stmt (init);
7287 if (thread_guard)
7289 finish_compound_stmt (inner_then_clause);
7290 finish_then_clause (inner_if_stmt);
7291 finish_if_stmt (inner_if_stmt);
7294 if (!targetm.relaxed_ordering || !thread_guard)
7296 finish_compound_stmt (then_clause);
7297 finish_then_clause (if_stmt);
7298 finish_if_stmt (if_stmt);
7301 else if (DECL_THREAD_LOCAL_P (decl))
7302 tls_aggregates = tree_cons (init, decl, tls_aggregates);
7303 else
7304 static_aggregates = tree_cons (init, decl, static_aggregates);
7308 /* Make TYPE a complete type based on INITIAL_VALUE.
7309 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7310 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7311 3 if the initializer list is empty (in pedantic mode). */
7314 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
7316 int failure;
7317 tree type, elt_type;
7319 /* Don't get confused by a CONSTRUCTOR for some other type. */
7320 if (initial_value && TREE_CODE (initial_value) == CONSTRUCTOR
7321 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value))
7322 return 1;
7324 if (initial_value)
7326 unsigned HOST_WIDE_INT i;
7327 tree value;
7329 /* An array of character type can be initialized from a
7330 brace-enclosed string constant.
7332 FIXME: this code is duplicated from reshape_init. Probably
7333 we should just call reshape_init here? */
7334 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
7335 && TREE_CODE (initial_value) == CONSTRUCTOR
7336 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value)))
7338 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value);
7339 tree value = (*v)[0].value;
7341 if (TREE_CODE (value) == STRING_CST
7342 && v->length () == 1)
7343 initial_value = value;
7346 /* If any of the elements are parameter packs, we can't actually
7347 complete this type now because the array size is dependent. */
7348 if (TREE_CODE (initial_value) == CONSTRUCTOR)
7350 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
7351 i, value)
7353 if (PACK_EXPANSION_P (value))
7354 return 0;
7359 failure = complete_array_type (ptype, initial_value, do_default);
7361 /* We can create the array before the element type is complete, which
7362 means that we didn't have these two bits set in the original type
7363 either. In completing the type, we are expected to propagate these
7364 bits. See also complete_type which does the same thing for arrays
7365 of fixed size. */
7366 type = *ptype;
7367 if (TYPE_DOMAIN (type))
7369 elt_type = TREE_TYPE (type);
7370 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
7371 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
7372 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
7375 return failure;
7378 /* As above, but either give an error or reject zero-size arrays, depending
7379 on COMPLAIN. */
7382 cp_complete_array_type_or_error (tree *ptype, tree initial_value,
7383 bool do_default, tsubst_flags_t complain)
7385 int failure;
7386 bool sfinae = !(complain & tf_error);
7387 /* In SFINAE context we can't be lenient about zero-size arrays. */
7388 if (sfinae)
7389 ++pedantic;
7390 failure = cp_complete_array_type (ptype, initial_value, do_default);
7391 if (sfinae)
7392 --pedantic;
7393 if (failure)
7395 if (sfinae)
7396 /* Not an error. */;
7397 else if (failure == 1)
7398 error ("initializer fails to determine size of %qT", *ptype);
7399 else if (failure == 2)
7401 if (do_default)
7402 error ("array size missing in %qT", *ptype);
7404 else if (failure == 3)
7405 error ("zero-size array %qT", *ptype);
7406 *ptype = error_mark_node;
7408 return failure;
7411 /* Return zero if something is declared to be a member of type
7412 CTYPE when in the context of CUR_TYPE. STRING is the error
7413 message to print in that case. Otherwise, quietly return 1. */
7415 static int
7416 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
7418 if (ctype && ctype != cur_type)
7420 if (flags == DTOR_FLAG)
7421 error ("destructor for alien class %qT cannot be a member", ctype);
7422 else
7423 error ("constructor for alien class %qT cannot be a member", ctype);
7424 return 0;
7426 return 1;
7429 /* Subroutine of `grokdeclarator'. */
7431 /* Generate errors possibly applicable for a given set of specifiers.
7432 This is for ARM $7.1.2. */
7434 static void
7435 bad_specifiers (tree object,
7436 enum bad_spec_place type,
7437 int virtualp,
7438 int quals,
7439 int inlinep,
7440 int friendp,
7441 int raises)
7443 switch (type)
7445 case BSP_VAR:
7446 if (virtualp)
7447 error ("%qD declared as a %<virtual%> variable", object);
7448 if (inlinep)
7449 error ("%qD declared as an %<inline%> variable", object);
7450 if (quals)
7451 error ("%<const%> and %<volatile%> function specifiers on "
7452 "%qD invalid in variable declaration", object);
7453 break;
7454 case BSP_PARM:
7455 if (virtualp)
7456 error ("%qD declared as a %<virtual%> parameter", object);
7457 if (inlinep)
7458 error ("%qD declared as an %<inline%> parameter", object);
7459 if (quals)
7460 error ("%<const%> and %<volatile%> function specifiers on "
7461 "%qD invalid in parameter declaration", object);
7462 break;
7463 case BSP_TYPE:
7464 if (virtualp)
7465 error ("%qD declared as a %<virtual%> type", object);
7466 if (inlinep)
7467 error ("%qD declared as an %<inline%> type", object);
7468 if (quals)
7469 error ("%<const%> and %<volatile%> function specifiers on "
7470 "%qD invalid in type declaration", object);
7471 break;
7472 case BSP_FIELD:
7473 if (virtualp)
7474 error ("%qD declared as a %<virtual%> field", object);
7475 if (inlinep)
7476 error ("%qD declared as an %<inline%> field", object);
7477 if (quals)
7478 error ("%<const%> and %<volatile%> function specifiers on "
7479 "%qD invalid in field declaration", object);
7480 break;
7481 default:
7482 gcc_unreachable();
7484 if (friendp)
7485 error ("%q+D declared as a friend", object);
7486 if (raises
7487 && (TREE_CODE (object) == TYPE_DECL
7488 || (!TYPE_PTRFN_P (TREE_TYPE (object))
7489 && !TYPE_REFFN_P (TREE_TYPE (object))
7490 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
7491 error ("%q+D declared with an exception specification", object);
7494 /* DECL is a member function or static data member and is presently
7495 being defined. Check that the definition is taking place in a
7496 valid namespace. */
7498 static void
7499 check_class_member_definition_namespace (tree decl)
7501 /* These checks only apply to member functions and static data
7502 members. */
7503 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
7504 /* We check for problems with specializations in pt.c in
7505 check_specialization_namespace, where we can issue better
7506 diagnostics. */
7507 if (processing_specialization)
7508 return;
7509 /* There are no restrictions on the placement of
7510 explicit instantiations. */
7511 if (processing_explicit_instantiation)
7512 return;
7513 /* [class.mfct]
7515 A member function definition that appears outside of the
7516 class definition shall appear in a namespace scope enclosing
7517 the class definition.
7519 [class.static.data]
7521 The definition for a static data member shall appear in a
7522 namespace scope enclosing the member's class definition. */
7523 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
7524 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
7525 decl, DECL_CONTEXT (decl));
7528 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7529 METHOD_TYPE for a non-static member function; QUALS are the
7530 cv-qualifiers that apply to the function. */
7532 tree
7533 build_this_parm (tree type, cp_cv_quals quals)
7535 tree this_type;
7536 tree qual_type;
7537 tree parm;
7538 cp_cv_quals this_quals;
7540 if (CLASS_TYPE_P (type))
7542 this_type
7543 = cp_build_qualified_type (type, quals & ~TYPE_QUAL_RESTRICT);
7544 this_type = build_pointer_type (this_type);
7546 else
7547 this_type = type_of_this_parm (type);
7548 /* The `this' parameter is implicitly `const'; it cannot be
7549 assigned to. */
7550 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
7551 qual_type = cp_build_qualified_type (this_type, this_quals);
7552 parm = build_artificial_parm (this_identifier, qual_type);
7553 cp_apply_type_quals_to_decl (this_quals, parm);
7554 return parm;
7557 /* DECL is a static member function. Complain if it was declared
7558 with function-cv-quals. */
7560 static void
7561 check_static_quals (tree decl, cp_cv_quals quals)
7563 if (quals != TYPE_UNQUALIFIED)
7564 error ("static member function %q#D declared with type qualifiers",
7565 decl);
7568 /* Helper function. Replace the temporary this parameter injected
7569 during cp_finish_omp_declare_simd with the real this parameter. */
7571 static tree
7572 declare_simd_adjust_this (tree *tp, int *walk_subtrees, void *data)
7574 tree this_parm = (tree) data;
7575 if (TREE_CODE (*tp) == PARM_DECL
7576 && DECL_NAME (*tp) == this_identifier
7577 && *tp != this_parm)
7578 *tp = this_parm;
7579 else if (TYPE_P (*tp))
7580 *walk_subtrees = 0;
7581 return NULL_TREE;
7584 /* CTYPE is class type, or null if non-class.
7585 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7586 or METHOD_TYPE.
7587 DECLARATOR is the function's name.
7588 PARMS is a chain of PARM_DECLs for the function.
7589 VIRTUALP is truthvalue of whether the function is virtual or not.
7590 FLAGS are to be passed through to `grokclassfn'.
7591 QUALS are qualifiers indicating whether the function is `const'
7592 or `volatile'.
7593 RAISES is a list of exceptions that this function can raise.
7594 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7595 not look, and -1 if we should not call `grokclassfn' at all.
7597 SFK is the kind of special function (if any) for the new function.
7599 Returns `NULL_TREE' if something goes wrong, after issuing
7600 applicable error messages. */
7602 static tree
7603 grokfndecl (tree ctype,
7604 tree type,
7605 tree declarator,
7606 tree parms,
7607 tree orig_declarator,
7608 int virtualp,
7609 enum overload_flags flags,
7610 cp_cv_quals quals,
7611 cp_ref_qualifier rqual,
7612 tree raises,
7613 int check,
7614 int friendp,
7615 int publicp,
7616 int inlinep,
7617 special_function_kind sfk,
7618 bool funcdef_flag,
7619 int template_count,
7620 tree in_namespace,
7621 tree* attrlist,
7622 location_t location)
7624 tree decl;
7625 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
7626 tree t;
7628 if (rqual)
7629 type = build_ref_qualified_type (type, rqual);
7630 if (raises)
7631 type = build_exception_variant (type, raises);
7633 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
7635 /* If we have an explicit location, use it, otherwise use whatever
7636 build_lang_decl used (probably input_location). */
7637 if (location != UNKNOWN_LOCATION)
7638 DECL_SOURCE_LOCATION (decl) = location;
7640 if (TREE_CODE (type) == METHOD_TYPE)
7642 tree parm;
7643 parm = build_this_parm (type, quals);
7644 DECL_CHAIN (parm) = parms;
7645 parms = parm;
7647 DECL_ARGUMENTS (decl) = parms;
7648 for (t = parms; t; t = DECL_CHAIN (t))
7649 DECL_CONTEXT (t) = decl;
7650 /* Propagate volatile out from type to decl. */
7651 if (TYPE_VOLATILE (type))
7652 TREE_THIS_VOLATILE (decl) = 1;
7654 /* Setup decl according to sfk. */
7655 switch (sfk)
7657 case sfk_constructor:
7658 case sfk_copy_constructor:
7659 case sfk_move_constructor:
7660 DECL_CONSTRUCTOR_P (decl) = 1;
7661 break;
7662 case sfk_destructor:
7663 DECL_DESTRUCTOR_P (decl) = 1;
7664 break;
7665 default:
7666 break;
7669 /* If pointers to member functions use the least significant bit to
7670 indicate whether a function is virtual, ensure a pointer
7671 to this function will have that bit clear. */
7672 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
7673 && TREE_CODE (type) == METHOD_TYPE
7674 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
7675 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
7677 if (friendp
7678 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
7680 if (funcdef_flag)
7681 error
7682 ("defining explicit specialization %qD in friend declaration",
7683 orig_declarator);
7684 else
7686 tree fns = TREE_OPERAND (orig_declarator, 0);
7687 tree args = TREE_OPERAND (orig_declarator, 1);
7689 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7691 /* Something like `template <class T> friend void f<T>()'. */
7692 error ("invalid use of template-id %qD in declaration "
7693 "of primary template",
7694 orig_declarator);
7695 return NULL_TREE;
7699 /* A friend declaration of the form friend void f<>(). Record
7700 the information in the TEMPLATE_ID_EXPR. */
7701 SET_DECL_IMPLICIT_INSTANTIATION (decl);
7703 gcc_assert (identifier_p (fns) || TREE_CODE (fns) == OVERLOAD);
7704 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
7706 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
7707 if (TREE_PURPOSE (t)
7708 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
7710 error ("default arguments are not allowed in declaration "
7711 "of friend template specialization %qD",
7712 decl);
7713 return NULL_TREE;
7716 if (inlinep & 1)
7717 error ("%<inline%> is not allowed in declaration of friend "
7718 "template specialization %qD",
7719 decl);
7720 if (inlinep & 2)
7721 error ("%<constexpr%> is not allowed in declaration of friend "
7722 "template specialization %qD",
7723 decl);
7724 if (inlinep)
7725 return NULL_TREE;
7729 /* If this decl has namespace scope, set that up. */
7730 if (in_namespace)
7731 set_decl_namespace (decl, in_namespace, friendp);
7732 else if (!ctype)
7733 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
7735 /* `main' and builtins have implicit 'C' linkage. */
7736 if ((MAIN_NAME_P (declarator)
7737 || (IDENTIFIER_LENGTH (declarator) > 10
7738 && IDENTIFIER_POINTER (declarator)[0] == '_'
7739 && IDENTIFIER_POINTER (declarator)[1] == '_'
7740 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0)
7741 || (targetcm.cxx_implicit_extern_c
7742 && targetcm.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator))))
7743 && current_lang_name == lang_name_cplusplus
7744 && ctype == NULL_TREE
7745 && DECL_FILE_SCOPE_P (decl))
7746 SET_DECL_LANGUAGE (decl, lang_c);
7748 /* Should probably propagate const out from type to decl I bet (mrs). */
7749 if (staticp)
7751 DECL_STATIC_FUNCTION_P (decl) = 1;
7752 DECL_CONTEXT (decl) = ctype;
7755 if (ctype)
7757 DECL_CONTEXT (decl) = ctype;
7758 if (funcdef_flag)
7759 check_class_member_definition_namespace (decl);
7762 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7764 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7765 error ("cannot declare %<::main%> to be a template");
7766 if (inlinep & 1)
7767 error ("cannot declare %<::main%> to be inline");
7768 if (inlinep & 2)
7769 error ("cannot declare %<::main%> to be constexpr");
7770 if (!publicp)
7771 error ("cannot declare %<::main%> to be static");
7772 inlinep = 0;
7773 publicp = 1;
7776 /* Members of anonymous types and local classes have no linkage; make
7777 them internal. If a typedef is made later, this will be changed. */
7778 if (ctype && (TYPE_ANONYMOUS_P (ctype)
7779 || decl_function_context (TYPE_MAIN_DECL (ctype))))
7780 publicp = 0;
7782 if (publicp && cxx_dialect == cxx98)
7784 /* [basic.link]: A name with no linkage (notably, the name of a class
7785 or enumeration declared in a local scope) shall not be used to
7786 declare an entity with linkage.
7788 DR 757 relaxes this restriction for C++0x. */
7789 no_linkage_error (decl);
7792 TREE_PUBLIC (decl) = publicp;
7793 if (! publicp)
7795 DECL_INTERFACE_KNOWN (decl) = 1;
7796 DECL_NOT_REALLY_EXTERN (decl) = 1;
7799 /* If the declaration was declared inline, mark it as such. */
7800 if (inlinep)
7802 DECL_DECLARED_INLINE_P (decl) = 1;
7803 if (publicp)
7804 DECL_COMDAT (decl) = 1;
7806 if (inlinep & 2)
7807 DECL_DECLARED_CONSTEXPR_P (decl) = true;
7809 DECL_EXTERNAL (decl) = 1;
7810 if (TREE_CODE (type) == FUNCTION_TYPE)
7812 if (quals)
7814 error (ctype
7815 ? G_("static member function %qD cannot have cv-qualifier")
7816 : G_("non-member function %qD cannot have cv-qualifier"),
7817 decl);
7818 quals = TYPE_UNQUALIFIED;
7821 if (rqual)
7823 error (ctype
7824 ? G_("static member function %qD cannot have ref-qualifier")
7825 : G_("non-member function %qD cannot have ref-qualifier"),
7826 decl);
7827 rqual = REF_QUAL_NONE;
7831 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
7832 && !grok_op_properties (decl, /*complain=*/true))
7833 return NULL_TREE;
7834 else if (UDLIT_OPER_P (DECL_NAME (decl)))
7836 bool long_long_unsigned_p;
7837 bool long_double_p;
7838 const char *suffix = NULL;
7839 /* [over.literal]/6: Literal operators shall not have C linkage. */
7840 if (DECL_LANGUAGE (decl) == lang_c)
7842 error ("literal operator with C linkage");
7843 return NULL_TREE;
7846 if (DECL_NAMESPACE_SCOPE_P (decl))
7848 if (!check_literal_operator_args (decl, &long_long_unsigned_p,
7849 &long_double_p))
7851 error ("%qD has invalid argument list", decl);
7852 return NULL_TREE;
7855 suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl));
7856 if (long_long_unsigned_p)
7858 if (cpp_interpret_int_suffix (parse_in, suffix, strlen (suffix)))
7859 warning (0, "integer suffix %<%s%>"
7860 " shadowed by implementation", suffix);
7862 else if (long_double_p)
7864 if (cpp_interpret_float_suffix (parse_in, suffix, strlen (suffix)))
7865 warning (0, "floating point suffix %<%s%>"
7866 " shadowed by implementation", suffix);
7869 else
7871 error ("%qD must be a non-member function", decl);
7872 return NULL_TREE;
7876 if (funcdef_flag)
7877 /* Make the init_value nonzero so pushdecl knows this is not
7878 tentative. error_mark_node is replaced later with the BLOCK. */
7879 DECL_INITIAL (decl) = error_mark_node;
7881 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
7882 TREE_NOTHROW (decl) = 1;
7884 if (flag_openmp || flag_cilkplus)
7886 /* Adjust "omp declare simd" attributes. */
7887 tree ods = lookup_attribute ("omp declare simd", *attrlist);
7888 if (ods)
7890 tree attr;
7891 for (attr = ods; attr;
7892 attr = lookup_attribute ("omp declare simd", TREE_CHAIN (attr)))
7894 if (TREE_CODE (type) == METHOD_TYPE)
7895 walk_tree (&TREE_VALUE (attr), declare_simd_adjust_this,
7896 DECL_ARGUMENTS (decl), NULL);
7897 if (TREE_VALUE (attr) != NULL_TREE)
7899 tree cl = TREE_VALUE (TREE_VALUE (attr));
7900 cl = c_omp_declare_simd_clauses_to_numbers
7901 (DECL_ARGUMENTS (decl), cl);
7902 if (cl)
7903 TREE_VALUE (TREE_VALUE (attr)) = cl;
7904 else
7905 TREE_VALUE (attr) = NULL_TREE;
7911 /* Caller will do the rest of this. */
7912 if (check < 0)
7913 return decl;
7915 if (ctype != NULL_TREE)
7916 grokclassfn (ctype, decl, flags);
7918 /* 12.4/3 */
7919 if (cxx_dialect >= cxx11
7920 && DECL_DESTRUCTOR_P (decl)
7921 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl))
7922 && !processing_template_decl)
7923 deduce_noexcept_on_destructor (decl);
7925 decl = check_explicit_specialization (orig_declarator, decl,
7926 template_count,
7927 2 * funcdef_flag +
7928 4 * (friendp != 0));
7929 if (decl == error_mark_node)
7930 return NULL_TREE;
7932 if (DECL_STATIC_FUNCTION_P (decl))
7933 check_static_quals (decl, quals);
7935 if (attrlist)
7937 cplus_decl_attributes (&decl, *attrlist, 0);
7938 *attrlist = NULL_TREE;
7941 /* Check main's type after attributes have been applied. */
7942 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
7944 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
7945 integer_type_node))
7947 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
7948 tree newtype;
7949 error ("%<::main%> must return %<int%>");
7950 newtype = build_function_type (integer_type_node, oldtypeargs);
7951 TREE_TYPE (decl) = newtype;
7953 if (warn_main)
7954 check_main_parameter_types (decl);
7957 if (ctype != NULL_TREE
7958 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
7959 && check)
7961 tree old_decl = check_classfn (ctype, decl,
7962 (processing_template_decl
7963 > template_class_depth (ctype))
7964 ? current_template_parms
7965 : NULL_TREE);
7967 if (old_decl == error_mark_node)
7968 return NULL_TREE;
7970 if (old_decl)
7972 tree ok;
7973 tree pushed_scope;
7975 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
7976 /* Because grokfndecl is always supposed to return a
7977 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7978 here. We depend on our callers to figure out that its
7979 really a template that's being returned. */
7980 old_decl = DECL_TEMPLATE_RESULT (old_decl);
7982 if (DECL_STATIC_FUNCTION_P (old_decl)
7983 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
7985 /* Remove the `this' parm added by grokclassfn. */
7986 revert_static_member_fn (decl);
7987 check_static_quals (decl, quals);
7989 if (DECL_ARTIFICIAL (old_decl))
7991 error ("definition of implicitly-declared %qD", old_decl);
7992 return NULL_TREE;
7994 else if (DECL_DEFAULTED_FN (old_decl))
7996 error ("definition of explicitly-defaulted %q+D", decl);
7997 error ("%q+#D explicitly defaulted here", old_decl);
7998 return NULL_TREE;
8001 /* Since we've smashed OLD_DECL to its
8002 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8003 if (TREE_CODE (decl) == TEMPLATE_DECL)
8004 decl = DECL_TEMPLATE_RESULT (decl);
8006 /* Attempt to merge the declarations. This can fail, in
8007 the case of some invalid specialization declarations. */
8008 pushed_scope = push_scope (ctype);
8009 ok = duplicate_decls (decl, old_decl, friendp);
8010 if (pushed_scope)
8011 pop_scope (pushed_scope);
8012 if (!ok)
8014 error ("no %q#D member function declared in class %qT",
8015 decl, ctype);
8016 return NULL_TREE;
8018 if (ok == error_mark_node)
8019 return NULL_TREE;
8020 return old_decl;
8024 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
8025 return NULL_TREE;
8027 if (ctype == NULL_TREE || check)
8028 return decl;
8030 if (virtualp)
8031 DECL_VIRTUAL_P (decl) = 1;
8033 return decl;
8036 /* decl is a FUNCTION_DECL.
8037 specifiers are the parsed virt-specifiers.
8039 Set flags to reflect the virt-specifiers.
8041 Returns decl. */
8043 static tree
8044 set_virt_specifiers (tree decl, cp_virt_specifiers specifiers)
8046 if (decl == NULL_TREE)
8047 return decl;
8048 if (specifiers & VIRT_SPEC_OVERRIDE)
8049 DECL_OVERRIDE_P (decl) = 1;
8050 if (specifiers & VIRT_SPEC_FINAL)
8051 DECL_FINAL_P (decl) = 1;
8052 return decl;
8055 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8056 the linkage that DECL will receive in the object file. */
8058 static void
8059 set_linkage_for_static_data_member (tree decl)
8061 /* A static data member always has static storage duration and
8062 external linkage. Note that static data members are forbidden in
8063 local classes -- the only situation in which a class has
8064 non-external linkage. */
8065 TREE_PUBLIC (decl) = 1;
8066 TREE_STATIC (decl) = 1;
8067 /* For non-template classes, static data members are always put
8068 out in exactly those files where they are defined, just as
8069 with ordinary namespace-scope variables. */
8070 if (!processing_template_decl)
8071 DECL_INTERFACE_KNOWN (decl) = 1;
8074 /* Create a VAR_DECL named NAME with the indicated TYPE.
8076 If SCOPE is non-NULL, it is the class type or namespace containing
8077 the variable. If SCOPE is NULL, the variable should is created in
8078 the innermost enclosing scope. */
8080 static tree
8081 grokvardecl (tree type,
8082 tree name,
8083 tree orig_declarator,
8084 const cp_decl_specifier_seq *declspecs,
8085 int initialized,
8086 int constp,
8087 int template_count,
8088 tree scope)
8090 tree decl;
8091 tree explicit_scope;
8093 gcc_assert (!name || identifier_p (name));
8095 /* Compute the scope in which to place the variable, but remember
8096 whether or not that scope was explicitly specified by the user. */
8097 explicit_scope = scope;
8098 if (!scope)
8100 /* An explicit "extern" specifier indicates a namespace-scope
8101 variable. */
8102 if (declspecs->storage_class == sc_extern)
8103 scope = current_decl_namespace ();
8104 else if (!at_function_scope_p ())
8105 scope = current_scope ();
8108 if (scope
8109 && (/* If the variable is a namespace-scope variable declared in a
8110 template, we need DECL_LANG_SPECIFIC. */
8111 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
8112 /* Similarly for namespace-scope variables with language linkage
8113 other than C++. */
8114 || (TREE_CODE (scope) == NAMESPACE_DECL
8115 && current_lang_name != lang_name_cplusplus)
8116 /* Similarly for static data members. */
8117 || TYPE_P (scope)
8118 /* Similarly for explicit specializations. */
8119 || (orig_declarator
8120 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)))
8121 decl = build_lang_decl (VAR_DECL, name, type);
8122 else
8123 decl = build_decl (input_location, VAR_DECL, name, type);
8125 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
8126 set_decl_namespace (decl, explicit_scope, 0);
8127 else
8128 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
8130 if (declspecs->storage_class == sc_extern)
8132 DECL_THIS_EXTERN (decl) = 1;
8133 DECL_EXTERNAL (decl) = !initialized;
8136 if (DECL_CLASS_SCOPE_P (decl))
8138 set_linkage_for_static_data_member (decl);
8139 /* This function is only called with out-of-class definitions. */
8140 DECL_EXTERNAL (decl) = 0;
8141 check_class_member_definition_namespace (decl);
8143 /* At top level, either `static' or no s.c. makes a definition
8144 (perhaps tentative), and absence of `static' makes it public. */
8145 else if (toplevel_bindings_p ())
8147 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
8148 && (DECL_THIS_EXTERN (decl) || ! constp));
8149 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
8151 /* Not at top level, only `static' makes a static definition. */
8152 else
8154 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
8155 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
8158 if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
8160 if (DECL_EXTERNAL (decl) || TREE_STATIC (decl))
8161 set_decl_tls_model (decl, decl_default_tls_model (decl));
8162 if (declspecs->gnu_thread_keyword_p)
8163 DECL_GNU_TLS_P (decl) = true;
8166 /* If the type of the decl has no linkage, make sure that we'll
8167 notice that in mark_used. */
8168 if (cxx_dialect > cxx98
8169 && decl_linkage (decl) != lk_none
8170 && DECL_LANG_SPECIFIC (decl) == NULL
8171 && !DECL_EXTERN_C_P (decl)
8172 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
8173 retrofit_lang_decl (decl);
8175 if (TREE_PUBLIC (decl))
8177 /* [basic.link]: A name with no linkage (notably, the name of a class
8178 or enumeration declared in a local scope) shall not be used to
8179 declare an entity with linkage.
8181 DR 757 relaxes this restriction for C++0x. */
8182 if (cxx_dialect < cxx11)
8183 no_linkage_error (decl);
8185 else
8186 DECL_INTERFACE_KNOWN (decl) = 1;
8188 // Handle explicit specializations and instantiations of variable templates.
8189 if (orig_declarator)
8190 decl = check_explicit_specialization (orig_declarator, decl,
8191 template_count, 0);
8193 return decl != error_mark_node ? decl : NULL_TREE;
8196 /* Create and return a canonical pointer to member function type, for
8197 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8199 tree
8200 build_ptrmemfunc_type (tree type)
8202 tree field, fields;
8203 tree t;
8205 if (type == error_mark_node)
8206 return type;
8208 /* If a canonical type already exists for this type, use it. We use
8209 this method instead of type_hash_canon, because it only does a
8210 simple equality check on the list of field members. */
8212 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
8213 return t;
8215 /* Make sure that we always have the unqualified pointer-to-member
8216 type first. */
8217 if (cp_cv_quals quals = cp_type_quals (type))
8219 tree unqual = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
8220 return cp_build_qualified_type (unqual, quals);
8223 t = make_node (RECORD_TYPE);
8225 /* Let the front end know this is a pointer to member function. */
8226 TYPE_PTRMEMFUNC_FLAG (t) = 1;
8228 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
8229 fields = field;
8231 field = build_decl (input_location, FIELD_DECL, delta_identifier,
8232 delta_type_node);
8233 DECL_CHAIN (field) = fields;
8234 fields = field;
8236 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
8238 /* Zap out the name so that the back end will give us the debugging
8239 information for this anonymous RECORD_TYPE. */
8240 TYPE_NAME (t) = NULL_TREE;
8242 /* Cache this pointer-to-member type so that we can find it again
8243 later. */
8244 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
8246 if (TYPE_STRUCTURAL_EQUALITY_P (type))
8247 SET_TYPE_STRUCTURAL_EQUALITY (t);
8248 else if (TYPE_CANONICAL (type) != type)
8249 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
8251 return t;
8254 /* Create and return a pointer to data member type. */
8256 tree
8257 build_ptrmem_type (tree class_type, tree member_type)
8259 if (TREE_CODE (member_type) == METHOD_TYPE)
8261 cp_cv_quals quals = type_memfn_quals (member_type);
8262 cp_ref_qualifier rqual = type_memfn_rqual (member_type);
8263 member_type = build_memfn_type (member_type, class_type, quals, rqual);
8264 return build_ptrmemfunc_type (build_pointer_type (member_type));
8266 else
8268 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
8269 return build_offset_type (class_type, member_type);
8273 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8274 Check to see that the definition is valid. Issue appropriate error
8275 messages. Return 1 if the definition is particularly bad, or 0
8276 otherwise. */
8278 static int
8279 check_static_variable_definition (tree decl, tree type)
8281 /* Can't check yet if we don't know the type. */
8282 if (dependent_type_p (type))
8283 return 0;
8284 /* If DECL is declared constexpr, we'll do the appropriate checks
8285 in check_initializer. */
8286 if (DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
8287 return 0;
8288 else if (cxx_dialect >= cxx11 && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
8290 if (!COMPLETE_TYPE_P (type))
8291 error ("in-class initialization of static data member %q#D of "
8292 "incomplete type", decl);
8293 else if (literal_type_p (type))
8294 permerror (input_location,
8295 "%<constexpr%> needed for in-class initialization of "
8296 "static data member %q#D of non-integral type", decl);
8297 else
8298 error ("in-class initialization of static data member %q#D of "
8299 "non-literal type", decl);
8300 return 1;
8303 /* Motion 10 at San Diego: If a static const integral data member is
8304 initialized with an integral constant expression, the initializer
8305 may appear either in the declaration (within the class), or in
8306 the definition, but not both. If it appears in the class, the
8307 member is a member constant. The file-scope definition is always
8308 required. */
8309 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
8311 error ("invalid in-class initialization of static data member "
8312 "of non-integral type %qT",
8313 type);
8314 return 1;
8316 else if (!CP_TYPE_CONST_P (type))
8317 error ("ISO C++ forbids in-class initialization of non-const "
8318 "static member %qD",
8319 decl);
8320 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
8321 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids initialization of member constant "
8322 "%qD of non-integral type %qT", decl, type);
8324 return 0;
8327 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8328 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8329 expressions out into temporary variables so that walk_tree doesn't
8330 step into them (c++/15764). */
8332 static tree
8333 stabilize_save_expr_r (tree *expr_p, int *walk_subtrees, void *data)
8335 hash_set<tree> *pset = (hash_set<tree> *)data;
8336 tree expr = *expr_p;
8337 if (TREE_CODE (expr) == SAVE_EXPR)
8339 tree op = TREE_OPERAND (expr, 0);
8340 cp_walk_tree (&op, stabilize_save_expr_r, data, pset);
8341 if (TREE_SIDE_EFFECTS (op))
8342 TREE_OPERAND (expr, 0) = get_temp_regvar (TREE_TYPE (op), op);
8343 *walk_subtrees = 0;
8345 else if (!EXPR_P (expr) || !TREE_SIDE_EFFECTS (expr))
8346 *walk_subtrees = 0;
8347 return NULL;
8350 /* Entry point for the above. */
8352 static void
8353 stabilize_vla_size (tree size)
8355 hash_set<tree> pset;
8356 /* Break out any function calls into temporary variables. */
8357 cp_walk_tree (&size, stabilize_save_expr_r, &pset, &pset);
8360 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8361 not inside of SAVE_EXPR and fold them. */
8363 static tree
8364 fold_sizeof_expr_r (tree *expr_p, int *walk_subtrees, void *data)
8366 tree expr = *expr_p;
8367 if (TREE_CODE (expr) == SAVE_EXPR || TYPE_P (expr))
8368 *walk_subtrees = 0;
8369 else if (TREE_CODE (expr) == SIZEOF_EXPR)
8371 *(bool *)data = true;
8372 if (SIZEOF_EXPR_TYPE_P (expr))
8373 expr = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr, 0)),
8374 SIZEOF_EXPR, false);
8375 else if (TYPE_P (TREE_OPERAND (expr, 0)))
8376 expr = cxx_sizeof_or_alignof_type (TREE_OPERAND (expr, 0), SIZEOF_EXPR,
8377 false);
8378 else
8379 expr = cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr, 0), SIZEOF_EXPR,
8380 false);
8381 if (expr == error_mark_node)
8382 expr = size_one_node;
8383 *expr_p = expr;
8384 *walk_subtrees = 0;
8386 return NULL;
8389 /* Given the SIZE (i.e., number of elements) in an array, compute an
8390 appropriate index type for the array. If non-NULL, NAME is the
8391 name of the thing being declared. */
8393 tree
8394 compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
8396 tree itype;
8397 tree osize = size;
8399 if (error_operand_p (size))
8400 return error_mark_node;
8402 if (!type_dependent_expression_p (size))
8404 tree type = TREE_TYPE (size);
8406 mark_rvalue_use (size);
8408 if (cxx_dialect < cxx11 && TREE_CODE (size) == NOP_EXPR
8409 && TREE_SIDE_EFFECTS (size))
8410 /* In C++98, we mark a non-constant array bound with a magic
8411 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8412 else
8414 size = instantiate_non_dependent_expr_sfinae (size, complain);
8416 if (CLASS_TYPE_P (type)
8417 && CLASSTYPE_LITERAL_P (type))
8419 size = build_expr_type_conversion (WANT_INT, size, true);
8420 if (!size)
8422 if (!(complain & tf_error))
8423 return error_mark_node;
8424 if (name)
8425 error ("size of array %qD has non-integral type %qT",
8426 name, type);
8427 else
8428 error ("size of array has non-integral type %qT", type);
8429 size = integer_one_node;
8431 if (size == error_mark_node)
8432 return error_mark_node;
8433 type = TREE_TYPE (size);
8436 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
8437 size = maybe_constant_value (size);
8439 if (!TREE_CONSTANT (size))
8440 size = osize;
8443 if (error_operand_p (size))
8444 return error_mark_node;
8446 /* The array bound must be an integer type. */
8447 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
8449 if (!(complain & tf_error))
8450 return error_mark_node;
8451 if (name)
8452 error ("size of array %qD has non-integral type %qT", name, type);
8453 else
8454 error ("size of array has non-integral type %qT", type);
8455 size = integer_one_node;
8456 type = TREE_TYPE (size);
8460 /* A type is dependent if it is...an array type constructed from any
8461 dependent type or whose size is specified by a constant expression
8462 that is value-dependent. */
8463 /* We can only call value_dependent_expression_p on integral constant
8464 expressions; treat non-constant expressions as dependent, too. */
8465 if (processing_template_decl
8466 && (type_dependent_expression_p (size)
8467 || !TREE_CONSTANT (size) || value_dependent_expression_p (size)))
8469 /* We cannot do any checking for a SIZE that isn't known to be
8470 constant. Just build the index type and mark that it requires
8471 structural equality checks. */
8472 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
8473 size, size_one_node));
8474 TYPE_DEPENDENT_P (itype) = 1;
8475 TYPE_DEPENDENT_P_VALID (itype) = 1;
8476 SET_TYPE_STRUCTURAL_EQUALITY (itype);
8477 return itype;
8480 /* Normally, the array-bound will be a constant. */
8481 if (TREE_CODE (size) == INTEGER_CST)
8483 /* Check to see if the array bound overflowed. Make that an
8484 error, no matter how generous we're being. */
8485 constant_expression_error (size);
8487 /* An array must have a positive number of elements. */
8488 if (tree_int_cst_lt (size, integer_zero_node))
8490 if (!(complain & tf_error))
8491 return error_mark_node;
8492 if (name)
8493 error ("size of array %qD is negative", name);
8494 else
8495 error ("size of array is negative");
8496 size = integer_one_node;
8498 /* As an extension we allow zero-sized arrays. */
8499 else if (integer_zerop (size))
8501 if (!(complain & tf_error))
8502 /* We must fail if performing argument deduction (as
8503 indicated by the state of complain), so that
8504 another substitution can be found. */
8505 return error_mark_node;
8506 else if (in_system_header_at (input_location))
8507 /* Allow them in system headers because glibc uses them. */;
8508 else if (name)
8509 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array %qD", name);
8510 else
8511 pedwarn (input_location, OPT_Wpedantic, "ISO C++ forbids zero-size array");
8514 else if (TREE_CONSTANT (size)
8515 /* We don't allow VLAs at non-function scopes, or during
8516 tentative template substitution. */
8517 || !at_function_scope_p ()
8518 || (cxx_dialect < cxx14 && !(complain & tf_error)))
8520 if (!(complain & tf_error))
8521 return error_mark_node;
8522 /* `(int) &fn' is not a valid array bound. */
8523 if (name)
8524 error ("size of array %qD is not an integral constant-expression",
8525 name);
8526 else
8527 error ("size of array is not an integral constant-expression");
8528 size = integer_one_node;
8530 else if (cxx_dialect < cxx14 && pedantic && warn_vla != 0)
8532 if (name)
8533 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
8534 else
8535 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
8537 else if (warn_vla > 0)
8539 if (name)
8540 warning (OPT_Wvla,
8541 "variable length array %qD is used", name);
8542 else
8543 warning (OPT_Wvla,
8544 "variable length array is used");
8547 if (processing_template_decl && !TREE_CONSTANT (size))
8548 /* A variable sized array. */
8549 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
8550 else
8552 HOST_WIDE_INT saved_processing_template_decl;
8554 /* Compute the index of the largest element in the array. It is
8555 one less than the number of elements in the array. We save
8556 and restore PROCESSING_TEMPLATE_DECL so that computations in
8557 cp_build_binary_op will be appropriately folded. */
8558 saved_processing_template_decl = processing_template_decl;
8559 processing_template_decl = 0;
8560 itype = cp_build_binary_op (input_location,
8561 MINUS_EXPR,
8562 cp_convert (ssizetype, size, complain),
8563 cp_convert (ssizetype, integer_one_node,
8564 complain),
8565 complain);
8566 itype = fold (itype);
8567 processing_template_decl = saved_processing_template_decl;
8569 if (!TREE_CONSTANT (itype))
8571 /* A variable sized array. */
8572 itype = variable_size (itype);
8574 if (TREE_CODE (itype) != SAVE_EXPR)
8576 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8577 they might survive till gimplification. */
8578 tree newitype = itype;
8579 bool found = false;
8580 cp_walk_tree_without_duplicates (&newitype,
8581 fold_sizeof_expr_r, &found);
8582 if (found)
8583 itype = variable_size (fold (newitype));
8586 stabilize_vla_size (itype);
8588 if (cxx_dialect >= cxx14 && flag_exceptions)
8590 /* If the VLA bound is larger than half the address space,
8591 or less than zero, throw std::bad_array_length. */
8592 tree comp = build2 (LT_EXPR, boolean_type_node, itype,
8593 ssize_int (-1));
8594 comp = build3 (COND_EXPR, void_type_node, comp,
8595 throw_bad_array_length (), void_node);
8596 finish_expr_stmt (comp);
8598 else if (flag_sanitize & SANITIZE_VLA
8599 && current_function_decl != NULL_TREE
8600 && !lookup_attribute ("no_sanitize_undefined",
8601 DECL_ATTRIBUTES
8602 (current_function_decl)))
8604 /* From C++14 onwards, we throw an exception on a negative
8605 length size of an array; see above. */
8607 /* We have to add 1 -- in the ubsan routine we generate
8608 LE_EXPR rather than LT_EXPR. */
8609 tree t = fold_build2 (PLUS_EXPR, TREE_TYPE (itype), itype,
8610 build_one_cst (TREE_TYPE (itype)));
8611 t = ubsan_instrument_vla (input_location, t);
8612 finish_expr_stmt (t);
8615 /* Make sure that there was no overflow when creating to a signed
8616 index type. (For example, on a 32-bit machine, an array with
8617 size 2^32 - 1 is too big.) */
8618 else if (TREE_CODE (itype) == INTEGER_CST
8619 && TREE_OVERFLOW (itype))
8621 if (!(complain & tf_error))
8622 return error_mark_node;
8623 error ("overflow in array dimension");
8624 TREE_OVERFLOW (itype) = 0;
8628 /* Create and return the appropriate index type. */
8629 itype = build_index_type (itype);
8631 /* If the index type were dependent, we would have returned early, so
8632 remember that it isn't. */
8633 TYPE_DEPENDENT_P (itype) = 0;
8634 TYPE_DEPENDENT_P_VALID (itype) = 1;
8635 return itype;
8638 /* Returns the scope (if any) in which the entity declared by
8639 DECLARATOR will be located. If the entity was declared with an
8640 unqualified name, NULL_TREE is returned. */
8642 tree
8643 get_scope_of_declarator (const cp_declarator *declarator)
8645 while (declarator && declarator->kind != cdk_id)
8646 declarator = declarator->declarator;
8648 /* If the declarator-id is a SCOPE_REF, the scope in which the
8649 declaration occurs is the first operand. */
8650 if (declarator
8651 && declarator->u.id.qualifying_scope)
8652 return declarator->u.id.qualifying_scope;
8654 /* Otherwise, the declarator is not a qualified name; the entity will
8655 be declared in the current scope. */
8656 return NULL_TREE;
8659 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8660 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8661 with this type. */
8663 static tree
8664 create_array_type_for_decl (tree name, tree type, tree size)
8666 tree itype = NULL_TREE;
8668 /* If things have already gone awry, bail now. */
8669 if (type == error_mark_node || size == error_mark_node)
8670 return error_mark_node;
8672 /* 8.3.4/1: If the type of the identifier of D contains the auto
8673 type-specifier, the program is ill-formed. */
8674 if (type_uses_auto (type))
8676 error ("%qD declared as array of %qT", name, type);
8677 return error_mark_node;
8680 /* If there are some types which cannot be array elements,
8681 issue an error-message and return. */
8682 switch (TREE_CODE (type))
8684 case VOID_TYPE:
8685 if (name)
8686 error ("declaration of %qD as array of void", name);
8687 else
8688 error ("creating array of void");
8689 return error_mark_node;
8691 case FUNCTION_TYPE:
8692 if (name)
8693 error ("declaration of %qD as array of functions", name);
8694 else
8695 error ("creating array of functions");
8696 return error_mark_node;
8698 case REFERENCE_TYPE:
8699 if (name)
8700 error ("declaration of %qD as array of references", name);
8701 else
8702 error ("creating array of references");
8703 return error_mark_node;
8705 case METHOD_TYPE:
8706 if (name)
8707 error ("declaration of %qD as array of function members", name);
8708 else
8709 error ("creating array of function members");
8710 return error_mark_node;
8712 default:
8713 break;
8716 /* [dcl.array]
8718 The constant expressions that specify the bounds of the arrays
8719 can be omitted only for the first member of the sequence. */
8720 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
8722 if (name)
8723 error ("declaration of %qD as multidimensional array must "
8724 "have bounds for all dimensions except the first",
8725 name);
8726 else
8727 error ("multidimensional array must have bounds for all "
8728 "dimensions except the first");
8730 return error_mark_node;
8733 if (cxx_dialect >= cxx14 && array_of_runtime_bound_p (type)
8734 && (flag_iso || warn_vla > 0))
8735 pedwarn (input_location, OPT_Wvla, "array of array of runtime bound");
8737 /* Figure out the index type for the array. */
8738 if (size)
8739 itype = compute_array_index_type (name, size, tf_warning_or_error);
8741 /* [dcl.array]
8742 T is called the array element type; this type shall not be [...] an
8743 abstract class type. */
8744 abstract_virtuals_error (name, type);
8746 return build_cplus_array_type (type, itype);
8749 /* Check that it's OK to declare a function with the indicated TYPE.
8750 SFK indicates the kind of special function (if any) that this
8751 function is. OPTYPE is the type given in a conversion operator
8752 declaration, or the class type for a constructor/destructor.
8753 Returns the actual return type of the function; that
8754 may be different than TYPE if an error occurs, or for certain
8755 special functions. */
8757 static tree
8758 check_special_function_return_type (special_function_kind sfk,
8759 tree type,
8760 tree optype)
8762 switch (sfk)
8764 case sfk_constructor:
8765 if (type)
8766 error ("return type specification for constructor invalid");
8768 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8769 type = build_pointer_type (optype);
8770 else
8771 type = void_type_node;
8772 break;
8774 case sfk_destructor:
8775 if (type)
8776 error ("return type specification for destructor invalid");
8777 /* We can't use the proper return type here because we run into
8778 problems with ambiguous bases and covariant returns.
8779 Java classes are left unchanged because (void *) isn't a valid
8780 Java type, and we don't want to change the Java ABI. */
8781 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
8782 type = build_pointer_type (void_type_node);
8783 else
8784 type = void_type_node;
8785 break;
8787 case sfk_conversion:
8788 if (type)
8789 error ("return type specified for %<operator %T%>", optype);
8790 type = optype;
8791 break;
8793 default:
8794 gcc_unreachable ();
8797 return type;
8800 /* A variable or data member (whose unqualified name is IDENTIFIER)
8801 has been declared with the indicated TYPE. If the TYPE is not
8802 acceptable, issue an error message and return a type to use for
8803 error-recovery purposes. */
8805 tree
8806 check_var_type (tree identifier, tree type)
8808 if (VOID_TYPE_P (type))
8810 if (!identifier)
8811 error ("unnamed variable or field declared void");
8812 else if (identifier_p (identifier))
8814 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
8815 error ("variable or field %qE declared void", identifier);
8817 else
8818 error ("variable or field declared void");
8819 type = error_mark_node;
8822 return type;
8825 /* Given declspecs and a declarator (abstract or otherwise), determine
8826 the name and type of the object declared and construct a DECL node
8827 for it.
8829 DECLSPECS points to the representation of declaration-specifier
8830 sequence that precedes declarator.
8832 DECL_CONTEXT says which syntactic context this declaration is in:
8833 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8834 FUNCDEF for a function definition. Like NORMAL but a few different
8835 error messages in each case. Return value may be zero meaning
8836 this definition is too screwy to try to parse.
8837 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8838 handle member functions (which have FIELD context).
8839 Return value may be zero meaning this definition is too screwy to
8840 try to parse.
8841 PARM for a parameter declaration (either within a function prototype
8842 or before a function body). Make a PARM_DECL, or return void_type_node.
8843 TPARM for a template parameter declaration.
8844 CATCHPARM for a parameter declaration before a catch clause.
8845 TYPENAME if for a typename (in a cast or sizeof).
8846 Don't make a DECL node; just return the ..._TYPE node.
8847 FIELD for a struct or union field; make a FIELD_DECL.
8848 BITFIELD for a field with specified width.
8850 INITIALIZED is as for start_decl.
8852 ATTRLIST is a pointer to the list of attributes, which may be NULL
8853 if there are none; *ATTRLIST may be modified if attributes from inside
8854 the declarator should be applied to the declaration.
8856 When this function is called, scoping variables (such as
8857 CURRENT_CLASS_TYPE) should reflect the scope in which the
8858 declaration occurs, not the scope in which the new declaration will
8859 be placed. For example, on:
8861 void S::f() { ... }
8863 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8864 should not be `S'.
8866 Returns a DECL (if a declarator is present), a TYPE (if there is no
8867 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8868 error occurs. */
8870 tree
8871 grokdeclarator (const cp_declarator *declarator,
8872 cp_decl_specifier_seq *declspecs,
8873 enum decl_context decl_context,
8874 int initialized,
8875 tree* attrlist)
8877 tree type = NULL_TREE;
8878 int longlong = 0;
8879 int explicit_intN = 0;
8880 int virtualp, explicitp, friendp, inlinep, staticp;
8881 int explicit_int = 0;
8882 int explicit_char = 0;
8883 int defaulted_int = 0;
8885 tree typedef_decl = NULL_TREE;
8886 const char *name = NULL;
8887 tree typedef_type = NULL_TREE;
8888 /* True if this declarator is a function definition. */
8889 bool funcdef_flag = false;
8890 cp_declarator_kind innermost_code = cdk_error;
8891 int bitfield = 0;
8892 #if 0
8893 /* See the code below that used this. */
8894 tree decl_attr = NULL_TREE;
8895 #endif
8897 /* Keep track of what sort of function is being processed
8898 so that we can warn about default return values, or explicit
8899 return values which do not match prescribed defaults. */
8900 special_function_kind sfk = sfk_none;
8902 tree dname = NULL_TREE;
8903 tree ctor_return_type = NULL_TREE;
8904 enum overload_flags flags = NO_SPECIAL;
8905 /* cv-qualifiers that apply to the declarator, for a declaration of
8906 a member function. */
8907 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
8908 /* virt-specifiers that apply to the declarator, for a declaration of
8909 a member function. */
8910 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
8911 /* ref-qualifier that applies to the declarator, for a declaration of
8912 a member function. */
8913 cp_ref_qualifier rqual = REF_QUAL_NONE;
8914 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8915 int type_quals;
8916 tree raises = NULL_TREE;
8917 int template_count = 0;
8918 tree returned_attrs = NULL_TREE;
8919 tree parms = NULL_TREE;
8920 const cp_declarator *id_declarator;
8921 /* The unqualified name of the declarator; either an
8922 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8923 tree unqualified_id;
8924 /* The class type, if any, in which this entity is located,
8925 or NULL_TREE if none. Note that this value may be different from
8926 the current class type; for example if an attempt is made to declare
8927 "A::f" inside "B", this value will be "A". */
8928 tree ctype = current_class_type;
8929 /* The NAMESPACE_DECL for the namespace in which this entity is
8930 located. If an unqualified name is used to declare the entity,
8931 this value will be NULL_TREE, even if the entity is located at
8932 namespace scope. */
8933 tree in_namespace = NULL_TREE;
8934 cp_storage_class storage_class;
8935 bool unsigned_p, signed_p, short_p, long_p, thread_p;
8936 bool type_was_error_mark_node = false;
8937 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
8938 bool template_type_arg = false;
8939 bool template_parm_flag = false;
8940 bool typedef_p = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
8941 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr);
8942 bool late_return_type_p = false;
8943 bool array_parameter_p = false;
8944 source_location saved_loc = input_location;
8945 const char *errmsg;
8947 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed);
8948 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned);
8949 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short);
8950 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long);
8951 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long);
8952 explicit_intN = declspecs->explicit_intN_p;
8953 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread);
8955 if (decl_context == FUNCDEF)
8956 funcdef_flag = true, decl_context = NORMAL;
8957 else if (decl_context == MEMFUNCDEF)
8958 funcdef_flag = true, decl_context = FIELD;
8959 else if (decl_context == BITFIELD)
8960 bitfield = 1, decl_context = FIELD;
8961 else if (decl_context == TEMPLATE_TYPE_ARG)
8962 template_type_arg = true, decl_context = TYPENAME;
8963 else if (decl_context == TPARM)
8964 template_parm_flag = true, decl_context = PARM;
8966 if (initialized > 1)
8967 funcdef_flag = true;
8969 /* Look inside a declarator for the name being declared
8970 and get it as a string, for an error message. */
8971 for (id_declarator = declarator;
8972 id_declarator;
8973 id_declarator = id_declarator->declarator)
8975 if (id_declarator->kind != cdk_id)
8976 innermost_code = id_declarator->kind;
8978 switch (id_declarator->kind)
8980 case cdk_function:
8981 if (id_declarator->declarator
8982 && id_declarator->declarator->kind == cdk_id)
8984 sfk = id_declarator->declarator->u.id.sfk;
8985 if (sfk == sfk_destructor)
8986 flags = DTOR_FLAG;
8988 break;
8990 case cdk_id:
8992 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
8993 tree decl = id_declarator->u.id.unqualified_name;
8994 if (!decl)
8995 break;
8996 if (qualifying_scope)
8998 if (at_function_scope_p ())
9000 /* [dcl.meaning]
9002 A declarator-id shall not be qualified except
9003 for ...
9005 None of the cases are permitted in block
9006 scope. */
9007 if (qualifying_scope == global_namespace)
9008 error ("invalid use of qualified-name %<::%D%>",
9009 decl);
9010 else if (TYPE_P (qualifying_scope))
9011 error ("invalid use of qualified-name %<%T::%D%>",
9012 qualifying_scope, decl);
9013 else
9014 error ("invalid use of qualified-name %<%D::%D%>",
9015 qualifying_scope, decl);
9016 return error_mark_node;
9018 else if (TYPE_P (qualifying_scope))
9020 ctype = qualifying_scope;
9021 if (!MAYBE_CLASS_TYPE_P (ctype))
9023 error ("%q#T is not a class or a namespace", ctype);
9024 ctype = NULL_TREE;
9026 else if (innermost_code != cdk_function
9027 && current_class_type
9028 && !uniquely_derived_from_p (ctype,
9029 current_class_type))
9031 error ("invalid use of qualified-name %<%T::%D%>",
9032 qualifying_scope, decl);
9033 return error_mark_node;
9036 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
9037 in_namespace = qualifying_scope;
9039 switch (TREE_CODE (decl))
9041 case BIT_NOT_EXPR:
9043 tree type;
9045 if (innermost_code != cdk_function)
9047 error ("declaration of %qD as non-function", decl);
9048 return error_mark_node;
9050 else if (!qualifying_scope
9051 && !(current_class_type && at_class_scope_p ()))
9053 error ("declaration of %qD as non-member", decl);
9054 return error_mark_node;
9057 type = TREE_OPERAND (decl, 0);
9058 if (TYPE_P (type))
9059 type = constructor_name (type);
9060 name = identifier_to_locale (IDENTIFIER_POINTER (type));
9061 dname = decl;
9063 break;
9065 case TEMPLATE_ID_EXPR:
9067 tree fns = TREE_OPERAND (decl, 0);
9069 dname = fns;
9070 if (!identifier_p (dname))
9072 if (variable_template_p (dname))
9073 dname = DECL_NAME (dname);
9074 else
9076 gcc_assert (is_overloaded_fn (dname));
9077 dname = DECL_NAME (get_first_fn (dname));
9081 /* Fall through. */
9083 case IDENTIFIER_NODE:
9084 if (identifier_p (decl))
9085 dname = decl;
9087 if (C_IS_RESERVED_WORD (dname))
9089 error ("declarator-id missing; using reserved word %qD",
9090 dname);
9091 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
9093 else if (!IDENTIFIER_TYPENAME_P (dname))
9094 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
9095 else
9097 gcc_assert (flags == NO_SPECIAL);
9098 flags = TYPENAME_FLAG;
9099 ctor_return_type = TREE_TYPE (dname);
9100 sfk = sfk_conversion;
9101 if (is_typename_at_global_scope (dname))
9102 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
9103 else
9104 name = "<invalid operator>";
9106 break;
9108 default:
9109 gcc_unreachable ();
9111 break;
9114 case cdk_array:
9115 case cdk_pointer:
9116 case cdk_reference:
9117 case cdk_ptrmem:
9118 break;
9120 case cdk_error:
9121 return error_mark_node;
9123 default:
9124 gcc_unreachable ();
9126 if (id_declarator->kind == cdk_id)
9127 break;
9130 /* [dcl.fct.edf]
9132 The declarator in a function-definition shall have the form
9133 D1 ( parameter-declaration-clause) ... */
9134 if (funcdef_flag && innermost_code != cdk_function)
9136 error ("function definition does not declare parameters");
9137 return error_mark_node;
9140 if (flags == TYPENAME_FLAG
9141 && innermost_code != cdk_function
9142 && ! (ctype && !declspecs->any_specifiers_p))
9144 error ("declaration of %qD as non-function", dname);
9145 return error_mark_node;
9148 if (dname
9149 && identifier_p (dname)
9150 && UDLIT_OPER_P (dname)
9151 && innermost_code != cdk_function)
9153 error ("declaration of %qD as non-function", dname);
9154 return error_mark_node;
9157 if (dname && IDENTIFIER_OPNAME_P (dname))
9159 if (typedef_p)
9161 error ("declaration of %qD as %<typedef%>", dname);
9162 return error_mark_node;
9164 else if (decl_context == PARM || decl_context == CATCHPARM)
9166 error ("declaration of %qD as parameter", dname);
9167 return error_mark_node;
9171 /* Anything declared one level down from the top level
9172 must be one of the parameters of a function
9173 (because the body is at least two levels down). */
9175 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9176 by not allowing C++ class definitions to specify their parameters
9177 with xdecls (must be spec.d in the parmlist).
9179 Since we now wait to push a class scope until we are sure that
9180 we are in a legitimate method context, we must set oldcname
9181 explicitly (since current_class_name is not yet alive).
9183 We also want to avoid calling this a PARM if it is in a namespace. */
9185 if (decl_context == NORMAL && !toplevel_bindings_p ())
9187 cp_binding_level *b = current_binding_level;
9188 current_binding_level = b->level_chain;
9189 if (current_binding_level != 0 && toplevel_bindings_p ())
9190 decl_context = PARM;
9191 current_binding_level = b;
9194 if (name == NULL)
9195 name = decl_context == PARM ? "parameter" : "type name";
9197 if (constexpr_p && typedef_p)
9199 error ("%<constexpr%> cannot appear in a typedef declaration");
9200 return error_mark_node;
9203 /* If there were multiple types specified in the decl-specifier-seq,
9204 issue an error message. */
9205 if (declspecs->multiple_types_p)
9207 error ("two or more data types in declaration of %qs", name);
9208 return error_mark_node;
9211 if (declspecs->conflicting_specifiers_p)
9213 error ("conflicting specifiers in declaration of %qs", name);
9214 return error_mark_node;
9217 /* Extract the basic type from the decl-specifier-seq. */
9218 type = declspecs->type;
9219 if (type == error_mark_node)
9221 type = NULL_TREE;
9222 type_was_error_mark_node = true;
9224 /* If the entire declaration is itself tagged as deprecated then
9225 suppress reports of deprecated items. */
9226 if (type && TREE_DEPRECATED (type)
9227 && deprecated_state != DEPRECATED_SUPPRESS)
9228 warn_deprecated_use (type, NULL_TREE);
9229 if (type && TREE_CODE (type) == TYPE_DECL)
9231 typedef_decl = type;
9232 type = TREE_TYPE (typedef_decl);
9233 if (TREE_DEPRECATED (type)
9234 && DECL_ARTIFICIAL (typedef_decl)
9235 && deprecated_state != DEPRECATED_SUPPRESS)
9236 warn_deprecated_use (type, NULL_TREE);
9238 /* No type at all: default to `int', and set DEFAULTED_INT
9239 because it was not a user-defined typedef. */
9240 if (type == NULL_TREE)
9242 if (signed_p || unsigned_p || long_p || short_p)
9244 /* These imply 'int'. */
9245 type = integer_type_node;
9246 defaulted_int = 1;
9248 /* If we just have "complex", it is equivalent to "complex double". */
9249 else if (!longlong && !explicit_intN
9250 && decl_spec_seq_has_spec_p (declspecs, ds_complex))
9252 type = double_type_node;
9253 pedwarn (declspecs->locations[ds_complex], OPT_Wpedantic,
9254 "ISO C++ does not support plain %<complex%> meaning "
9255 "%<double complex%>");
9258 /* Gather flags. */
9259 explicit_int = declspecs->explicit_int_p;
9260 explicit_char = declspecs->explicit_char_p;
9262 #if 0
9263 /* See the code below that used this. */
9264 if (typedef_decl)
9265 decl_attr = DECL_ATTRIBUTES (typedef_decl);
9266 #endif
9267 typedef_type = type;
9270 if (sfk != sfk_conversion)
9271 ctor_return_type = ctype;
9273 if (sfk != sfk_none)
9274 type = check_special_function_return_type (sfk, type,
9275 ctor_return_type);
9276 else if (type == NULL_TREE)
9278 int is_main;
9280 explicit_int = -1;
9282 /* We handle `main' specially here, because 'main () { }' is so
9283 common. With no options, it is allowed. With -Wreturn-type,
9284 it is a warning. It is only an error with -pedantic-errors. */
9285 is_main = (funcdef_flag
9286 && dname && identifier_p (dname)
9287 && MAIN_NAME_P (dname)
9288 && ctype == NULL_TREE
9289 && in_namespace == NULL_TREE
9290 && current_namespace == global_namespace);
9292 if (type_was_error_mark_node)
9293 /* We've already issued an error, don't complain more. */;
9294 else if (in_system_header_at (input_location) || flag_ms_extensions)
9295 /* Allow it, sigh. */;
9296 else if (! is_main)
9297 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
9298 else if (pedantic)
9299 pedwarn (input_location, OPT_Wpedantic,
9300 "ISO C++ forbids declaration of %qs with no type", name);
9301 else
9302 warning (OPT_Wreturn_type,
9303 "ISO C++ forbids declaration of %qs with no type", name);
9305 type = integer_type_node;
9308 ctype = NULL_TREE;
9310 if (explicit_intN)
9312 if (! int_n_enabled_p[declspecs->int_n_idx])
9314 error ("%<__int%d%> is not supported by this target",
9315 int_n_data[declspecs->int_n_idx].bitsize);
9316 explicit_intN = false;
9318 else if (pedantic && ! in_system_header_at (input_location))
9319 pedwarn (input_location, OPT_Wpedantic,
9320 "ISO C++ does not support %<__int%d%> for %qs",
9321 int_n_data[declspecs->int_n_idx].bitsize, name);
9324 /* Now process the modifiers that were specified
9325 and check for invalid combinations. */
9327 /* Long double is a special combination. */
9328 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
9330 long_p = false;
9331 type = cp_build_qualified_type (long_double_type_node,
9332 cp_type_quals (type));
9335 /* Check all other uses of type modifiers. */
9337 if (unsigned_p || signed_p || long_p || short_p)
9339 int ok = 0;
9341 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
9342 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
9343 else if (signed_p && unsigned_p)
9344 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
9345 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
9346 error ("%<long long%> invalid for %qs", name);
9347 else if (long_p && TREE_CODE (type) == REAL_TYPE)
9348 error ("%<long%> invalid for %qs", name);
9349 else if (short_p && TREE_CODE (type) == REAL_TYPE)
9350 error ("%<short%> invalid for %qs", name);
9351 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
9352 error ("%<long%> or %<short%> invalid for %qs", name);
9353 else if ((long_p || short_p || explicit_char || explicit_int) && explicit_intN)
9354 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name);
9355 else if ((long_p || short_p) && explicit_char)
9356 error ("%<long%> or %<short%> specified with char for %qs", name);
9357 else if (long_p && short_p)
9358 error ("%<long%> and %<short%> specified together for %qs", name);
9359 else if (type == char16_type_node || type == char32_type_node)
9361 if (signed_p || unsigned_p)
9362 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
9363 else if (short_p || long_p)
9364 error ("%<short%> or %<long%> invalid for %qs", name);
9366 else
9368 ok = 1;
9369 if (!explicit_int && !defaulted_int && !explicit_char && !explicit_intN && pedantic)
9371 pedwarn (input_location, OPT_Wpedantic,
9372 "long, short, signed or unsigned used invalidly for %qs",
9373 name);
9374 if (flag_pedantic_errors)
9375 ok = 0;
9379 /* Discard the type modifiers if they are invalid. */
9380 if (! ok)
9382 unsigned_p = false;
9383 signed_p = false;
9384 long_p = false;
9385 short_p = false;
9386 longlong = 0;
9390 /* Decide whether an integer type is signed or not.
9391 Optionally treat bitfields as signed by default. */
9392 if (unsigned_p
9393 /* [class.bit]
9395 It is implementation-defined whether a plain (neither
9396 explicitly signed or unsigned) char, short, int, or long
9397 bit-field is signed or unsigned.
9399 Naturally, we extend this to long long as well. Note that
9400 this does not include wchar_t. */
9401 || (bitfield && !flag_signed_bitfields
9402 && !signed_p
9403 /* A typedef for plain `int' without `signed' can be
9404 controlled just like plain `int', but a typedef for
9405 `signed int' cannot be so controlled. */
9406 && !(typedef_decl
9407 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
9408 && TREE_CODE (type) == INTEGER_TYPE
9409 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
9411 if (explicit_intN)
9412 type = int_n_trees[declspecs->int_n_idx].unsigned_type;
9413 else if (longlong)
9414 type = long_long_unsigned_type_node;
9415 else if (long_p)
9416 type = long_unsigned_type_node;
9417 else if (short_p)
9418 type = short_unsigned_type_node;
9419 else if (type == char_type_node)
9420 type = unsigned_char_type_node;
9421 else if (typedef_decl)
9422 type = unsigned_type_for (type);
9423 else
9424 type = unsigned_type_node;
9426 else if (signed_p && type == char_type_node)
9427 type = signed_char_type_node;
9428 else if (explicit_intN)
9429 type = int_n_trees[declspecs->int_n_idx].signed_type;
9430 else if (longlong)
9431 type = long_long_integer_type_node;
9432 else if (long_p)
9433 type = long_integer_type_node;
9434 else if (short_p)
9435 type = short_integer_type_node;
9437 if (decl_spec_seq_has_spec_p (declspecs, ds_complex))
9439 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
9440 error ("complex invalid for %qs", name);
9441 /* If a modifier is specified, the resulting complex is the complex
9442 form of TYPE. E.g, "complex short" is "complex short int". */
9443 else if (type == integer_type_node)
9444 type = complex_integer_type_node;
9445 else if (type == float_type_node)
9446 type = complex_float_type_node;
9447 else if (type == double_type_node)
9448 type = complex_double_type_node;
9449 else if (type == long_double_type_node)
9450 type = complex_long_double_type_node;
9451 else
9452 type = build_complex_type (type);
9455 type_quals = TYPE_UNQUALIFIED;
9456 if (decl_spec_seq_has_spec_p (declspecs, ds_const))
9457 type_quals |= TYPE_QUAL_CONST;
9458 if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
9459 type_quals |= TYPE_QUAL_VOLATILE;
9460 if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
9461 type_quals |= TYPE_QUAL_RESTRICT;
9462 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
9463 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9464 ctor_return_type);
9466 /* If we're using the injected-class-name to form a compound type or a
9467 declaration, replace it with the underlying class so we don't get
9468 redundant typedefs in the debug output. But if we are returning the
9469 type unchanged, leave it alone so that it's available to
9470 maybe_get_template_decl_from_type_decl. */
9471 if (CLASS_TYPE_P (type)
9472 && DECL_SELF_REFERENCE_P (TYPE_NAME (type))
9473 && type == TREE_TYPE (TYPE_NAME (type))
9474 && (declarator || type_quals))
9475 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
9477 type_quals |= cp_type_quals (type);
9478 type = cp_build_qualified_type_real
9479 (type, type_quals, ((((typedef_decl && !DECL_ARTIFICIAL (typedef_decl))
9480 || declspecs->decltype_p)
9481 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
9482 /* We might have ignored or rejected some of the qualifiers. */
9483 type_quals = cp_type_quals (type);
9485 staticp = 0;
9486 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline);
9487 virtualp = decl_spec_seq_has_spec_p (declspecs, ds_virtual);
9488 explicitp = decl_spec_seq_has_spec_p (declspecs, ds_explicit);
9490 storage_class = declspecs->storage_class;
9491 if (storage_class == sc_static)
9492 staticp = 1 + (decl_context == FIELD);
9494 if (virtualp && staticp == 2)
9496 error ("member %qD cannot be declared both virtual and static", dname);
9497 storage_class = sc_none;
9498 staticp = 0;
9500 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
9502 /* Issue errors about use of storage classes for parameters. */
9503 if (decl_context == PARM)
9505 if (typedef_p)
9507 error ("typedef declaration invalid in parameter declaration");
9508 return error_mark_node;
9510 else if (template_parm_flag && storage_class != sc_none)
9512 error ("storage class specified for template parameter %qs", name);
9513 return error_mark_node;
9515 else if (storage_class == sc_static
9516 || storage_class == sc_extern
9517 || thread_p)
9518 error ("storage class specifiers invalid in parameter declarations");
9520 /* Function parameters cannot be constexpr. If we saw one, moan
9521 and pretend it wasn't there. */
9522 if (constexpr_p)
9524 error ("a parameter cannot be declared %<constexpr%>");
9525 constexpr_p = 0;
9529 /* Give error if `virtual' is used outside of class declaration. */
9530 if (virtualp
9531 && (current_class_name == NULL_TREE || decl_context != FIELD))
9533 error ("%<virtual%> outside class declaration");
9534 virtualp = 0;
9537 /* Static anonymous unions are dealt with here. */
9538 if (staticp && decl_context == TYPENAME
9539 && declspecs->type
9540 && ANON_AGGR_TYPE_P (declspecs->type))
9541 decl_context = FIELD;
9543 /* Warn about storage classes that are invalid for certain
9544 kinds of declarations (parameters, typenames, etc.). */
9545 if (thread_p
9546 && ((storage_class
9547 && storage_class != sc_extern
9548 && storage_class != sc_static)
9549 || typedef_p))
9551 error ("multiple storage classes in declaration of %qs", name);
9552 thread_p = false;
9554 if (decl_context != NORMAL
9555 && ((storage_class != sc_none
9556 && storage_class != sc_mutable)
9557 || thread_p))
9559 if ((decl_context == PARM || decl_context == CATCHPARM)
9560 && (storage_class == sc_register
9561 || storage_class == sc_auto))
9563 else if (typedef_p)
9565 else if (decl_context == FIELD
9566 /* C++ allows static class elements. */
9567 && storage_class == sc_static)
9568 /* C++ also allows inlines and signed and unsigned elements,
9569 but in those cases we don't come in here. */
9571 else
9573 if (decl_context == FIELD)
9574 error ("storage class specified for %qs", name);
9575 else
9577 if (decl_context == PARM || decl_context == CATCHPARM)
9578 error ("storage class specified for parameter %qs", name);
9579 else
9580 error ("storage class specified for typename");
9582 if (storage_class == sc_register
9583 || storage_class == sc_auto
9584 || storage_class == sc_extern
9585 || thread_p)
9586 storage_class = sc_none;
9589 else if (storage_class == sc_extern && funcdef_flag
9590 && ! toplevel_bindings_p ())
9591 error ("nested function %qs declared %<extern%>", name);
9592 else if (toplevel_bindings_p ())
9594 if (storage_class == sc_auto)
9595 error ("top-level declaration of %qs specifies %<auto%>", name);
9597 else if (thread_p
9598 && storage_class != sc_extern
9599 && storage_class != sc_static)
9601 if (declspecs->gnu_thread_keyword_p)
9602 pedwarn (input_location, 0, "function-scope %qs implicitly auto and "
9603 "declared %<__thread%>", name);
9605 /* When thread_local is applied to a variable of block scope the
9606 storage-class-specifier static is implied if it does not appear
9607 explicitly. */
9608 storage_class = declspecs->storage_class = sc_static;
9609 staticp = 1;
9612 if (storage_class && friendp)
9614 error ("storage class specifiers invalid in friend function declarations");
9615 storage_class = sc_none;
9616 staticp = 0;
9619 if (!id_declarator)
9620 unqualified_id = NULL_TREE;
9621 else
9623 unqualified_id = id_declarator->u.id.unqualified_name;
9624 switch (TREE_CODE (unqualified_id))
9626 case BIT_NOT_EXPR:
9627 unqualified_id = TREE_OPERAND (unqualified_id, 0);
9628 if (TYPE_P (unqualified_id))
9629 unqualified_id = constructor_name (unqualified_id);
9630 break;
9632 case IDENTIFIER_NODE:
9633 case TEMPLATE_ID_EXPR:
9634 break;
9636 default:
9637 gcc_unreachable ();
9641 if (declspecs->std_attributes)
9643 /* Apply the c++11 attributes to the type preceding them. */
9644 input_location = declspecs->locations[ds_std_attribute];
9645 decl_attributes (&type, declspecs->std_attributes, 0);
9646 input_location = saved_loc;
9649 /* Determine the type of the entity declared by recurring on the
9650 declarator. */
9651 for (; declarator; declarator = declarator->declarator)
9653 const cp_declarator *inner_declarator;
9654 tree attrs;
9656 if (type == error_mark_node)
9657 return error_mark_node;
9659 attrs = declarator->attributes;
9660 if (attrs)
9662 int attr_flags;
9664 attr_flags = 0;
9665 if (declarator == NULL || declarator->kind == cdk_id)
9666 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
9667 if (declarator->kind == cdk_function)
9668 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
9669 if (declarator->kind == cdk_array)
9670 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
9671 returned_attrs = decl_attributes (&type,
9672 chainon (returned_attrs, attrs),
9673 attr_flags);
9676 if (declarator->kind == cdk_id)
9677 break;
9679 inner_declarator = declarator->declarator;
9681 switch (declarator->kind)
9683 case cdk_array:
9684 type = create_array_type_for_decl (dname, type,
9685 declarator->u.array.bounds);
9686 if (declarator->std_attributes)
9687 /* [dcl.array]/1:
9689 The optional attribute-specifier-seq appertains to the
9690 array. */
9691 returned_attrs = chainon (returned_attrs,
9692 declarator->std_attributes);
9693 break;
9695 case cdk_function:
9697 tree arg_types;
9698 int funcdecl_p;
9700 /* Declaring a function type.
9701 Make sure we have a valid type for the function to return. */
9703 if (type_quals != TYPE_UNQUALIFIED)
9705 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
9706 warning (OPT_Wignored_qualifiers,
9707 "type qualifiers ignored on function return type");
9708 /* We now know that the TYPE_QUALS don't apply to the
9709 decl, but to its return type. */
9710 type_quals = TYPE_UNQUALIFIED;
9712 errmsg = targetm.invalid_return_type (type);
9713 if (errmsg)
9715 error (errmsg);
9716 type = integer_type_node;
9719 /* Error about some types functions can't return. */
9721 if (TREE_CODE (type) == FUNCTION_TYPE)
9723 error ("%qs declared as function returning a function", name);
9724 return error_mark_node;
9726 if (TREE_CODE (type) == ARRAY_TYPE)
9728 error ("%qs declared as function returning an array", name);
9729 return error_mark_node;
9732 input_location = declspecs->locations[ds_type_spec];
9733 abstract_virtuals_error (ACU_RETURN, type);
9734 input_location = saved_loc;
9736 /* Pick up type qualifiers which should be applied to `this'. */
9737 memfn_quals = declarator->u.function.qualifiers;
9738 /* Pick up virt-specifiers. */
9739 virt_specifiers = declarator->u.function.virt_specifiers;
9740 /* And ref-qualifier, too */
9741 rqual = declarator->u.function.ref_qualifier;
9742 /* Pick up the exception specifications. */
9743 raises = declarator->u.function.exception_specification;
9744 /* If the exception-specification is ill-formed, let's pretend
9745 there wasn't one. */
9746 if (raises == error_mark_node)
9747 raises = NULL_TREE;
9749 /* Say it's a definition only for the CALL_EXPR
9750 closest to the identifier. */
9751 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
9753 /* Handle a late-specified return type. */
9754 if (funcdecl_p)
9756 if (type_uses_auto (type))
9758 if (!declarator->u.function.late_return_type)
9760 if (current_class_type
9761 && LAMBDA_TYPE_P (current_class_type))
9762 /* OK for C++11 lambdas. */;
9763 else if (cxx_dialect < cxx14)
9765 error ("%qs function uses "
9766 "%<auto%> type specifier without trailing "
9767 "return type", name);
9768 inform (input_location, "deduced return type "
9769 "only available with -std=c++14 or "
9770 "-std=gnu++14");
9772 else if (virtualp)
9774 error ("virtual function cannot "
9775 "have deduced return type");
9776 virtualp = false;
9779 else if (!is_auto (type))
9781 error ("%qs function with trailing return type has"
9782 " %qT as its type rather than plain %<auto%>",
9783 name, type);
9784 return error_mark_node;
9787 else if (declarator->u.function.late_return_type)
9789 if (cxx_dialect < cxx11)
9790 /* Not using maybe_warn_cpp0x because this should
9791 always be an error. */
9792 error ("trailing return type only available with "
9793 "-std=c++11 or -std=gnu++11");
9794 else
9795 error ("%qs function with trailing return type not "
9796 "declared with %<auto%> type specifier", name);
9797 return error_mark_node;
9800 type = splice_late_return_type
9801 (type, declarator->u.function.late_return_type);
9802 if (type == error_mark_node)
9803 return error_mark_node;
9805 if (declarator->u.function.late_return_type)
9806 late_return_type_p = true;
9808 if (ctype == NULL_TREE
9809 && decl_context == FIELD
9810 && funcdecl_p
9811 && friendp == 0)
9812 ctype = current_class_type;
9814 if (ctype && (sfk == sfk_constructor
9815 || sfk == sfk_destructor))
9817 /* We are within a class's scope. If our declarator name
9818 is the same as the class name, and we are defining
9819 a function, then it is a constructor/destructor, and
9820 therefore returns a void type. */
9822 /* ISO C++ 12.4/2. A destructor may not be declared
9823 const or volatile. A destructor may not be static.
9824 A destructor may not be declared with ref-qualifier.
9826 ISO C++ 12.1. A constructor may not be declared
9827 const or volatile. A constructor may not be
9828 virtual. A constructor may not be static.
9829 A constructor may not be declared with ref-qualifier. */
9830 if (staticp == 2)
9831 error ((flags == DTOR_FLAG)
9832 ? G_("destructor cannot be static member function")
9833 : G_("constructor cannot be static member function"));
9834 if (memfn_quals)
9836 error ((flags == DTOR_FLAG)
9837 ? G_("destructors may not be cv-qualified")
9838 : G_("constructors may not be cv-qualified"));
9839 memfn_quals = TYPE_UNQUALIFIED;
9842 if (rqual)
9844 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER);
9845 error ((flags == DTOR_FLAG)
9846 ? "destructors may not be ref-qualified"
9847 : "constructors may not be ref-qualified");
9848 rqual = REF_QUAL_NONE;
9851 if (decl_context == FIELD
9852 && !member_function_or_else (ctype,
9853 current_class_type,
9854 flags))
9855 return error_mark_node;
9857 if (flags != DTOR_FLAG)
9859 /* It's a constructor. */
9860 if (explicitp == 1)
9861 explicitp = 2;
9862 if (virtualp)
9864 permerror (input_location, "constructors cannot be declared virtual");
9865 virtualp = 0;
9867 if (decl_context == FIELD
9868 && sfk != sfk_constructor)
9869 return error_mark_node;
9871 if (decl_context == FIELD)
9872 staticp = 0;
9874 else if (friendp)
9876 if (virtualp)
9878 /* Cannot be both friend and virtual. */
9879 error ("virtual functions cannot be friends");
9880 friendp = 0;
9882 if (decl_context == NORMAL)
9883 error ("friend declaration not in class definition");
9884 if (current_function_decl && funcdef_flag)
9885 error ("can%'t define friend function %qs in a local "
9886 "class definition",
9887 name);
9889 else if (ctype && sfk == sfk_conversion)
9891 if (explicitp == 1)
9893 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION);
9894 explicitp = 2;
9898 arg_types = grokparms (declarator->u.function.parameters,
9899 &parms);
9901 if (inner_declarator
9902 && inner_declarator->kind == cdk_id
9903 && inner_declarator->u.id.sfk == sfk_destructor
9904 && arg_types != void_list_node)
9906 error ("destructors may not have parameters");
9907 arg_types = void_list_node;
9908 parms = NULL_TREE;
9911 type = build_function_type (type, arg_types);
9912 if (declarator->std_attributes)
9913 /* [dcl.fct]/2:
9915 The optional attribute-specifier-seq appertains to
9916 the function type. */
9917 decl_attributes (&type, declarator->std_attributes,
9920 break;
9922 case cdk_pointer:
9923 case cdk_reference:
9924 case cdk_ptrmem:
9925 /* Filter out pointers-to-references and references-to-references.
9926 We can get these if a TYPE_DECL is used. */
9928 if (TREE_CODE (type) == REFERENCE_TYPE)
9930 if (declarator->kind != cdk_reference)
9932 error ("cannot declare pointer to %q#T", type);
9933 type = TREE_TYPE (type);
9936 /* In C++0x, we allow reference to reference declarations
9937 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9938 and template type arguments [14.3.1/4 temp.arg.type]. The
9939 check for direct reference to reference declarations, which
9940 are still forbidden, occurs below. Reasoning behind the change
9941 can be found in DR106, DR540, and the rvalue reference
9942 proposals. */
9943 else if (cxx_dialect == cxx98)
9945 error ("cannot declare reference to %q#T", type);
9946 type = TREE_TYPE (type);
9949 else if (VOID_TYPE_P (type))
9951 if (declarator->kind == cdk_reference)
9952 error ("cannot declare reference to %q#T", type);
9953 else if (declarator->kind == cdk_ptrmem)
9954 error ("cannot declare pointer to %q#T member", type);
9957 /* We now know that the TYPE_QUALS don't apply to the decl,
9958 but to the target of the pointer. */
9959 type_quals = TYPE_UNQUALIFIED;
9961 /* This code used to handle METHOD_TYPE, but I don't think it's
9962 possible to get it here anymore. */
9963 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
9964 if (declarator->kind == cdk_ptrmem
9965 && TREE_CODE (type) == FUNCTION_TYPE)
9967 memfn_quals |= type_memfn_quals (type);
9968 type = build_memfn_type (type,
9969 declarator->u.pointer.class_type,
9970 memfn_quals,
9971 rqual);
9972 if (type == error_mark_node)
9973 return error_mark_node;
9975 rqual = REF_QUAL_NONE;
9976 memfn_quals = TYPE_UNQUALIFIED;
9979 if (TREE_CODE (type) == FUNCTION_TYPE
9980 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
9981 || type_memfn_rqual (type) != REF_QUAL_NONE))
9982 error (declarator->kind == cdk_reference
9983 ? G_("cannot declare reference to qualified function type %qT")
9984 : G_("cannot declare pointer to qualified function type %qT"),
9985 type);
9987 if (cxx_dialect >= cxx14 && array_of_runtime_bound_p (type)
9988 && (flag_iso || warn_vla > 0))
9989 pedwarn (input_location, OPT_Wvla,
9990 declarator->kind == cdk_reference
9991 ? G_("reference to array of runtime bound")
9992 : G_("pointer to array of runtime bound"));
9994 /* When the pointed-to type involves components of variable size,
9995 care must be taken to ensure that the size evaluation code is
9996 emitted early enough to dominate all the possible later uses
9997 and late enough for the variables on which it depends to have
9998 been assigned.
10000 This is expected to happen automatically when the pointed-to
10001 type has a name/declaration of it's own, but special attention
10002 is required if the type is anonymous.
10004 We handle the NORMAL and FIELD contexts here by inserting a
10005 dummy statement that just evaluates the size at a safe point
10006 and ensures it is not deferred until e.g. within a deeper
10007 conditional context (c++/43555).
10009 We expect nothing to be needed here for PARM or TYPENAME.
10010 Evaluating the size at this point for TYPENAME would
10011 actually be incorrect, as we might be in the middle of an
10012 expression with side effects on the pointed-to type size
10013 "arguments" prior to the pointer declaration point and the
10014 size evaluation could end up prior to the side effects. */
10016 if (!TYPE_NAME (type)
10017 && (decl_context == NORMAL || decl_context == FIELD)
10018 && at_function_scope_p ()
10019 && variably_modified_type_p (type, NULL_TREE))
10020 /* Force evaluation of the SAVE_EXPR. */
10021 finish_expr_stmt (TYPE_SIZE (type));
10023 if (declarator->kind == cdk_reference)
10025 /* In C++0x, the type we are creating a reference to might be
10026 a typedef which is itself a reference type. In that case,
10027 we follow the reference collapsing rules in
10028 [7.1.3/8 dcl.typedef] to create the final reference type:
10030 "If a typedef TD names a type that is a reference to a type
10031 T, an attempt to create the type 'lvalue reference to cv TD'
10032 creates the type 'lvalue reference to T,' while an attempt
10033 to create the type "rvalue reference to cv TD' creates the
10034 type TD."
10036 if (VOID_TYPE_P (type))
10037 /* We already gave an error. */;
10038 else if (TREE_CODE (type) == REFERENCE_TYPE)
10040 if (declarator->u.reference.rvalue_ref)
10041 /* Leave type alone. */;
10042 else
10043 type = cp_build_reference_type (TREE_TYPE (type), false);
10045 else
10046 type = cp_build_reference_type
10047 (type, declarator->u.reference.rvalue_ref);
10049 /* In C++0x, we need this check for direct reference to
10050 reference declarations, which are forbidden by
10051 [8.3.2/5 dcl.ref]. Reference to reference declarations
10052 are only allowed indirectly through typedefs and template
10053 type arguments. Example:
10055 void foo(int & &); // invalid ref-to-ref decl
10057 typedef int & int_ref;
10058 void foo(int_ref &); // valid ref-to-ref decl
10060 if (inner_declarator && inner_declarator->kind == cdk_reference)
10061 error ("cannot declare reference to %q#T, which is not "
10062 "a typedef or a template type argument", type);
10064 else if (TREE_CODE (type) == METHOD_TYPE)
10065 type = build_ptrmemfunc_type (build_pointer_type (type));
10066 else if (declarator->kind == cdk_ptrmem)
10068 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
10069 != NAMESPACE_DECL);
10070 if (declarator->u.pointer.class_type == error_mark_node)
10071 /* We will already have complained. */
10072 type = error_mark_node;
10073 else
10074 type = build_ptrmem_type (declarator->u.pointer.class_type,
10075 type);
10077 else
10078 type = build_pointer_type (type);
10080 /* Process a list of type modifier keywords (such as
10081 const or volatile) that were given inside the `*' or `&'. */
10083 if (declarator->u.pointer.qualifiers)
10085 type
10086 = cp_build_qualified_type (type,
10087 declarator->u.pointer.qualifiers);
10088 type_quals = cp_type_quals (type);
10091 /* Apply C++11 attributes to the pointer, and not to the
10092 type pointed to. This is unlike what is done for GNU
10093 attributes above. It is to comply with [dcl.ptr]/1:
10095 [the optional attribute-specifier-seq (7.6.1) appertains
10096 to the pointer and not to the object pointed to]. */
10097 if (declarator->std_attributes)
10098 decl_attributes (&type, declarator->std_attributes,
10101 ctype = NULL_TREE;
10102 break;
10104 case cdk_error:
10105 break;
10107 default:
10108 gcc_unreachable ();
10112 /* A `constexpr' specifier used in an object declaration declares
10113 the object as `const'. */
10114 if (constexpr_p && innermost_code != cdk_function)
10116 if (type_quals & TYPE_QUAL_VOLATILE)
10117 error ("both %<volatile%> and %<constexpr%> cannot be used here");
10118 if (TREE_CODE (type) != REFERENCE_TYPE)
10120 type_quals |= TYPE_QUAL_CONST;
10121 type = cp_build_qualified_type (type, type_quals);
10125 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
10126 && TREE_CODE (type) != FUNCTION_TYPE
10127 && TREE_CODE (type) != METHOD_TYPE
10128 && !variable_template_p (TREE_OPERAND (unqualified_id, 0)))
10130 error ("template-id %qD used as a declarator",
10131 unqualified_id);
10132 unqualified_id = dname;
10135 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10136 qualified with a class-name, turn it into a METHOD_TYPE, unless
10137 we know that the function is static. We take advantage of this
10138 opportunity to do other processing that pertains to entities
10139 explicitly declared to be class members. Note that if DECLARATOR
10140 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10141 would not have exited the loop above. */
10142 if (declarator
10143 && declarator->u.id.qualifying_scope
10144 && MAYBE_CLASS_TYPE_P (declarator->u.id.qualifying_scope))
10146 ctype = declarator->u.id.qualifying_scope;
10147 ctype = TYPE_MAIN_VARIANT (ctype);
10148 template_count = num_template_headers_for_class (ctype);
10150 if (ctype == current_class_type)
10152 if (friendp)
10154 permerror (input_location, "member functions are implicitly friends of their class");
10155 friendp = 0;
10157 else
10158 permerror (declarator->id_loc,
10159 "extra qualification %<%T::%> on member %qs",
10160 ctype, name);
10162 else if (/* If the qualifying type is already complete, then we
10163 can skip the following checks. */
10164 !COMPLETE_TYPE_P (ctype)
10165 && (/* If the function is being defined, then
10166 qualifying type must certainly be complete. */
10167 funcdef_flag
10168 /* A friend declaration of "T::f" is OK, even if
10169 "T" is a template parameter. But, if this
10170 function is not a friend, the qualifying type
10171 must be a class. */
10172 || (!friendp && !CLASS_TYPE_P (ctype))
10173 /* For a declaration, the type need not be
10174 complete, if either it is dependent (since there
10175 is no meaningful definition of complete in that
10176 case) or the qualifying class is currently being
10177 defined. */
10178 || !(dependent_type_p (ctype)
10179 || currently_open_class (ctype)))
10180 /* Check that the qualifying type is complete. */
10181 && !complete_type_or_else (ctype, NULL_TREE))
10182 return error_mark_node;
10183 else if (TREE_CODE (type) == FUNCTION_TYPE)
10185 if (current_class_type
10186 && (!friendp || funcdef_flag))
10188 error (funcdef_flag
10189 ? G_("cannot define member function %<%T::%s%> "
10190 "within %<%T%>")
10191 : G_("cannot declare member function %<%T::%s%> "
10192 "within %<%T%>"),
10193 ctype, name, current_class_type);
10194 return error_mark_node;
10197 else if (typedef_p && current_class_type)
10199 error ("cannot declare member %<%T::%s%> within %qT",
10200 ctype, name, current_class_type);
10201 return error_mark_node;
10205 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0)
10206 ctype = current_class_type;
10208 /* Now TYPE has the actual type. */
10210 if (returned_attrs)
10212 if (attrlist)
10213 *attrlist = chainon (returned_attrs, *attrlist);
10214 else
10215 attrlist = &returned_attrs;
10218 if (declarator
10219 && declarator->kind == cdk_id
10220 && declarator->std_attributes)
10221 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10222 a declarator-id appertains to the entity that is declared. */
10223 *attrlist = chainon (*attrlist, declarator->std_attributes);
10225 /* Handle parameter packs. */
10226 if (parameter_pack_p)
10228 if (decl_context == PARM)
10229 /* Turn the type into a pack expansion.*/
10230 type = make_pack_expansion (type);
10231 else
10232 error ("non-parameter %qs cannot be a parameter pack", name);
10235 /* Did array size calculations overflow or does the array cover more
10236 than half of the address-space? */
10237 if (TREE_CODE (type) == ARRAY_TYPE
10238 && COMPLETE_TYPE_P (type)
10239 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
10240 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type)))
10242 error ("size of array %qs is too large", name);
10243 /* If we proceed with the array type as it is, we'll eventually
10244 crash in tree_to_[su]hwi(). */
10245 type = error_mark_node;
10248 if ((decl_context == FIELD || decl_context == PARM)
10249 && !processing_template_decl
10250 && variably_modified_type_p (type, NULL_TREE))
10252 if (decl_context == FIELD)
10253 error ("data member may not have variably modified type %qT", type);
10254 else
10255 error ("parameter may not have variably modified type %qT", type);
10256 type = error_mark_node;
10259 if (explicitp == 1 || (explicitp && friendp))
10261 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10262 in the declaration of a constructor or conversion function within
10263 a class definition. */
10264 if (!current_class_type)
10265 error ("%<explicit%> outside class declaration");
10266 else if (friendp)
10267 error ("%<explicit%> in friend declaration");
10268 else
10269 error ("only declarations of constructors and conversion operators "
10270 "can be %<explicit%>");
10271 explicitp = 0;
10274 if (storage_class == sc_mutable)
10276 if (decl_context != FIELD || friendp)
10278 error ("non-member %qs cannot be declared %<mutable%>", name);
10279 storage_class = sc_none;
10281 else if (decl_context == TYPENAME || typedef_p)
10283 error ("non-object member %qs cannot be declared %<mutable%>", name);
10284 storage_class = sc_none;
10286 else if (TREE_CODE (type) == FUNCTION_TYPE
10287 || TREE_CODE (type) == METHOD_TYPE)
10289 error ("function %qs cannot be declared %<mutable%>", name);
10290 storage_class = sc_none;
10292 else if (staticp)
10294 error ("static %qs cannot be declared %<mutable%>", name);
10295 storage_class = sc_none;
10297 else if (type_quals & TYPE_QUAL_CONST)
10299 error ("const %qs cannot be declared %<mutable%>", name);
10300 storage_class = sc_none;
10302 else if (TREE_CODE (type) == REFERENCE_TYPE)
10304 permerror (input_location, "reference %qs cannot be declared "
10305 "%<mutable%>", name);
10306 storage_class = sc_none;
10310 /* If this is declaring a typedef name, return a TYPE_DECL. */
10311 if (typedef_p && decl_context != TYPENAME)
10313 tree decl;
10315 /* Note that the grammar rejects storage classes
10316 in typenames, fields or parameters. */
10317 if (current_lang_name == lang_name_java)
10318 TYPE_FOR_JAVA (type) = 1;
10320 /* This declaration:
10322 typedef void f(int) const;
10324 declares a function type which is not a member of any
10325 particular class, but which is cv-qualified; for
10326 example "f S::*" declares a pointer to a const-qualified
10327 member function of S. We record the cv-qualification in the
10328 function type. */
10329 if ((rqual || memfn_quals) && TREE_CODE (type) == FUNCTION_TYPE)
10331 type = apply_memfn_quals (type, memfn_quals, rqual);
10333 /* We have now dealt with these qualifiers. */
10334 memfn_quals = TYPE_UNQUALIFIED;
10335 rqual = REF_QUAL_NONE;
10338 if (type_uses_auto (type))
10340 error ("typedef declared %<auto%>");
10341 type = error_mark_node;
10344 if (cxx_dialect >= cxx14 && array_of_runtime_bound_p (type)
10345 && (flag_iso || warn_vla > 0))
10346 pedwarn (input_location, OPT_Wvla,
10347 "typedef naming array of runtime bound");
10349 if (decl_context == FIELD)
10350 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
10351 else
10352 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
10353 if (id_declarator && declarator->u.id.qualifying_scope) {
10354 error_at (DECL_SOURCE_LOCATION (decl),
10355 "typedef name may not be a nested-name-specifier");
10356 TREE_TYPE (decl) = error_mark_node;
10359 if (decl_context != FIELD)
10361 if (!current_function_decl)
10362 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
10363 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
10364 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10365 (current_function_decl)))
10366 /* The TYPE_DECL is "abstract" because there will be
10367 clones of this constructor/destructor, and there will
10368 be copies of this TYPE_DECL generated in those
10369 clones. The decloning optimization (for space) may
10370 revert this subsequently if it determines that
10371 the clones should share a common implementation. */
10372 DECL_ABSTRACT_P (decl) = true;
10374 else if (current_class_type
10375 && constructor_name_p (unqualified_id, current_class_type))
10376 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
10377 "as enclosing class",
10378 unqualified_id);
10380 /* If the user declares "typedef struct {...} foo" then the
10381 struct will have an anonymous name. Fill that name in now.
10382 Nothing can refer to it, so nothing needs know about the name
10383 change. */
10384 if (type != error_mark_node
10385 && unqualified_id
10386 && TYPE_NAME (type)
10387 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10388 && TYPE_ANONYMOUS_P (type)
10389 && declspecs->type_definition_p
10390 && attributes_naming_typedef_ok (*attrlist)
10391 && cp_type_quals (type) == TYPE_UNQUALIFIED)
10393 tree t;
10395 /* Replace the anonymous name with the real name everywhere. */
10396 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10398 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
10399 /* We do not rename the debug info representing the
10400 anonymous tagged type because the standard says in
10401 [dcl.typedef] that the naming applies only for
10402 linkage purposes. */
10403 /*debug_hooks->set_name (t, decl);*/
10404 TYPE_NAME (t) = decl;
10407 if (TYPE_LANG_SPECIFIC (type))
10408 TYPE_WAS_ANONYMOUS (type) = 1;
10410 /* If this is a typedef within a template class, the nested
10411 type is a (non-primary) template. The name for the
10412 template needs updating as well. */
10413 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10414 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10415 = TYPE_IDENTIFIER (type);
10417 /* Adjust linkage now that we aren't anonymous anymore. */
10418 reset_type_linkage (type);
10420 /* FIXME remangle member functions; member functions of a
10421 type with external linkage have external linkage. */
10424 if (signed_p
10425 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
10426 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
10428 bad_specifiers (decl, BSP_TYPE, virtualp,
10429 memfn_quals != TYPE_UNQUALIFIED,
10430 inlinep, friendp, raises != NULL_TREE);
10432 if (decl_spec_seq_has_spec_p (declspecs, ds_alias))
10433 /* Acknowledge that this was written:
10434 `using analias = atype;'. */
10435 TYPE_DECL_ALIAS_P (decl) = 1;
10437 return decl;
10440 /* Detect the case of an array type of unspecified size
10441 which came, as such, direct from a typedef name.
10442 We must copy the type, so that the array's domain can be
10443 individually set by the object's initializer. */
10445 if (type && typedef_type
10446 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
10447 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
10448 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
10450 /* Detect where we're using a typedef of function type to declare a
10451 function. PARMS will not be set, so we must create it now. */
10453 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
10455 tree decls = NULL_TREE;
10456 tree args;
10458 for (args = TYPE_ARG_TYPES (type);
10459 args && args != void_list_node;
10460 args = TREE_CHAIN (args))
10462 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
10464 DECL_CHAIN (decl) = decls;
10465 decls = decl;
10468 parms = nreverse (decls);
10470 if (decl_context != TYPENAME)
10472 /* The qualifiers on the function type become the qualifiers on
10473 the non-static member function. */
10474 memfn_quals |= type_memfn_quals (type);
10475 rqual = type_memfn_rqual (type);
10476 type_quals = TYPE_UNQUALIFIED;
10480 /* If this is a type name (such as, in a cast or sizeof),
10481 compute the type and return it now. */
10483 if (decl_context == TYPENAME)
10485 /* Note that the grammar rejects storage classes
10486 in typenames, fields or parameters. */
10487 if (type_quals != TYPE_UNQUALIFIED)
10488 type_quals = TYPE_UNQUALIFIED;
10490 /* Special case: "friend class foo" looks like a TYPENAME context. */
10491 if (friendp)
10493 if (type_quals != TYPE_UNQUALIFIED)
10495 error ("type qualifiers specified for friend class declaration");
10496 type_quals = TYPE_UNQUALIFIED;
10498 if (inlinep)
10500 error ("%<inline%> specified for friend class declaration");
10501 inlinep = 0;
10504 if (!current_aggr)
10506 /* Don't allow friend declaration without a class-key. */
10507 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10508 permerror (input_location, "template parameters cannot be friends");
10509 else if (TREE_CODE (type) == TYPENAME_TYPE)
10510 permerror (input_location, "friend declaration requires class-key, "
10511 "i.e. %<friend class %T::%D%>",
10512 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
10513 else
10514 permerror (input_location, "friend declaration requires class-key, "
10515 "i.e. %<friend %#T%>",
10516 type);
10519 /* Only try to do this stuff if we didn't already give up. */
10520 if (type != integer_type_node)
10522 /* A friendly class? */
10523 if (current_class_type)
10524 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
10525 /*complain=*/true);
10526 else
10527 error ("trying to make class %qT a friend of global scope",
10528 type);
10530 type = void_type_node;
10533 else if (memfn_quals || rqual)
10535 if (ctype == NULL_TREE
10536 && TREE_CODE (type) == METHOD_TYPE)
10537 ctype = TYPE_METHOD_BASETYPE (type);
10539 if (ctype)
10540 type = build_memfn_type (type, ctype, memfn_quals, rqual);
10541 /* Core issue #547: need to allow this in template type args.
10542 Allow it in general in C++11 for alias-declarations. */
10543 else if ((template_type_arg || cxx_dialect >= cxx11)
10544 && TREE_CODE (type) == FUNCTION_TYPE)
10545 type = apply_memfn_quals (type, memfn_quals, rqual);
10546 else
10547 error ("invalid qualifiers on non-member function type");
10550 return type;
10552 else if (unqualified_id == NULL_TREE && decl_context != PARM
10553 && decl_context != CATCHPARM
10554 && TREE_CODE (type) != UNION_TYPE
10555 && ! bitfield)
10557 error ("abstract declarator %qT used as declaration", type);
10558 return error_mark_node;
10561 /* Only functions may be declared using an operator-function-id. */
10562 if (unqualified_id
10563 && IDENTIFIER_OPNAME_P (unqualified_id)
10564 && TREE_CODE (type) != FUNCTION_TYPE
10565 && TREE_CODE (type) != METHOD_TYPE)
10567 error ("declaration of %qD as non-function", unqualified_id);
10568 return error_mark_node;
10571 /* We don't check parameter types here because we can emit a better
10572 error message later. */
10573 if (decl_context != PARM)
10575 type = check_var_type (unqualified_id, type);
10576 if (type == error_mark_node)
10577 return error_mark_node;
10580 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10581 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10583 if (decl_context == PARM || decl_context == CATCHPARM)
10585 if (ctype || in_namespace)
10586 error ("cannot use %<::%> in parameter declaration");
10588 if (type_uses_auto (type))
10590 if (cxx_dialect >= cxx14)
10591 error ("%<auto%> parameter not permitted in this context");
10592 else
10593 error ("parameter declared %<auto%>");
10594 type = error_mark_node;
10597 /* A parameter declared as an array of T is really a pointer to T.
10598 One declared as a function is really a pointer to a function.
10599 One declared as a member is really a pointer to member. */
10601 if (TREE_CODE (type) == ARRAY_TYPE)
10603 /* Transfer const-ness of array into that of type pointed to. */
10604 type = build_pointer_type (TREE_TYPE (type));
10605 type_quals = TYPE_UNQUALIFIED;
10606 array_parameter_p = true;
10608 else if (TREE_CODE (type) == FUNCTION_TYPE)
10609 type = build_pointer_type (type);
10612 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
10613 && !NEW_DELETE_OPNAME_P (unqualified_id))
10615 cp_cv_quals real_quals = memfn_quals;
10616 if (cxx_dialect < cxx14 && constexpr_p
10617 && sfk != sfk_constructor && sfk != sfk_destructor)
10618 real_quals |= TYPE_QUAL_CONST;
10619 type = build_memfn_type (type, ctype, real_quals, rqual);
10623 tree decl;
10625 if (decl_context == PARM)
10627 decl = cp_build_parm_decl (unqualified_id, type);
10628 DECL_ARRAY_PARAMETER_P (decl) = array_parameter_p;
10630 bad_specifiers (decl, BSP_PARM, virtualp,
10631 memfn_quals != TYPE_UNQUALIFIED,
10632 inlinep, friendp, raises != NULL_TREE);
10634 else if (decl_context == FIELD)
10636 if (!staticp && TREE_CODE (type) != METHOD_TYPE
10637 && type_uses_auto (type))
10639 error ("non-static data member declared %<auto%>");
10640 type = error_mark_node;
10643 /* The C99 flexible array extension. */
10644 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
10645 && TYPE_DOMAIN (type) == NULL_TREE)
10647 tree itype = compute_array_index_type (dname, integer_zero_node,
10648 tf_warning_or_error);
10649 type = build_cplus_array_type (TREE_TYPE (type), itype);
10652 if (type == error_mark_node)
10654 /* Happens when declaring arrays of sizes which
10655 are error_mark_node, for example. */
10656 decl = NULL_TREE;
10658 else if (in_namespace && !friendp)
10660 /* Something like struct S { int N::j; }; */
10661 error ("invalid use of %<::%>");
10662 return error_mark_node;
10664 else if (TREE_CODE (type) == FUNCTION_TYPE
10665 || TREE_CODE (type) == METHOD_TYPE)
10667 int publicp = 0;
10668 tree function_context;
10670 if (friendp == 0)
10672 /* This should never happen in pure C++ (the check
10673 could be an assert). It could happen in
10674 Objective-C++ if someone writes invalid code that
10675 uses a function declaration for an instance
10676 variable or property (instance variables and
10677 properties are parsed as FIELD_DECLs, but they are
10678 part of an Objective-C class, not a C++ class).
10679 That code is invalid and is caught by this
10680 check. */
10681 if (!ctype)
10683 error ("declaration of function %qD in invalid context",
10684 unqualified_id);
10685 return error_mark_node;
10688 /* ``A union may [ ... ] not [ have ] virtual functions.''
10689 ARM 9.5 */
10690 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
10692 error ("function %qD declared virtual inside a union",
10693 unqualified_id);
10694 return error_mark_node;
10697 if (NEW_DELETE_OPNAME_P (unqualified_id))
10699 if (virtualp)
10701 error ("%qD cannot be declared virtual, since it "
10702 "is always static",
10703 unqualified_id);
10704 virtualp = 0;
10709 /* Check that the name used for a destructor makes sense. */
10710 if (sfk == sfk_destructor)
10712 tree uqname = id_declarator->u.id.unqualified_name;
10714 if (!ctype)
10716 gcc_assert (friendp);
10717 error ("expected qualified name in friend declaration "
10718 "for destructor %qD", uqname);
10719 return error_mark_node;
10722 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
10724 error ("declaration of %qD as member of %qT",
10725 uqname, ctype);
10726 return error_mark_node;
10728 if (constexpr_p)
10730 error ("a destructor cannot be %<constexpr%>");
10731 return error_mark_node;
10734 else if (sfk == sfk_constructor && friendp && !ctype)
10736 error ("expected qualified name in friend declaration "
10737 "for constructor %qD",
10738 id_declarator->u.id.unqualified_name);
10739 return error_mark_node;
10742 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
10744 tree tmpl = TREE_OPERAND (unqualified_id, 0);
10745 if (variable_template_p (tmpl))
10747 error ("specialization of variable template %qD "
10748 "declared as function", tmpl);
10749 inform (DECL_SOURCE_LOCATION (tmpl),
10750 "variable template declared here");
10751 return error_mark_node;
10755 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10756 function_context = (ctype != NULL_TREE) ?
10757 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
10758 publicp = (! friendp || ! staticp)
10759 && function_context == NULL_TREE;
10761 if (late_return_type_p)
10762 TYPE_HAS_LATE_RETURN_TYPE (type) = 1;
10764 decl = grokfndecl (ctype, type,
10765 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
10766 ? unqualified_id : dname,
10767 parms,
10768 unqualified_id,
10769 virtualp, flags, memfn_quals, rqual, raises,
10770 friendp ? -1 : 0, friendp, publicp,
10771 inlinep | (2 * constexpr_p),
10772 sfk,
10773 funcdef_flag, template_count, in_namespace,
10774 attrlist, declarator->id_loc);
10775 decl = set_virt_specifiers (decl, virt_specifiers);
10776 if (decl == NULL_TREE)
10777 return error_mark_node;
10778 #if 0
10779 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10780 /* The decl and setting of decl_attr is also turned off. */
10781 decl = build_decl_attribute_variant (decl, decl_attr);
10782 #endif
10784 /* [class.conv.ctor]
10786 A constructor declared without the function-specifier
10787 explicit that can be called with a single parameter
10788 specifies a conversion from the type of its first
10789 parameter to the type of its class. Such a constructor
10790 is called a converting constructor. */
10791 if (explicitp == 2)
10792 DECL_NONCONVERTING_P (decl) = 1;
10794 else if (!staticp && !dependent_type_p (type)
10795 && !COMPLETE_TYPE_P (complete_type (type))
10796 && (TREE_CODE (type) != ARRAY_TYPE
10797 || !COMPLETE_TYPE_P (TREE_TYPE (type))
10798 || initialized == 0))
10800 if (unqualified_id)
10802 error ("field %qD has incomplete type %qT",
10803 unqualified_id, type);
10804 cxx_incomplete_type_inform (strip_array_types (type));
10806 else
10807 error ("name %qT has incomplete type", type);
10809 type = error_mark_node;
10810 decl = NULL_TREE;
10812 else
10814 if (friendp)
10816 error ("%qE is neither function nor member function; "
10817 "cannot be declared friend", unqualified_id);
10818 friendp = 0;
10820 decl = NULL_TREE;
10823 if (friendp)
10825 /* Friends are treated specially. */
10826 if (ctype == current_class_type)
10827 ; /* We already issued a permerror. */
10828 else if (decl && DECL_NAME (decl))
10830 if (template_class_depth (current_class_type) == 0)
10832 decl = check_explicit_specialization
10833 (unqualified_id, decl, template_count,
10834 2 * funcdef_flag + 4);
10835 if (decl == error_mark_node)
10836 return error_mark_node;
10839 decl = do_friend (ctype, unqualified_id, decl,
10840 *attrlist, flags,
10841 funcdef_flag);
10842 return decl;
10844 else
10845 return error_mark_node;
10848 /* Structure field. It may not be a function, except for C++. */
10850 if (decl == NULL_TREE)
10852 if (staticp)
10854 /* C++ allows static class members. All other work
10855 for this is done by grokfield. */
10856 decl = build_lang_decl_loc (declarator
10857 ? declarator->id_loc
10858 : input_location,
10859 VAR_DECL, unqualified_id, type);
10860 set_linkage_for_static_data_member (decl);
10861 /* Even if there is an in-class initialization, DECL
10862 is considered undefined until an out-of-class
10863 definition is provided. */
10864 DECL_EXTERNAL (decl) = 1;
10866 if (thread_p)
10868 set_decl_tls_model (decl, decl_default_tls_model (decl));
10869 if (declspecs->gnu_thread_keyword_p)
10870 DECL_GNU_TLS_P (decl) = true;
10873 if (constexpr_p && !initialized)
10875 error ("constexpr static data member %qD must have an "
10876 "initializer", decl);
10877 constexpr_p = false;
10880 else
10882 if (constexpr_p)
10884 error ("non-static data member %qE declared %<constexpr%>",
10885 unqualified_id);
10886 constexpr_p = false;
10888 decl = build_decl (input_location,
10889 FIELD_DECL, unqualified_id, type);
10890 DECL_NONADDRESSABLE_P (decl) = bitfield;
10891 if (bitfield && !unqualified_id)
10892 TREE_NO_WARNING (decl) = 1;
10894 if (storage_class == sc_mutable)
10896 DECL_MUTABLE_P (decl) = 1;
10897 storage_class = sc_none;
10900 if (initialized)
10902 /* An attempt is being made to initialize a non-static
10903 member. This is new in C++11. */
10904 maybe_warn_cpp0x (CPP0X_NSDMI);
10906 /* If this has been parsed with static storage class, but
10907 errors forced staticp to be cleared, ensure NSDMI is
10908 not present. */
10909 if (declspecs->storage_class == sc_static)
10910 DECL_INITIAL (decl) = error_mark_node;
10914 bad_specifiers (decl, BSP_FIELD, virtualp,
10915 memfn_quals != TYPE_UNQUALIFIED,
10916 inlinep, friendp, raises != NULL_TREE);
10919 else if (TREE_CODE (type) == FUNCTION_TYPE
10920 || TREE_CODE (type) == METHOD_TYPE)
10922 tree original_name;
10923 int publicp = 0;
10925 if (!unqualified_id)
10926 return error_mark_node;
10928 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
10929 original_name = dname;
10930 else
10931 original_name = unqualified_id;
10933 if (storage_class == sc_auto)
10934 error ("storage class %<auto%> invalid for function %qs", name);
10935 else if (storage_class == sc_register)
10936 error ("storage class %<register%> invalid for function %qs", name);
10937 else if (thread_p)
10939 if (declspecs->gnu_thread_keyword_p)
10940 error ("storage class %<__thread%> invalid for function %qs",
10941 name);
10942 else
10943 error ("storage class %<thread_local%> invalid for function %qs",
10944 name);
10947 if (virt_specifiers)
10948 error ("virt-specifiers in %qs not allowed outside a class definition", name);
10949 /* Function declaration not at top level.
10950 Storage classes other than `extern' are not allowed
10951 and `extern' makes no difference. */
10952 if (! toplevel_bindings_p ()
10953 && (storage_class == sc_static
10954 || decl_spec_seq_has_spec_p (declspecs, ds_inline))
10955 && pedantic)
10957 if (storage_class == sc_static)
10958 pedwarn (input_location, OPT_Wpedantic,
10959 "%<static%> specified invalid for function %qs "
10960 "declared out of global scope", name);
10961 else
10962 pedwarn (input_location, OPT_Wpedantic,
10963 "%<inline%> specifier invalid for function %qs "
10964 "declared out of global scope", name);
10967 if (ctype == NULL_TREE)
10969 if (virtualp)
10971 error ("virtual non-class function %qs", name);
10972 virtualp = 0;
10974 else if (sfk == sfk_constructor
10975 || sfk == sfk_destructor)
10977 error (funcdef_flag
10978 ? G_("%qs defined in a non-class scope")
10979 : G_("%qs declared in a non-class scope"), name);
10980 sfk = sfk_none;
10984 /* Record whether the function is public. */
10985 publicp = (ctype != NULL_TREE
10986 || storage_class != sc_static);
10988 if (late_return_type_p)
10989 TYPE_HAS_LATE_RETURN_TYPE (type) = 1;
10991 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
10992 virtualp, flags, memfn_quals, rqual, raises,
10993 1, friendp,
10994 publicp, inlinep | (2 * constexpr_p), sfk,
10995 funcdef_flag,
10996 template_count, in_namespace, attrlist,
10997 declarator->id_loc);
10998 if (decl == NULL_TREE)
10999 return error_mark_node;
11001 if (staticp == 1)
11003 int invalid_static = 0;
11005 /* Don't allow a static member function in a class, and forbid
11006 declaring main to be static. */
11007 if (TREE_CODE (type) == METHOD_TYPE)
11009 permerror (input_location, "cannot declare member function %qD to have "
11010 "static linkage", decl);
11011 invalid_static = 1;
11013 else if (current_function_decl)
11015 /* FIXME need arm citation */
11016 error ("cannot declare static function inside another function");
11017 invalid_static = 1;
11020 if (invalid_static)
11022 staticp = 0;
11023 storage_class = sc_none;
11027 else
11029 /* It's a variable. */
11031 /* An uninitialized decl with `extern' is a reference. */
11032 decl = grokvardecl (type, dname, unqualified_id,
11033 declspecs,
11034 initialized,
11035 (type_quals & TYPE_QUAL_CONST) != 0,
11036 template_count,
11037 ctype ? ctype : in_namespace);
11038 if (decl == NULL_TREE)
11039 return error_mark_node;
11041 bad_specifiers (decl, BSP_VAR, virtualp,
11042 memfn_quals != TYPE_UNQUALIFIED,
11043 inlinep, friendp, raises != NULL_TREE);
11045 if (ctype)
11047 DECL_CONTEXT (decl) = ctype;
11048 if (staticp == 1)
11050 permerror (input_location, "%<static%> may not be used when defining "
11051 "(as opposed to declaring) a static data member");
11052 staticp = 0;
11053 storage_class = sc_none;
11055 if (storage_class == sc_register && TREE_STATIC (decl))
11057 error ("static member %qD declared %<register%>", decl);
11058 storage_class = sc_none;
11060 if (storage_class == sc_extern && pedantic)
11062 pedwarn (input_location, OPT_Wpedantic,
11063 "cannot explicitly declare member %q#D to have "
11064 "extern linkage", decl);
11065 storage_class = sc_none;
11068 else if (constexpr_p && DECL_EXTERNAL (decl))
11070 error ("declaration of constexpr variable %qD is not a definition",
11071 decl);
11072 constexpr_p = false;
11076 if (storage_class == sc_extern && initialized && !funcdef_flag)
11078 if (toplevel_bindings_p ())
11080 /* It's common practice (and completely valid) to have a const
11081 be initialized and declared extern. */
11082 if (!(type_quals & TYPE_QUAL_CONST))
11083 warning (0, "%qs initialized and declared %<extern%>", name);
11085 else
11087 error ("%qs has both %<extern%> and initializer", name);
11088 return error_mark_node;
11092 /* Record `register' declaration for warnings on &
11093 and in case doing stupid register allocation. */
11095 if (storage_class == sc_register)
11096 DECL_REGISTER (decl) = 1;
11097 else if (storage_class == sc_extern)
11098 DECL_THIS_EXTERN (decl) = 1;
11099 else if (storage_class == sc_static)
11100 DECL_THIS_STATIC (decl) = 1;
11102 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11103 if (constexpr_p && VAR_P (decl))
11104 DECL_DECLARED_CONSTEXPR_P (decl) = true;
11106 /* Record constancy and volatility on the DECL itself . There's
11107 no need to do this when processing a template; we'll do this
11108 for the instantiated declaration based on the type of DECL. */
11109 if (!processing_template_decl)
11110 cp_apply_type_quals_to_decl (type_quals, decl);
11112 return decl;
11116 /* Subroutine of start_function. Ensure that each of the parameter
11117 types (as listed in PARMS) is complete, as is required for a
11118 function definition. */
11120 static void
11121 require_complete_types_for_parms (tree parms)
11123 for (; parms; parms = DECL_CHAIN (parms))
11125 if (dependent_type_p (TREE_TYPE (parms)))
11126 continue;
11127 if (!VOID_TYPE_P (TREE_TYPE (parms))
11128 && complete_type_or_else (TREE_TYPE (parms), parms))
11130 relayout_decl (parms);
11131 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
11133 else
11134 /* grokparms or complete_type_or_else will have already issued
11135 an error. */
11136 TREE_TYPE (parms) = error_mark_node;
11140 /* Returns nonzero if T is a local variable. */
11143 local_variable_p (const_tree t)
11145 if ((VAR_P (t)
11146 /* A VAR_DECL with a context that is a _TYPE is a static data
11147 member. */
11148 && !TYPE_P (CP_DECL_CONTEXT (t))
11149 /* Any other non-local variable must be at namespace scope. */
11150 && !DECL_NAMESPACE_SCOPE_P (t))
11151 || (TREE_CODE (t) == PARM_DECL))
11152 return 1;
11154 return 0;
11157 /* Like local_variable_p, but suitable for use as a tree-walking
11158 function. */
11160 static tree
11161 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
11162 void * /*data*/)
11164 if (local_variable_p (*tp)
11165 && (!DECL_ARTIFICIAL (*tp) || DECL_NAME (*tp) == this_identifier))
11166 return *tp;
11167 else if (TYPE_P (*tp))
11168 *walk_subtrees = 0;
11170 return NULL_TREE;
11173 /* Check that ARG, which is a default-argument expression for a
11174 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11175 something goes wrong. DECL may also be a _TYPE node, rather than a
11176 DECL, if there is no DECL available. */
11178 tree
11179 check_default_argument (tree decl, tree arg, tsubst_flags_t complain)
11181 tree var;
11182 tree decl_type;
11184 if (TREE_CODE (arg) == DEFAULT_ARG)
11185 /* We get a DEFAULT_ARG when looking at an in-class declaration
11186 with a default argument. Ignore the argument for now; we'll
11187 deal with it after the class is complete. */
11188 return arg;
11190 if (TYPE_P (decl))
11192 decl_type = decl;
11193 decl = NULL_TREE;
11195 else
11196 decl_type = TREE_TYPE (decl);
11198 if (arg == error_mark_node
11199 || decl == error_mark_node
11200 || TREE_TYPE (arg) == error_mark_node
11201 || decl_type == error_mark_node)
11202 /* Something already went wrong. There's no need to check
11203 further. */
11204 return error_mark_node;
11206 /* [dcl.fct.default]
11208 A default argument expression is implicitly converted to the
11209 parameter type. */
11210 ++cp_unevaluated_operand;
11211 perform_implicit_conversion_flags (decl_type, arg, complain,
11212 LOOKUP_IMPLICIT);
11213 --cp_unevaluated_operand;
11215 if (warn_zero_as_null_pointer_constant
11216 && TYPE_PTR_OR_PTRMEM_P (decl_type)
11217 && null_ptr_cst_p (arg)
11218 && (complain & tf_warning)
11219 && maybe_warn_zero_as_null_pointer_constant (arg, input_location))
11220 return nullptr_node;
11222 /* [dcl.fct.default]
11224 Local variables shall not be used in default argument
11225 expressions.
11227 The keyword `this' shall not be used in a default argument of a
11228 member function. */
11229 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
11230 if (var)
11232 if (complain & tf_warning_or_error)
11234 if (DECL_NAME (var) == this_identifier)
11235 permerror (input_location, "default argument %qE uses %qD",
11236 arg, var);
11237 else
11238 error ("default argument %qE uses local variable %qD", arg, var);
11240 return error_mark_node;
11243 /* All is well. */
11244 return arg;
11247 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11249 static tree
11250 type_is_deprecated (tree type)
11252 enum tree_code code;
11253 if (TREE_DEPRECATED (type))
11254 return type;
11255 if (TYPE_NAME (type)
11256 && TREE_DEPRECATED (TYPE_NAME (type)))
11257 return type;
11259 /* Do warn about using typedefs to a deprecated class. */
11260 if (OVERLOAD_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
11261 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
11263 code = TREE_CODE (type);
11265 if (code == POINTER_TYPE || code == REFERENCE_TYPE
11266 || code == OFFSET_TYPE || code == FUNCTION_TYPE
11267 || code == METHOD_TYPE || code == ARRAY_TYPE)
11268 return type_is_deprecated (TREE_TYPE (type));
11270 if (TYPE_PTRMEMFUNC_P (type))
11271 return type_is_deprecated
11272 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
11274 return NULL_TREE;
11277 /* Decode the list of parameter types for a function type.
11278 Given the list of things declared inside the parens,
11279 return a list of types.
11281 If this parameter does not end with an ellipsis, we append
11282 void_list_node.
11284 *PARMS is set to the chain of PARM_DECLs created. */
11286 static tree
11287 grokparms (tree parmlist, tree *parms)
11289 tree result = NULL_TREE;
11290 tree decls = NULL_TREE;
11291 tree parm;
11292 int any_error = 0;
11294 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
11296 tree type = NULL_TREE;
11297 tree init = TREE_PURPOSE (parm);
11298 tree decl = TREE_VALUE (parm);
11299 const char *errmsg;
11301 if (parm == void_list_node)
11302 break;
11304 if (! decl || TREE_TYPE (decl) == error_mark_node)
11305 continue;
11307 type = TREE_TYPE (decl);
11308 if (VOID_TYPE_P (type))
11310 if (same_type_p (type, void_type_node)
11311 && !init
11312 && !DECL_NAME (decl) && !result
11313 && TREE_CHAIN (parm) == void_list_node)
11314 /* DR 577: A parameter list consisting of a single
11315 unnamed parameter of non-dependent type 'void'. */
11316 break;
11317 else if (cv_qualified_p (type))
11318 error_at (DECL_SOURCE_LOCATION (decl),
11319 "invalid use of cv-qualified type %qT in "
11320 "parameter declaration", type);
11321 else
11322 error_at (DECL_SOURCE_LOCATION (decl),
11323 "invalid use of type %<void%> in parameter "
11324 "declaration");
11325 /* It's not a good idea to actually create parameters of
11326 type `void'; other parts of the compiler assume that a
11327 void type terminates the parameter list. */
11328 type = error_mark_node;
11329 TREE_TYPE (decl) = error_mark_node;
11332 if (type != error_mark_node
11333 && TYPE_FOR_JAVA (type)
11334 && MAYBE_CLASS_TYPE_P (type))
11336 error ("parameter %qD has Java class type", decl);
11337 type = error_mark_node;
11338 TREE_TYPE (decl) = error_mark_node;
11339 init = NULL_TREE;
11342 if (type != error_mark_node
11343 && (errmsg = targetm.invalid_parameter_type (type)))
11345 error (errmsg);
11346 type = error_mark_node;
11347 TREE_TYPE (decl) = error_mark_node;
11350 if (type != error_mark_node)
11352 if (deprecated_state != DEPRECATED_SUPPRESS)
11354 tree deptype = type_is_deprecated (type);
11355 if (deptype)
11356 warn_deprecated_use (deptype, NULL_TREE);
11359 /* Top-level qualifiers on the parameters are
11360 ignored for function types. */
11361 type = cp_build_qualified_type (type, 0);
11362 if (TREE_CODE (type) == METHOD_TYPE)
11364 error ("parameter %qD invalidly declared method type", decl);
11365 type = build_pointer_type (type);
11366 TREE_TYPE (decl) = type;
11368 else if (abstract_virtuals_error (decl, type))
11369 any_error = 1; /* Seems like a good idea. */
11370 else if (POINTER_TYPE_P (type))
11372 /* [dcl.fct]/6, parameter types cannot contain pointers
11373 (references) to arrays of unknown bound. */
11374 tree t = TREE_TYPE (type);
11375 int ptr = TYPE_PTR_P (type);
11377 while (1)
11379 if (TYPE_PTR_P (t))
11380 ptr = 1;
11381 else if (TREE_CODE (t) != ARRAY_TYPE)
11382 break;
11383 else if (!TYPE_DOMAIN (t))
11384 break;
11385 t = TREE_TYPE (t);
11387 if (TREE_CODE (t) == ARRAY_TYPE)
11388 error (ptr
11389 ? G_("parameter %qD includes pointer to array of "
11390 "unknown bound %qT")
11391 : G_("parameter %qD includes reference to array of "
11392 "unknown bound %qT"),
11393 decl, t);
11396 if (any_error)
11397 init = NULL_TREE;
11398 else if (init && !processing_template_decl)
11399 init = check_default_argument (decl, init, tf_warning_or_error);
11402 DECL_CHAIN (decl) = decls;
11403 decls = decl;
11404 result = tree_cons (init, type, result);
11406 decls = nreverse (decls);
11407 result = nreverse (result);
11408 if (parm)
11409 result = chainon (result, void_list_node);
11410 *parms = decls;
11412 return result;
11416 /* D is a constructor or overloaded `operator='.
11418 Let T be the class in which D is declared. Then, this function
11419 returns:
11421 -1 if D's is an ill-formed constructor or copy assignment operator
11422 whose first parameter is of type `T'.
11423 0 if D is not a copy constructor or copy assignment
11424 operator.
11425 1 if D is a copy constructor or copy assignment operator whose
11426 first parameter is a reference to non-const qualified T.
11427 2 if D is a copy constructor or copy assignment operator whose
11428 first parameter is a reference to const qualified T.
11430 This function can be used as a predicate. Positive values indicate
11431 a copy constructor and nonzero values indicate a copy assignment
11432 operator. */
11435 copy_fn_p (const_tree d)
11437 tree args;
11438 tree arg_type;
11439 int result = 1;
11441 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
11443 if (TREE_CODE (d) == TEMPLATE_DECL
11444 || (DECL_TEMPLATE_INFO (d)
11445 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
11446 /* Instantiations of template member functions are never copy
11447 functions. Note that member functions of templated classes are
11448 represented as template functions internally, and we must
11449 accept those as copy functions. */
11450 return 0;
11452 args = FUNCTION_FIRST_USER_PARMTYPE (d);
11453 if (!args)
11454 return 0;
11456 arg_type = TREE_VALUE (args);
11457 if (arg_type == error_mark_node)
11458 return 0;
11460 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
11462 /* Pass by value copy assignment operator. */
11463 result = -1;
11465 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
11466 && !TYPE_REF_IS_RVALUE (arg_type)
11467 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
11469 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
11470 result = 2;
11472 else
11473 return 0;
11475 args = TREE_CHAIN (args);
11477 if (args && args != void_list_node && !TREE_PURPOSE (args))
11478 /* There are more non-optional args. */
11479 return 0;
11481 return result;
11484 /* D is a constructor or overloaded `operator='.
11486 Let T be the class in which D is declared. Then, this function
11487 returns true when D is a move constructor or move assignment
11488 operator, false otherwise. */
11490 bool
11491 move_fn_p (const_tree d)
11493 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
11495 if (cxx_dialect == cxx98)
11496 /* There are no move constructors if we are in C++98 mode. */
11497 return false;
11499 if (TREE_CODE (d) == TEMPLATE_DECL
11500 || (DECL_TEMPLATE_INFO (d)
11501 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
11502 /* Instantiations of template member functions are never move
11503 functions. Note that member functions of templated classes are
11504 represented as template functions internally, and we must
11505 accept those as move functions. */
11506 return 0;
11508 return move_signature_fn_p (d);
11511 /* D is a constructor or overloaded `operator='.
11513 Then, this function returns true when D has the same signature as a move
11514 constructor or move assignment operator (because either it is such a
11515 ctor/op= or it is a template specialization with the same signature),
11516 false otherwise. */
11518 bool
11519 move_signature_fn_p (const_tree d)
11521 tree args;
11522 tree arg_type;
11523 bool result = false;
11525 args = FUNCTION_FIRST_USER_PARMTYPE (d);
11526 if (!args)
11527 return 0;
11529 arg_type = TREE_VALUE (args);
11530 if (arg_type == error_mark_node)
11531 return 0;
11533 if (TREE_CODE (arg_type) == REFERENCE_TYPE
11534 && TYPE_REF_IS_RVALUE (arg_type)
11535 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
11536 DECL_CONTEXT (d)))
11537 result = true;
11539 args = TREE_CHAIN (args);
11541 if (args && args != void_list_node && !TREE_PURPOSE (args))
11542 /* There are more non-optional args. */
11543 return false;
11545 return result;
11548 /* Remember any special properties of member function DECL. */
11550 void
11551 grok_special_member_properties (tree decl)
11553 tree class_type;
11555 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
11556 return;
11558 class_type = DECL_CONTEXT (decl);
11559 if (DECL_CONSTRUCTOR_P (decl))
11561 int ctor = copy_fn_p (decl);
11563 if (!DECL_ARTIFICIAL (decl))
11564 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
11566 if (ctor > 0)
11568 /* [class.copy]
11570 A non-template constructor for class X is a copy
11571 constructor if its first parameter is of type X&, const
11572 X&, volatile X& or const volatile X&, and either there
11573 are no other parameters or else all other parameters have
11574 default arguments. */
11575 TYPE_HAS_COPY_CTOR (class_type) = 1;
11576 if (user_provided_p (decl))
11577 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
11578 if (ctor > 1)
11579 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
11581 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
11582 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
11583 else if (move_fn_p (decl) && user_provided_p (decl))
11584 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1;
11585 else if (is_list_ctor (decl))
11586 TYPE_HAS_LIST_CTOR (class_type) = 1;
11588 if (DECL_DECLARED_CONSTEXPR_P (decl)
11589 && !copy_fn_p (decl) && !move_fn_p (decl))
11590 TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
11592 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
11594 /* [class.copy]
11596 A non-template assignment operator for class X is a copy
11597 assignment operator if its parameter is of type X, X&, const
11598 X&, volatile X& or const volatile X&. */
11600 int assop = copy_fn_p (decl);
11602 if (assop)
11604 TYPE_HAS_COPY_ASSIGN (class_type) = 1;
11605 if (user_provided_p (decl))
11606 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
11607 if (assop != 1)
11608 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
11610 else if (move_fn_p (decl) && user_provided_p (decl))
11611 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1;
11613 /* Destructors are handled in check_methods. */
11616 /* Check a constructor DECL has the correct form. Complains
11617 if the class has a constructor of the form X(X). */
11620 grok_ctor_properties (const_tree ctype, const_tree decl)
11622 int ctor_parm = copy_fn_p (decl);
11624 if (ctor_parm < 0)
11626 /* [class.copy]
11628 A declaration of a constructor for a class X is ill-formed if
11629 its first parameter is of type (optionally cv-qualified) X
11630 and either there are no other parameters or else all other
11631 parameters have default arguments.
11633 We *don't* complain about member template instantiations that
11634 have this form, though; they can occur as we try to decide
11635 what constructor to use during overload resolution. Since
11636 overload resolution will never prefer such a constructor to
11637 the non-template copy constructor (which is either explicitly
11638 or implicitly defined), there's no need to worry about their
11639 existence. Theoretically, they should never even be
11640 instantiated, but that's hard to forestall. */
11641 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11642 ctype, ctype);
11643 return 0;
11646 return 1;
11649 /* An operator with this code is unary, but can also be binary. */
11651 static int
11652 ambi_op_p (enum tree_code code)
11654 return (code == INDIRECT_REF
11655 || code == ADDR_EXPR
11656 || code == UNARY_PLUS_EXPR
11657 || code == NEGATE_EXPR
11658 || code == PREINCREMENT_EXPR
11659 || code == PREDECREMENT_EXPR);
11662 /* An operator with this name can only be unary. */
11664 static int
11665 unary_op_p (enum tree_code code)
11667 return (code == TRUTH_NOT_EXPR
11668 || code == BIT_NOT_EXPR
11669 || code == COMPONENT_REF
11670 || code == TYPE_EXPR);
11673 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11674 errors are issued for invalid declarations. */
11676 bool
11677 grok_op_properties (tree decl, bool complain)
11679 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
11680 tree argtype;
11681 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
11682 tree name = DECL_NAME (decl);
11683 enum tree_code operator_code;
11684 int arity;
11685 bool ellipsis_p;
11686 tree class_type;
11688 /* Count the number of arguments and check for ellipsis. */
11689 for (argtype = argtypes, arity = 0;
11690 argtype && argtype != void_list_node;
11691 argtype = TREE_CHAIN (argtype))
11692 ++arity;
11693 ellipsis_p = !argtype;
11695 class_type = DECL_CONTEXT (decl);
11696 if (class_type && !CLASS_TYPE_P (class_type))
11697 class_type = NULL_TREE;
11699 if (DECL_CONV_FN_P (decl))
11700 operator_code = TYPE_EXPR;
11701 else
11704 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11705 if (ansi_opname (CODE) == name) \
11707 operator_code = (CODE); \
11708 break; \
11710 else if (ansi_assopname (CODE) == name) \
11712 operator_code = (CODE); \
11713 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11714 break; \
11717 #include "operators.def"
11718 #undef DEF_OPERATOR
11720 gcc_unreachable ();
11722 while (0);
11723 gcc_assert (operator_code != MAX_TREE_CODES);
11724 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11726 if (class_type)
11727 switch (operator_code)
11729 case NEW_EXPR:
11730 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
11731 break;
11733 case DELETE_EXPR:
11734 TYPE_GETS_DELETE (class_type) |= 1;
11735 break;
11737 case VEC_NEW_EXPR:
11738 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
11739 break;
11741 case VEC_DELETE_EXPR:
11742 TYPE_GETS_DELETE (class_type) |= 2;
11743 break;
11745 default:
11746 break;
11749 /* [basic.std.dynamic.allocation]/1:
11751 A program is ill-formed if an allocation function is declared
11752 in a namespace scope other than global scope or declared static
11753 in global scope.
11755 The same also holds true for deallocation functions. */
11756 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
11757 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11759 if (DECL_NAMESPACE_SCOPE_P (decl))
11761 if (CP_DECL_CONTEXT (decl) != global_namespace)
11763 error ("%qD may not be declared within a namespace", decl);
11764 return false;
11766 else if (!TREE_PUBLIC (decl))
11768 error ("%qD may not be declared as static", decl);
11769 return false;
11774 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
11776 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
11777 DECL_IS_OPERATOR_NEW (decl) = 1;
11779 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
11780 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
11781 else
11783 /* An operator function must either be a non-static member function
11784 or have at least one parameter of a class, a reference to a class,
11785 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11786 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
11788 if (operator_code == TYPE_EXPR
11789 || operator_code == CALL_EXPR
11790 || operator_code == COMPONENT_REF
11791 || operator_code == ARRAY_REF
11792 || operator_code == NOP_EXPR)
11794 error ("%qD must be a nonstatic member function", decl);
11795 return false;
11797 else
11799 tree p;
11801 if (DECL_STATIC_FUNCTION_P (decl))
11803 error ("%qD must be either a non-static member "
11804 "function or a non-member function", decl);
11805 return false;
11808 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
11810 tree arg = non_reference (TREE_VALUE (p));
11811 if (arg == error_mark_node)
11812 return false;
11814 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11815 because these checks are performed even on
11816 template functions. */
11817 if (MAYBE_CLASS_TYPE_P (arg)
11818 || TREE_CODE (arg) == ENUMERAL_TYPE)
11819 break;
11822 if (!p || p == void_list_node)
11824 if (complain)
11825 error ("%qD must have an argument of class or "
11826 "enumerated type", decl);
11827 return false;
11832 /* There are no restrictions on the arguments to an overloaded
11833 "operator ()". */
11834 if (operator_code == CALL_EXPR)
11835 return true;
11837 /* Warn about conversion operators that will never be used. */
11838 if (IDENTIFIER_TYPENAME_P (name)
11839 && ! DECL_TEMPLATE_INFO (decl)
11840 && warn_conversion
11841 /* Warn only declaring the function; there is no need to
11842 warn again about out-of-class definitions. */
11843 && class_type == current_class_type)
11845 tree t = TREE_TYPE (name);
11846 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
11848 if (ref)
11849 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
11851 if (VOID_TYPE_P (t))
11852 warning (OPT_Wconversion,
11854 ? G_("conversion to a reference to void "
11855 "will never use a type conversion operator")
11856 : G_("conversion to void "
11857 "will never use a type conversion operator"));
11858 else if (class_type)
11860 if (t == class_type)
11861 warning (OPT_Wconversion,
11863 ? G_("conversion to a reference to the same type "
11864 "will never use a type conversion operator")
11865 : G_("conversion to the same type "
11866 "will never use a type conversion operator"));
11867 /* Don't force t to be complete here. */
11868 else if (MAYBE_CLASS_TYPE_P (t)
11869 && COMPLETE_TYPE_P (t)
11870 && DERIVED_FROM_P (t, class_type))
11871 warning (OPT_Wconversion,
11873 ? G_("conversion to a reference to a base class "
11874 "will never use a type conversion operator")
11875 : G_("conversion to a base class "
11876 "will never use a type conversion operator"));
11881 if (operator_code == COND_EXPR)
11883 /* 13.4.0.3 */
11884 error ("ISO C++ prohibits overloading operator ?:");
11885 return false;
11887 else if (ellipsis_p)
11889 error ("%qD must not have variable number of arguments", decl);
11890 return false;
11892 else if (ambi_op_p (operator_code))
11894 if (arity == 1)
11895 /* We pick the one-argument operator codes by default, so
11896 we don't have to change anything. */
11898 else if (arity == 2)
11900 /* If we thought this was a unary operator, we now know
11901 it to be a binary operator. */
11902 switch (operator_code)
11904 case INDIRECT_REF:
11905 operator_code = MULT_EXPR;
11906 break;
11908 case ADDR_EXPR:
11909 operator_code = BIT_AND_EXPR;
11910 break;
11912 case UNARY_PLUS_EXPR:
11913 operator_code = PLUS_EXPR;
11914 break;
11916 case NEGATE_EXPR:
11917 operator_code = MINUS_EXPR;
11918 break;
11920 case PREINCREMENT_EXPR:
11921 operator_code = POSTINCREMENT_EXPR;
11922 break;
11924 case PREDECREMENT_EXPR:
11925 operator_code = POSTDECREMENT_EXPR;
11926 break;
11928 default:
11929 gcc_unreachable ();
11932 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
11934 if ((operator_code == POSTINCREMENT_EXPR
11935 || operator_code == POSTDECREMENT_EXPR)
11936 && ! processing_template_decl
11937 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
11939 if (methodp)
11940 error ("postfix %qD must take %<int%> as its argument",
11941 decl);
11942 else
11943 error ("postfix %qD must take %<int%> as its second "
11944 "argument", decl);
11945 return false;
11948 else
11950 if (methodp)
11951 error ("%qD must take either zero or one argument", decl);
11952 else
11953 error ("%qD must take either one or two arguments", decl);
11954 return false;
11957 /* More Effective C++ rule 6. */
11958 if (warn_ecpp
11959 && (operator_code == POSTINCREMENT_EXPR
11960 || operator_code == POSTDECREMENT_EXPR
11961 || operator_code == PREINCREMENT_EXPR
11962 || operator_code == PREDECREMENT_EXPR))
11964 tree arg = TREE_VALUE (argtypes);
11965 tree ret = TREE_TYPE (TREE_TYPE (decl));
11966 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
11967 arg = TREE_TYPE (arg);
11968 arg = TYPE_MAIN_VARIANT (arg);
11969 if (operator_code == PREINCREMENT_EXPR
11970 || operator_code == PREDECREMENT_EXPR)
11972 if (TREE_CODE (ret) != REFERENCE_TYPE
11973 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
11974 arg))
11975 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
11976 build_reference_type (arg));
11978 else
11980 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
11981 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
11985 else if (unary_op_p (operator_code))
11987 if (arity != 1)
11989 if (methodp)
11990 error ("%qD must take %<void%>", decl);
11991 else
11992 error ("%qD must take exactly one argument", decl);
11993 return false;
11996 else /* if (binary_op_p (operator_code)) */
11998 if (arity != 2)
12000 if (methodp)
12001 error ("%qD must take exactly one argument", decl);
12002 else
12003 error ("%qD must take exactly two arguments", decl);
12004 return false;
12007 /* More Effective C++ rule 7. */
12008 if (warn_ecpp
12009 && (operator_code == TRUTH_ANDIF_EXPR
12010 || operator_code == TRUTH_ORIF_EXPR
12011 || operator_code == COMPOUND_EXPR))
12012 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
12013 decl);
12016 /* Effective C++ rule 23. */
12017 if (warn_ecpp
12018 && arity == 2
12019 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
12020 && (operator_code == PLUS_EXPR
12021 || operator_code == MINUS_EXPR
12022 || operator_code == TRUNC_DIV_EXPR
12023 || operator_code == MULT_EXPR
12024 || operator_code == TRUNC_MOD_EXPR)
12025 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
12026 warning (OPT_Weffc__, "%qD should return by value", decl);
12028 /* [over.oper]/8 */
12029 for (; argtypes && argtypes != void_list_node;
12030 argtypes = TREE_CHAIN (argtypes))
12031 if (TREE_PURPOSE (argtypes))
12033 TREE_PURPOSE (argtypes) = NULL_TREE;
12034 if (operator_code == POSTINCREMENT_EXPR
12035 || operator_code == POSTDECREMENT_EXPR)
12037 pedwarn (input_location, OPT_Wpedantic, "%qD cannot have default arguments",
12038 decl);
12040 else
12042 error ("%qD cannot have default arguments", decl);
12043 return false;
12047 return true;
12050 /* Return a string giving the keyword associate with CODE. */
12052 static const char *
12053 tag_name (enum tag_types code)
12055 switch (code)
12057 case record_type:
12058 return "struct";
12059 case class_type:
12060 return "class";
12061 case union_type:
12062 return "union";
12063 case enum_type:
12064 return "enum";
12065 case typename_type:
12066 return "typename";
12067 default:
12068 gcc_unreachable ();
12072 /* Name lookup in an elaborated-type-specifier (after the keyword
12073 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12074 elaborated-type-specifier is invalid, issue a diagnostic and return
12075 error_mark_node; otherwise, return the *_TYPE to which it referred.
12076 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12078 tree
12079 check_elaborated_type_specifier (enum tag_types tag_code,
12080 tree decl,
12081 bool allow_template_p)
12083 tree type;
12085 /* In the case of:
12087 struct S { struct S *p; };
12089 name lookup will find the TYPE_DECL for the implicit "S::S"
12090 typedef. Adjust for that here. */
12091 if (DECL_SELF_REFERENCE_P (decl))
12092 decl = TYPE_NAME (TREE_TYPE (decl));
12094 type = TREE_TYPE (decl);
12096 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12097 is false for this case as well. */
12098 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12100 error ("using template type parameter %qT after %qs",
12101 type, tag_name (tag_code));
12102 return error_mark_node;
12104 /* Accept template template parameters. */
12105 else if (allow_template_p
12106 && (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
12107 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM))
12109 /* [dcl.type.elab]
12111 If the identifier resolves to a typedef-name or the
12112 simple-template-id resolves to an alias template
12113 specialization, the elaborated-type-specifier is ill-formed.
12115 In other words, the only legitimate declaration to use in the
12116 elaborated type specifier is the implicit typedef created when
12117 the type is declared. */
12118 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
12119 && !DECL_SELF_REFERENCE_P (decl)
12120 && tag_code != typename_type)
12122 if (alias_template_specialization_p (type))
12123 error ("using alias template specialization %qT after %qs",
12124 type, tag_name (tag_code));
12125 else
12126 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
12127 inform (DECL_SOURCE_LOCATION (decl),
12128 "%qD has a previous declaration here", decl);
12129 return error_mark_node;
12131 else if (TREE_CODE (type) != RECORD_TYPE
12132 && TREE_CODE (type) != UNION_TYPE
12133 && tag_code != enum_type
12134 && tag_code != typename_type)
12136 error ("%qT referred to as %qs", type, tag_name (tag_code));
12137 inform (input_location, "%q+T has a previous declaration here", type);
12138 return error_mark_node;
12140 else if (TREE_CODE (type) != ENUMERAL_TYPE
12141 && tag_code == enum_type)
12143 error ("%qT referred to as enum", type);
12144 inform (input_location, "%q+T has a previous declaration here", type);
12145 return error_mark_node;
12147 else if (!allow_template_p
12148 && TREE_CODE (type) == RECORD_TYPE
12149 && CLASSTYPE_IS_TEMPLATE (type))
12151 /* If a class template appears as elaborated type specifier
12152 without a template header such as:
12154 template <class T> class C {};
12155 void f(class C); // No template header here
12157 then the required template argument is missing. */
12158 error ("template argument required for %<%s %T%>",
12159 tag_name (tag_code),
12160 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
12161 return error_mark_node;
12164 return type;
12167 /* Lookup NAME in elaborate type specifier in scope according to
12168 SCOPE and issue diagnostics if necessary.
12169 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12170 found, and ERROR_MARK_NODE for type error. */
12172 static tree
12173 lookup_and_check_tag (enum tag_types tag_code, tree name,
12174 tag_scope scope, bool template_header_p)
12176 tree t;
12177 tree decl;
12178 if (scope == ts_global)
12180 /* First try ordinary name lookup, ignoring hidden class name
12181 injected via friend declaration. */
12182 decl = lookup_name_prefer_type (name, 2);
12183 /* If that fails, the name will be placed in the smallest
12184 non-class, non-function-prototype scope according to 3.3.1/5.
12185 We may already have a hidden name declared as friend in this
12186 scope. So lookup again but not ignoring hidden names.
12187 If we find one, that name will be made visible rather than
12188 creating a new tag. */
12189 if (!decl)
12190 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
12192 else
12193 decl = lookup_type_scope (name, scope);
12195 if (decl
12196 && (DECL_CLASS_TEMPLATE_P (decl)
12197 /* If scope is ts_current we're defining a class, so ignore a
12198 template template parameter. */
12199 || (scope != ts_current
12200 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl))))
12201 decl = DECL_TEMPLATE_RESULT (decl);
12203 if (decl && TREE_CODE (decl) == TYPE_DECL)
12205 /* Look for invalid nested type:
12206 class C {
12207 class C {};
12208 }; */
12209 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
12211 error ("%qD has the same name as the class in which it is "
12212 "declared",
12213 decl);
12214 return error_mark_node;
12217 /* Two cases we need to consider when deciding if a class
12218 template is allowed as an elaborated type specifier:
12219 1. It is a self reference to its own class.
12220 2. It comes with a template header.
12222 For example:
12224 template <class T> class C {
12225 class C *c1; // DECL_SELF_REFERENCE_P is true
12226 class D;
12228 template <class U> class C; // template_header_p is true
12229 template <class T> class C<T>::D {
12230 class C *c2; // DECL_SELF_REFERENCE_P is true
12231 }; */
12233 t = check_elaborated_type_specifier (tag_code,
12234 decl,
12235 template_header_p
12236 | DECL_SELF_REFERENCE_P (decl));
12237 return t;
12239 else if (decl && TREE_CODE (decl) == TREE_LIST)
12241 error ("reference to %qD is ambiguous", name);
12242 print_candidates (decl);
12243 return error_mark_node;
12245 else
12246 return NULL_TREE;
12249 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12250 Define the tag as a forward-reference if it is not defined.
12252 If a declaration is given, process it here, and report an error if
12253 multiple declarations are not identical.
12255 SCOPE is TS_CURRENT when this is also a definition. Only look in
12256 the current frame for the name (since C++ allows new names in any
12257 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12258 declaration. Only look beginning from the current scope outward up
12259 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12261 TEMPLATE_HEADER_P is true when this declaration is preceded by
12262 a set of template parameters. */
12264 static tree
12265 xref_tag_1 (enum tag_types tag_code, tree name,
12266 tag_scope orig_scope, bool template_header_p)
12268 enum tree_code code;
12269 tree t;
12270 tree context = NULL_TREE;
12271 tag_scope scope;
12273 gcc_assert (identifier_p (name));
12275 switch (tag_code)
12277 case record_type:
12278 case class_type:
12279 code = RECORD_TYPE;
12280 break;
12281 case union_type:
12282 code = UNION_TYPE;
12283 break;
12284 case enum_type:
12285 code = ENUMERAL_TYPE;
12286 break;
12287 default:
12288 gcc_unreachable ();
12291 if (orig_scope == ts_lambda)
12292 scope = ts_current;
12293 else
12294 scope = orig_scope;
12296 /* In case of anonymous name, xref_tag is only called to
12297 make type node and push name. Name lookup is not required. */
12298 if (ANON_AGGRNAME_P (name))
12299 t = NULL_TREE;
12300 else
12301 t = lookup_and_check_tag (tag_code, name,
12302 scope, template_header_p);
12304 if (t == error_mark_node)
12305 return error_mark_node;
12307 if (scope != ts_current && t && current_class_type
12308 && template_class_depth (current_class_type)
12309 && template_header_p)
12311 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
12312 return t;
12314 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12315 definition of this tag. Since, in addition, we are currently
12316 processing a (member) template declaration of a template
12317 class, we must be very careful; consider:
12319 template <class X>
12320 struct S1
12322 template <class U>
12323 struct S2
12324 { template <class V>
12325 friend struct S1; };
12327 Here, the S2::S1 declaration should not be confused with the
12328 outer declaration. In particular, the inner version should
12329 have a template parameter of level 2, not level 1. This
12330 would be particularly important if the member declaration
12331 were instead:
12333 template <class V = U> friend struct S1;
12335 say, when we should tsubst into `U' when instantiating
12336 S2. On the other hand, when presented with:
12338 template <class T>
12339 struct S1 {
12340 template <class U>
12341 struct S2 {};
12342 template <class U>
12343 friend struct S2;
12346 we must find the inner binding eventually. We
12347 accomplish this by making sure that the new type we
12348 create to represent this declaration has the right
12349 TYPE_CONTEXT. */
12350 context = TYPE_CONTEXT (t);
12351 t = NULL_TREE;
12354 if (! t)
12356 /* If no such tag is yet defined, create a forward-reference node
12357 and record it as the "definition".
12358 When a real declaration of this type is found,
12359 the forward-reference will be altered into a real type. */
12360 if (code == ENUMERAL_TYPE)
12362 error ("use of enum %q#D without previous declaration", name);
12363 return error_mark_node;
12365 else
12367 t = make_class_type (code);
12368 TYPE_CONTEXT (t) = context;
12369 if (orig_scope == ts_lambda)
12370 /* Remember that we're declaring a lambda to avoid bogus errors
12371 in push_template_decl. */
12372 CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node;
12373 t = pushtag (name, t, scope);
12376 else
12378 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
12380 if (!redeclare_class_template (t, current_template_parms))
12381 return error_mark_node;
12383 else if (!processing_template_decl
12384 && CLASS_TYPE_P (t)
12385 && CLASSTYPE_IS_TEMPLATE (t))
12387 error ("redeclaration of %qT as a non-template", t);
12388 error ("previous declaration %q+D", t);
12389 return error_mark_node;
12392 /* Make injected friend class visible. */
12393 if (scope != ts_within_enclosing_non_class
12394 && hidden_name_p (TYPE_NAME (t)))
12396 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
12397 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
12399 if (TYPE_TEMPLATE_INFO (t))
12401 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
12402 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
12407 return t;
12410 /* Wrapper for xref_tag_1. */
12412 tree
12413 xref_tag (enum tag_types tag_code, tree name,
12414 tag_scope scope, bool template_header_p)
12416 tree ret;
12417 bool subtime;
12418 subtime = timevar_cond_start (TV_NAME_LOOKUP);
12419 ret = xref_tag_1 (tag_code, name, scope, template_header_p);
12420 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
12421 return ret;
12425 tree
12426 xref_tag_from_type (tree old, tree id, tag_scope scope)
12428 enum tag_types tag_kind;
12430 if (TREE_CODE (old) == RECORD_TYPE)
12431 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
12432 else
12433 tag_kind = union_type;
12435 if (id == NULL_TREE)
12436 id = TYPE_IDENTIFIER (old);
12438 return xref_tag (tag_kind, id, scope, false);
12441 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12442 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12443 access_* node, and the TREE_VALUE is the type of the base-class.
12444 Non-NULL TREE_TYPE indicates virtual inheritance.
12446 Returns true if the binfo hierarchy was successfully created,
12447 false if an error was detected. */
12449 bool
12450 xref_basetypes (tree ref, tree base_list)
12452 tree *basep;
12453 tree binfo, base_binfo;
12454 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
12455 unsigned max_bases = 0; /* Maximum direct bases. */
12456 int i;
12457 tree default_access;
12458 tree igo_prev; /* Track Inheritance Graph Order. */
12460 if (ref == error_mark_node)
12461 return false;
12463 /* The base of a derived class is private by default, all others are
12464 public. */
12465 default_access = (TREE_CODE (ref) == RECORD_TYPE
12466 && CLASSTYPE_DECLARED_CLASS (ref)
12467 ? access_private_node : access_public_node);
12469 /* First, make sure that any templates in base-classes are
12470 instantiated. This ensures that if we call ourselves recursively
12471 we do not get confused about which classes are marked and which
12472 are not. */
12473 basep = &base_list;
12474 while (*basep)
12476 tree basetype = TREE_VALUE (*basep);
12478 /* The dependent_type_p call below should really be dependent_scope_p
12479 so that we give a hard error about using an incomplete type as a
12480 base, but we allow it with a pedwarn for backward
12481 compatibility. */
12482 if (processing_template_decl
12483 && CLASS_TYPE_P (basetype) && TYPE_BEING_DEFINED (basetype))
12484 cxx_incomplete_type_diagnostic (NULL_TREE, basetype, DK_PEDWARN);
12485 if (!dependent_type_p (basetype)
12486 && !complete_type_or_else (basetype, NULL))
12487 /* An incomplete type. Remove it from the list. */
12488 *basep = TREE_CHAIN (*basep);
12489 else
12491 max_bases++;
12492 if (TREE_TYPE (*basep))
12493 max_vbases++;
12494 if (CLASS_TYPE_P (basetype))
12495 max_vbases += vec_safe_length (CLASSTYPE_VBASECLASSES (basetype));
12496 basep = &TREE_CHAIN (*basep);
12500 TYPE_MARKED_P (ref) = 1;
12502 /* The binfo slot should be empty, unless this is an (ill-formed)
12503 redefinition. */
12504 if (TYPE_BINFO (ref) && !TYPE_SIZE (ref))
12506 error ("redefinition of %q#T", ref);
12507 return false;
12510 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
12512 binfo = make_tree_binfo (max_bases);
12514 TYPE_BINFO (ref) = binfo;
12515 BINFO_OFFSET (binfo) = size_zero_node;
12516 BINFO_TYPE (binfo) = ref;
12518 /* Apply base-class info set up to the variants of this type. */
12519 fixup_type_variants (ref);
12521 if (max_bases)
12523 vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases);
12524 /* An aggregate cannot have baseclasses. */
12525 CLASSTYPE_NON_AGGREGATE (ref) = 1;
12527 if (TREE_CODE (ref) == UNION_TYPE)
12529 error ("derived union %qT invalid", ref);
12530 return false;
12534 if (max_bases > 1)
12536 if (TYPE_FOR_JAVA (ref))
12538 error ("Java class %qT cannot have multiple bases", ref);
12539 return false;
12543 if (max_vbases)
12545 vec_alloc (CLASSTYPE_VBASECLASSES (ref), max_vbases);
12547 if (TYPE_FOR_JAVA (ref))
12549 error ("Java class %qT cannot have virtual bases", ref);
12550 return false;
12554 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
12556 tree access = TREE_PURPOSE (base_list);
12557 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
12558 tree basetype = TREE_VALUE (base_list);
12560 if (access == access_default_node)
12561 access = default_access;
12563 if (PACK_EXPANSION_P (basetype))
12564 basetype = PACK_EXPANSION_PATTERN (basetype);
12565 if (TREE_CODE (basetype) == TYPE_DECL)
12566 basetype = TREE_TYPE (basetype);
12567 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
12569 error ("base type %qT fails to be a struct or class type",
12570 basetype);
12571 return false;
12574 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
12575 TYPE_FOR_JAVA (ref) = 1;
12577 base_binfo = NULL_TREE;
12578 if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
12580 base_binfo = TYPE_BINFO (basetype);
12581 /* The original basetype could have been a typedef'd type. */
12582 basetype = BINFO_TYPE (base_binfo);
12584 /* Inherit flags from the base. */
12585 TYPE_HAS_NEW_OPERATOR (ref)
12586 |= TYPE_HAS_NEW_OPERATOR (basetype);
12587 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
12588 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
12589 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
12590 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
12591 CLASSTYPE_DIAMOND_SHAPED_P (ref)
12592 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
12593 CLASSTYPE_REPEATED_BASE_P (ref)
12594 |= CLASSTYPE_REPEATED_BASE_P (basetype);
12597 /* We must do this test after we've seen through a typedef
12598 type. */
12599 if (TYPE_MARKED_P (basetype))
12601 if (basetype == ref)
12602 error ("recursive type %qT undefined", basetype);
12603 else
12604 error ("duplicate base type %qT invalid", basetype);
12605 return false;
12608 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
12609 /* Regenerate the pack expansion for the bases. */
12610 basetype = make_pack_expansion (basetype);
12612 TYPE_MARKED_P (basetype) = 1;
12614 base_binfo = copy_binfo (base_binfo, basetype, ref,
12615 &igo_prev, via_virtual);
12616 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
12617 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
12619 BINFO_BASE_APPEND (binfo, base_binfo);
12620 BINFO_BASE_ACCESS_APPEND (binfo, access);
12623 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref)) < max_vbases)
12624 /* If we didn't get max_vbases vbases, we must have shared at
12625 least one of them, and are therefore diamond shaped. */
12626 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
12628 /* Unmark all the types. */
12629 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
12630 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12631 TYPE_MARKED_P (ref) = 0;
12633 /* Now see if we have a repeated base type. */
12634 if (!CLASSTYPE_REPEATED_BASE_P (ref))
12636 for (base_binfo = binfo; base_binfo;
12637 base_binfo = TREE_CHAIN (base_binfo))
12639 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12641 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
12642 break;
12644 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
12646 for (base_binfo = binfo; base_binfo;
12647 base_binfo = TREE_CHAIN (base_binfo))
12648 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
12649 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
12650 else
12651 break;
12654 return true;
12658 /* Copies the enum-related properties from type SRC to type DST.
12659 Used with the underlying type of an enum and the enum itself. */
12660 static void
12661 copy_type_enum (tree dst, tree src)
12663 tree t;
12664 for (t = dst; t; t = TYPE_NEXT_VARIANT (t))
12666 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src);
12667 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src);
12668 TYPE_SIZE (t) = TYPE_SIZE (src);
12669 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src);
12670 SET_TYPE_MODE (dst, TYPE_MODE (src));
12671 TYPE_PRECISION (t) = TYPE_PRECISION (src);
12672 TYPE_ALIGN (t) = TYPE_ALIGN (src);
12673 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src);
12674 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src);
12678 /* Begin compiling the definition of an enumeration type.
12679 NAME is its name,
12681 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12683 UNDERLYING_TYPE is the type that will be used as the storage for
12684 the enumeration type. This should be NULL_TREE if no storage type
12685 was specified.
12687 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12689 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12691 Returns the type object, as yet incomplete.
12692 Also records info about it so that build_enumerator
12693 may be used to declare the individual values as they are read. */
12695 tree
12696 start_enum (tree name, tree enumtype, tree underlying_type,
12697 bool scoped_enum_p, bool *is_new)
12699 tree prevtype = NULL_TREE;
12700 gcc_assert (identifier_p (name));
12702 if (is_new)
12703 *is_new = false;
12704 /* [C++0x dcl.enum]p5:
12706 If not explicitly specified, the underlying type of a scoped
12707 enumeration type is int. */
12708 if (!underlying_type && scoped_enum_p)
12709 underlying_type = integer_type_node;
12711 if (underlying_type)
12712 underlying_type = cv_unqualified (underlying_type);
12714 /* If this is the real definition for a previous forward reference,
12715 fill in the contents in the same object that used to be the
12716 forward reference. */
12717 if (!enumtype)
12718 enumtype = lookup_and_check_tag (enum_type, name,
12719 /*tag_scope=*/ts_current,
12720 /*template_header_p=*/false);
12722 /* In case of a template_decl, the only check that should be deferred
12723 to instantiation time is the comparison of underlying types. */
12724 if (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE)
12726 if (scoped_enum_p != SCOPED_ENUM_P (enumtype))
12728 error_at (input_location, "scoped/unscoped mismatch "
12729 "in enum %q#T", enumtype);
12730 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12731 "previous definition here");
12732 enumtype = error_mark_node;
12734 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) != !! underlying_type)
12736 error_at (input_location, "underlying type mismatch "
12737 "in enum %q#T", enumtype);
12738 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12739 "previous definition here");
12740 enumtype = error_mark_node;
12742 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype)
12743 && !dependent_type_p (underlying_type)
12744 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))
12745 && !same_type_p (underlying_type,
12746 ENUM_UNDERLYING_TYPE (enumtype)))
12748 error_at (input_location, "different underlying type "
12749 "in enum %q#T", enumtype);
12750 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
12751 "previous definition here");
12752 underlying_type = NULL_TREE;
12756 if (!enumtype || TREE_CODE (enumtype) != ENUMERAL_TYPE
12757 || processing_template_decl)
12759 /* In case of error, make a dummy enum to allow parsing to
12760 continue. */
12761 if (enumtype == error_mark_node)
12763 name = make_anon_name ();
12764 enumtype = NULL_TREE;
12767 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12768 of an opaque enum, or an opaque enum of an already defined
12769 enumeration (C++0x only).
12770 In any other case, it'll be NULL_TREE. */
12771 if (!enumtype)
12773 if (is_new)
12774 *is_new = true;
12776 prevtype = enumtype;
12778 /* Do not push the decl more than once, unless we need to
12779 compare underlying types at instantiation time */
12780 if (!enumtype
12781 || TREE_CODE (enumtype) != ENUMERAL_TYPE
12782 || (underlying_type
12783 && dependent_type_p (underlying_type))
12784 || (ENUM_UNDERLYING_TYPE (enumtype)
12785 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype))))
12787 enumtype = cxx_make_type (ENUMERAL_TYPE);
12788 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
12790 else
12791 enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current,
12792 false);
12794 if (enumtype == error_mark_node)
12795 return error_mark_node;
12797 /* The enum is considered opaque until the opening '{' of the
12798 enumerator list. */
12799 SET_OPAQUE_ENUM_P (enumtype, true);
12800 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) = !! underlying_type;
12803 SET_SCOPED_ENUM_P (enumtype, scoped_enum_p);
12805 if (underlying_type)
12807 if (CP_INTEGRAL_TYPE_P (underlying_type))
12809 copy_type_enum (enumtype, underlying_type);
12810 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12812 else if (dependent_type_p (underlying_type))
12813 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
12814 else
12815 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12816 underlying_type, enumtype);
12819 /* If into a template class, the returned enum is always the first
12820 declaration (opaque or not) seen. This way all the references to
12821 this type will be to the same declaration. The following ones are used
12822 only to check for definition errors. */
12823 if (prevtype && processing_template_decl)
12824 return prevtype;
12825 else
12826 return enumtype;
12829 /* After processing and defining all the values of an enumeration type,
12830 install their decls in the enumeration type.
12831 ENUMTYPE is the type object. */
12833 void
12834 finish_enum_value_list (tree enumtype)
12836 tree values;
12837 tree underlying_type;
12838 tree decl;
12839 tree value;
12840 tree minnode, maxnode;
12841 tree t;
12843 bool fixed_underlying_type_p
12844 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
12846 /* We built up the VALUES in reverse order. */
12847 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
12849 /* For an enum defined in a template, just set the type of the values;
12850 all further processing is postponed until the template is
12851 instantiated. We need to set the type so that tsubst of a CONST_DECL
12852 works. */
12853 if (processing_template_decl)
12855 for (values = TYPE_VALUES (enumtype);
12856 values;
12857 values = TREE_CHAIN (values))
12858 TREE_TYPE (TREE_VALUE (values)) = enumtype;
12859 return;
12862 /* Determine the minimum and maximum values of the enumerators. */
12863 if (TYPE_VALUES (enumtype))
12865 minnode = maxnode = NULL_TREE;
12867 for (values = TYPE_VALUES (enumtype);
12868 values;
12869 values = TREE_CHAIN (values))
12871 decl = TREE_VALUE (values);
12873 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12874 each enumerator has the type of its enumeration. Prior to the
12875 closing brace, the type of each enumerator is the type of its
12876 initializing value. */
12877 TREE_TYPE (decl) = enumtype;
12879 /* Update the minimum and maximum values, if appropriate. */
12880 value = DECL_INITIAL (decl);
12881 if (value == error_mark_node)
12882 value = integer_zero_node;
12883 /* Figure out what the minimum and maximum values of the
12884 enumerators are. */
12885 if (!minnode)
12886 minnode = maxnode = value;
12887 else if (tree_int_cst_lt (maxnode, value))
12888 maxnode = value;
12889 else if (tree_int_cst_lt (value, minnode))
12890 minnode = value;
12893 else
12894 /* [dcl.enum]
12896 If the enumerator-list is empty, the underlying type is as if
12897 the enumeration had a single enumerator with value 0. */
12898 minnode = maxnode = integer_zero_node;
12900 if (!fixed_underlying_type_p)
12902 /* Compute the number of bits require to represent all values of the
12903 enumeration. We must do this before the type of MINNODE and
12904 MAXNODE are transformed, since tree_int_cst_min_precision relies
12905 on the TREE_TYPE of the value it is passed. */
12906 signop sgn = tree_int_cst_sgn (minnode) >= 0 ? UNSIGNED : SIGNED;
12907 int lowprec = tree_int_cst_min_precision (minnode, sgn);
12908 int highprec = tree_int_cst_min_precision (maxnode, sgn);
12909 int precision = MAX (lowprec, highprec);
12910 unsigned int itk;
12911 bool use_short_enum;
12913 /* Determine the underlying type of the enumeration.
12915 [dcl.enum]
12917 The underlying type of an enumeration is an integral type that
12918 can represent all the enumerator values defined in the
12919 enumeration. It is implementation-defined which integral type is
12920 used as the underlying type for an enumeration except that the
12921 underlying type shall not be larger than int unless the value of
12922 an enumerator cannot fit in an int or unsigned int.
12924 We use "int" or an "unsigned int" as the underlying type, even if
12925 a smaller integral type would work, unless the user has
12926 explicitly requested that we use the smallest possible type. The
12927 user can request that for all enumerations with a command line
12928 flag, or for just one enumeration with an attribute. */
12930 use_short_enum = flag_short_enums
12931 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
12933 for (itk = (use_short_enum ? itk_char : itk_int);
12934 itk != itk_none;
12935 itk++)
12937 underlying_type = integer_types[itk];
12938 if (underlying_type != NULL_TREE
12939 && TYPE_PRECISION (underlying_type) >= precision
12940 && TYPE_SIGN (underlying_type) == sgn)
12941 break;
12943 if (itk == itk_none)
12945 /* DR 377
12947 IF no integral type can represent all the enumerator values, the
12948 enumeration is ill-formed. */
12949 error ("no integral type can represent all of the enumerator values "
12950 "for %qT", enumtype);
12951 precision = TYPE_PRECISION (long_long_integer_type_node);
12952 underlying_type = integer_types[itk_unsigned_long_long];
12955 /* [dcl.enum]
12957 The value of sizeof() applied to an enumeration type, an object
12958 of an enumeration type, or an enumerator, is the value of sizeof()
12959 applied to the underlying type. */
12960 copy_type_enum (enumtype, underlying_type);
12962 /* Compute the minimum and maximum values for the type.
12964 [dcl.enum]
12966 For an enumeration where emin is the smallest enumerator and emax
12967 is the largest, the values of the enumeration are the values of the
12968 underlying type in the range bmin to bmax, where bmin and bmax are,
12969 respectively, the smallest and largest values of the smallest bit-
12970 field that can store emin and emax. */
12972 /* The middle-end currently assumes that types with TYPE_PRECISION
12973 narrower than their underlying type are suitably zero or sign
12974 extended to fill their mode. Similarly, it assumes that the front
12975 end assures that a value of a particular type must be within
12976 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12978 We used to set these fields based on bmin and bmax, but that led
12979 to invalid assumptions like optimizing away bounds checking. So
12980 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12981 TYPE_MAX_VALUE to the values for the mode above and only restrict
12982 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12983 ENUM_UNDERLYING_TYPE (enumtype)
12984 = build_distinct_type_copy (underlying_type);
12985 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision;
12986 set_min_and_max_values_for_integral_type
12987 (ENUM_UNDERLYING_TYPE (enumtype), precision, sgn);
12989 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12990 if (flag_strict_enums)
12991 set_min_and_max_values_for_integral_type (enumtype, precision, sgn);
12993 else
12994 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
12996 /* Convert each of the enumerators to the type of the underlying
12997 type of the enumeration. */
12998 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
13000 location_t saved_location;
13002 decl = TREE_VALUE (values);
13003 saved_location = input_location;
13004 input_location = DECL_SOURCE_LOCATION (decl);
13005 if (fixed_underlying_type_p)
13006 /* If the enumeration type has a fixed underlying type, we
13007 already checked all of the enumerator values. */
13008 value = DECL_INITIAL (decl);
13009 else
13010 value = perform_implicit_conversion (underlying_type,
13011 DECL_INITIAL (decl),
13012 tf_warning_or_error);
13013 input_location = saved_location;
13015 /* Do not clobber shared ints. */
13016 value = copy_node (value);
13018 TREE_TYPE (value) = enumtype;
13019 DECL_INITIAL (decl) = value;
13022 /* Fix up all variant types of this enum type. */
13023 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
13024 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
13026 if (at_class_scope_p ()
13027 && COMPLETE_TYPE_P (current_class_type)
13028 && UNSCOPED_ENUM_P (enumtype))
13029 insert_late_enum_def_into_classtype_sorted_fields (enumtype,
13030 current_class_type);
13032 /* Finish debugging output for this type. */
13033 rest_of_type_compilation (enumtype, namespace_bindings_p ());
13036 /* Finishes the enum type. This is called only the first time an
13037 enumeration is seen, be it opaque or odinary.
13038 ENUMTYPE is the type object. */
13040 void
13041 finish_enum (tree enumtype)
13043 if (processing_template_decl)
13045 if (at_function_scope_p ())
13046 add_stmt (build_min (TAG_DEFN, enumtype));
13047 return;
13050 /* If this is a forward declaration, there should not be any variants,
13051 though we can get a variant in the middle of an enum-specifier with
13052 wacky code like 'enum E { e = sizeof(const E*) };' */
13053 gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
13054 && (TYPE_VALUES (enumtype)
13055 || !TYPE_NEXT_VARIANT (enumtype)));
13058 /* Build and install a CONST_DECL for an enumeration constant of the
13059 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13060 LOC is the location of NAME.
13061 Assignment of sequential values by default is handled here. */
13063 void
13064 build_enumerator (tree name, tree value, tree enumtype, location_t loc)
13066 tree decl;
13067 tree context;
13068 tree type;
13070 /* scalar_constant_value will pull out this expression, so make sure
13071 it's folded as appropriate. */
13072 if (processing_template_decl)
13073 value = fold_non_dependent_expr (value);
13075 /* If the VALUE was erroneous, pretend it wasn't there; that will
13076 result in the enum being assigned the next value in sequence. */
13077 if (value == error_mark_node)
13078 value = NULL_TREE;
13080 /* Remove no-op casts from the value. */
13081 if (value)
13082 STRIP_TYPE_NOPS (value);
13084 if (! processing_template_decl)
13086 /* Validate and default VALUE. */
13087 if (value != NULL_TREE)
13089 if (!ENUM_UNDERLYING_TYPE (enumtype))
13091 tree tmp_value = build_expr_type_conversion (WANT_INT | WANT_ENUM,
13092 value, true);
13093 if (tmp_value)
13094 value = tmp_value;
13096 else if (! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
13097 value = perform_implicit_conversion_flags
13098 (ENUM_UNDERLYING_TYPE (enumtype), value, tf_warning_or_error,
13099 LOOKUP_IMPLICIT | LOOKUP_NO_NARROWING);
13101 if (value == error_mark_node)
13102 value = NULL_TREE;
13104 if (value != NULL_TREE)
13106 value = cxx_constant_value (value);
13108 if (TREE_CODE (value) != INTEGER_CST
13109 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value)))
13111 error ("enumerator value for %qD is not an integer constant",
13112 name);
13113 value = NULL_TREE;
13118 /* Default based on previous value. */
13119 if (value == NULL_TREE)
13121 if (TYPE_VALUES (enumtype))
13123 tree prev_value;
13124 bool overflowed;
13126 /* C++03 7.2/4: If no initializer is specified for the first
13127 enumerator, the type is an unspecified integral
13128 type. Otherwise the type is the same as the type of the
13129 initializing value of the preceding enumerator unless the
13130 incremented value is not representable in that type, in
13131 which case the type is an unspecified integral type
13132 sufficient to contain the incremented value. */
13133 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
13134 if (error_operand_p (prev_value))
13135 value = error_mark_node;
13136 else
13138 tree type = TREE_TYPE (prev_value);
13139 signop sgn = TYPE_SIGN (type);
13140 widest_int wi = wi::add (wi::to_widest (prev_value), 1, sgn,
13141 &overflowed);
13142 if (!overflowed)
13144 bool pos = !wi::neg_p (wi, sgn);
13145 if (!wi::fits_to_tree_p (wi, type))
13147 unsigned int itk;
13148 for (itk = itk_int; itk != itk_none; itk++)
13150 type = integer_types[itk];
13151 if (type != NULL_TREE
13152 && (pos || !TYPE_UNSIGNED (type))
13153 && wi::fits_to_tree_p (wi, type))
13154 break;
13156 if (type && cxx_dialect < cxx11
13157 && itk > itk_unsigned_long)
13158 pedwarn (input_location, OPT_Wlong_long, pos ? "\
13159 incremented enumerator value is too large for %<unsigned long%>" : "\
13160 incremented enumerator value is too large for %<long%>");
13162 if (type == NULL_TREE)
13163 overflowed = true;
13164 else
13165 value = wide_int_to_tree (type, wi);
13168 if (overflowed)
13170 error ("overflow in enumeration values at %qD", name);
13171 value = error_mark_node;
13175 else
13176 value = integer_zero_node;
13179 /* Remove no-op casts from the value. */
13180 STRIP_TYPE_NOPS (value);
13182 /* If the underlying type of the enum is fixed, check whether
13183 the enumerator values fits in the underlying type. If it
13184 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13185 if (ENUM_UNDERLYING_TYPE (enumtype)
13186 && value
13187 && TREE_CODE (value) == INTEGER_CST)
13189 if (!int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
13190 error ("enumerator value %E is outside the range of underlying "
13191 "type %<%T%>", value, ENUM_UNDERLYING_TYPE (enumtype));
13193 /* Convert the value to the appropriate type. */
13194 value = convert (ENUM_UNDERLYING_TYPE (enumtype), value);
13198 /* C++ associates enums with global, function, or class declarations. */
13199 context = current_scope ();
13201 /* Build the actual enumeration constant. Note that the enumeration
13202 constants have the underlying type of the enum (if it is fixed)
13203 or the type of their initializer (if the underlying type of the
13204 enum is not fixed):
13206 [ C++0x dcl.enum ]
13208 If the underlying type is fixed, the type of each enumerator
13209 prior to the closing brace is the underlying type; if the
13210 initializing value of an enumerator cannot be represented by
13211 the underlying type, the program is ill-formed. If the
13212 underlying type is not fixed, the type of each enumerator is
13213 the type of its initializing value.
13215 If the underlying type is not fixed, it will be computed by
13216 finish_enum and we will reset the type of this enumerator. Of
13217 course, if we're processing a template, there may be no value. */
13218 type = value ? TREE_TYPE (value) : NULL_TREE;
13220 decl = build_decl (loc, CONST_DECL, name, type);
13222 DECL_CONTEXT (decl) = enumtype;
13223 TREE_CONSTANT (decl) = 1;
13224 TREE_READONLY (decl) = 1;
13225 DECL_INITIAL (decl) = value;
13227 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype))
13228 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13229 on the TYPE_FIELDS list for `S'. (That's so that you can say
13230 things like `S::i' later.) */
13231 finish_member_declaration (decl);
13232 else
13233 pushdecl (decl);
13235 /* Add this enumeration constant to the list for this type. */
13236 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
13239 /* Look for an enumerator with the given NAME within the enumeration
13240 type ENUMTYPE. This routine is used primarily for qualified name
13241 lookup into an enumerator in C++0x, e.g.,
13243 enum class Color { Red, Green, Blue };
13245 Color color = Color::Red;
13247 Returns the value corresponding to the enumerator, or
13248 NULL_TREE if no such enumerator was found. */
13249 tree
13250 lookup_enumerator (tree enumtype, tree name)
13252 tree e;
13253 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
13255 e = purpose_member (name, TYPE_VALUES (enumtype));
13256 return e? TREE_VALUE (e) : NULL_TREE;
13260 /* We're defining DECL. Make sure that its type is OK. */
13262 static void
13263 check_function_type (tree decl, tree current_function_parms)
13265 tree fntype = TREE_TYPE (decl);
13266 tree return_type = complete_type (TREE_TYPE (fntype));
13268 /* In a function definition, arg types must be complete. */
13269 require_complete_types_for_parms (current_function_parms);
13271 if (dependent_type_p (return_type)
13272 || type_uses_auto (return_type))
13273 return;
13274 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
13275 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
13277 tree args = TYPE_ARG_TYPES (fntype);
13279 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
13280 error ("return type %q#T is incomplete", return_type);
13281 else
13282 error ("return type has Java class type %q#T", return_type);
13284 /* Make it return void instead. */
13285 if (TREE_CODE (fntype) == METHOD_TYPE)
13286 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
13287 void_type_node,
13288 TREE_CHAIN (args));
13289 else
13290 fntype = build_function_type (void_type_node, args);
13291 fntype
13292 = build_exception_variant (fntype,
13293 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
13294 fntype = (cp_build_type_attribute_variant
13295 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
13296 TREE_TYPE (decl) = fntype;
13298 else
13299 abstract_virtuals_error (decl, TREE_TYPE (fntype));
13302 /* Create the FUNCTION_DECL for a function definition.
13303 DECLSPECS and DECLARATOR are the parts of the declaration;
13304 they describe the function's name and the type it returns,
13305 but twisted together in a fashion that parallels the syntax of C.
13307 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13308 DECLARATOR is really the DECL for the function we are about to
13309 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13310 indicating that the function is an inline defined in-class.
13312 This function creates a binding context for the function body
13313 as well as setting up the FUNCTION_DECL in current_function_decl.
13315 For C++, we must first check whether that datum makes any sense.
13316 For example, "class A local_a(1,2);" means that variable local_a
13317 is an aggregate of type A, which should have a constructor
13318 applied to it with the argument list [1, 2].
13320 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13321 or may be a BLOCK if the function has been defined previously
13322 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13323 error_mark_node if the function has never been defined, or
13324 a BLOCK if the function has been defined somewhere. */
13326 bool
13327 start_preparsed_function (tree decl1, tree attrs, int flags)
13329 tree ctype = NULL_TREE;
13330 tree fntype;
13331 tree restype;
13332 int doing_friend = 0;
13333 cp_binding_level *bl;
13334 tree current_function_parms;
13335 struct c_fileinfo *finfo
13336 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
13337 bool honor_interface;
13339 /* Sanity check. */
13340 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node)));
13341 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
13343 fntype = TREE_TYPE (decl1);
13344 if (TREE_CODE (fntype) == METHOD_TYPE)
13345 ctype = TYPE_METHOD_BASETYPE (fntype);
13347 /* ISO C++ 11.4/5. A friend function defined in a class is in
13348 the (lexical) scope of the class in which it is defined. */
13349 if (!ctype && DECL_FRIEND_P (decl1))
13351 ctype = DECL_FRIEND_CONTEXT (decl1);
13353 /* CTYPE could be null here if we're dealing with a template;
13354 for example, `inline friend float foo()' inside a template
13355 will have no CTYPE set. */
13356 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
13357 ctype = NULL_TREE;
13358 else
13359 doing_friend = 1;
13362 if (DECL_DECLARED_INLINE_P (decl1)
13363 && lookup_attribute ("noinline", attrs))
13364 warning (0, "inline function %q+D given attribute noinline", decl1);
13366 /* Handle gnu_inline attribute. */
13367 if (GNU_INLINE_P (decl1))
13369 DECL_EXTERNAL (decl1) = 1;
13370 DECL_NOT_REALLY_EXTERN (decl1) = 0;
13371 DECL_INTERFACE_KNOWN (decl1) = 1;
13372 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
13375 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
13376 /* This is a constructor, we must ensure that any default args
13377 introduced by this definition are propagated to the clones
13378 now. The clones are used directly in overload resolution. */
13379 adjust_clone_args (decl1);
13381 /* Sometimes we don't notice that a function is a static member, and
13382 build a METHOD_TYPE for it. Fix that up now. */
13383 gcc_assert (!(ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
13384 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE));
13386 /* Set up current_class_type, and enter the scope of the class, if
13387 appropriate. */
13388 if (ctype)
13389 push_nested_class (ctype);
13390 else if (DECL_STATIC_FUNCTION_P (decl1))
13391 push_nested_class (DECL_CONTEXT (decl1));
13393 /* Now that we have entered the scope of the class, we must restore
13394 the bindings for any template parameters surrounding DECL1, if it
13395 is an inline member template. (Order is important; consider the
13396 case where a template parameter has the same name as a field of
13397 the class.) It is not until after this point that
13398 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13399 if (flags & SF_INCLASS_INLINE)
13400 maybe_begin_member_template_processing (decl1);
13402 /* Effective C++ rule 15. */
13403 if (warn_ecpp
13404 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
13405 && VOID_TYPE_P (TREE_TYPE (fntype)))
13406 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
13408 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13409 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13410 if (!DECL_INITIAL (decl1))
13411 DECL_INITIAL (decl1) = error_mark_node;
13413 /* This function exists in static storage.
13414 (This does not mean `static' in the C sense!) */
13415 TREE_STATIC (decl1) = 1;
13417 /* We must call push_template_decl after current_class_type is set
13418 up. (If we are processing inline definitions after exiting a
13419 class scope, current_class_type will be NULL_TREE until set above
13420 by push_nested_class.) */
13421 if (processing_template_decl)
13423 tree newdecl1 = push_template_decl (decl1);
13424 if (newdecl1 == error_mark_node)
13426 if (ctype || DECL_STATIC_FUNCTION_P (decl1))
13427 pop_nested_class ();
13428 return false;
13430 decl1 = newdecl1;
13433 /* We are now in the scope of the function being defined. */
13434 current_function_decl = decl1;
13436 /* Save the parm names or decls from this function's declarator
13437 where store_parm_decls will find them. */
13438 current_function_parms = DECL_ARGUMENTS (decl1);
13440 /* Make sure the parameter and return types are reasonable. When
13441 you declare a function, these types can be incomplete, but they
13442 must be complete when you define the function. */
13443 check_function_type (decl1, current_function_parms);
13445 /* Build the return declaration for the function. */
13446 restype = TREE_TYPE (fntype);
13448 if (DECL_RESULT (decl1) == NULL_TREE)
13450 tree resdecl;
13452 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
13453 DECL_ARTIFICIAL (resdecl) = 1;
13454 DECL_IGNORED_P (resdecl) = 1;
13455 DECL_RESULT (decl1) = resdecl;
13457 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
13460 /* Let the user know we're compiling this function. */
13461 announce_function (decl1);
13463 /* Record the decl so that the function name is defined.
13464 If we already have a decl for this name, and it is a FUNCTION_DECL,
13465 use the old decl. */
13466 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
13468 /* A specialization is not used to guide overload resolution. */
13469 if (!DECL_FUNCTION_MEMBER_P (decl1)
13470 && !(DECL_USE_TEMPLATE (decl1) &&
13471 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
13473 tree olddecl = pushdecl (decl1);
13475 if (olddecl == error_mark_node)
13476 /* If something went wrong when registering the declaration,
13477 use DECL1; we have to have a FUNCTION_DECL to use when
13478 parsing the body of the function. */
13480 else
13482 /* Otherwise, OLDDECL is either a previous declaration
13483 of the same function or DECL1 itself. */
13485 if (warn_missing_declarations
13486 && olddecl == decl1
13487 && !DECL_MAIN_P (decl1)
13488 && TREE_PUBLIC (decl1)
13489 && !DECL_DECLARED_INLINE_P (decl1))
13491 tree context;
13493 /* Check whether DECL1 is in an anonymous
13494 namespace. */
13495 for (context = DECL_CONTEXT (decl1);
13496 context;
13497 context = DECL_CONTEXT (context))
13499 if (TREE_CODE (context) == NAMESPACE_DECL
13500 && DECL_NAME (context) == NULL_TREE)
13501 break;
13504 if (context == NULL)
13505 warning (OPT_Wmissing_declarations,
13506 "no previous declaration for %q+D", decl1);
13509 decl1 = olddecl;
13512 else
13514 /* We need to set the DECL_CONTEXT. */
13515 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
13516 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
13518 fntype = TREE_TYPE (decl1);
13519 restype = TREE_TYPE (fntype);
13521 /* If #pragma weak applies, mark the decl appropriately now.
13522 The pragma only applies to global functions. Because
13523 determining whether or not the #pragma applies involves
13524 computing the mangled name for the declaration, we cannot
13525 apply the pragma until after we have merged this declaration
13526 with any previous declarations; if the original declaration
13527 has a linkage specification, that specification applies to
13528 the definition as well, and may affect the mangled name. */
13529 if (DECL_FILE_SCOPE_P (decl1))
13530 maybe_apply_pragma_weak (decl1);
13533 /* Reset this in case the call to pushdecl changed it. */
13534 current_function_decl = decl1;
13536 gcc_assert (DECL_INITIAL (decl1));
13538 /* This function may already have been parsed, in which case just
13539 return; our caller will skip over the body without parsing. */
13540 if (DECL_INITIAL (decl1) != error_mark_node)
13541 return true;
13543 /* Initialize RTL machinery. We cannot do this until
13544 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13545 even when processing a template; this is how we get
13546 CFUN set up, and our per-function variables initialized.
13547 FIXME factor out the non-RTL stuff. */
13548 bl = current_binding_level;
13549 allocate_struct_function (decl1, processing_template_decl);
13551 /* Initialize the language data structures. Whenever we start
13552 a new function, we destroy temporaries in the usual way. */
13553 cfun->language = ggc_cleared_alloc<language_function> ();
13554 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
13555 current_binding_level = bl;
13557 if (!processing_template_decl && type_uses_auto (restype))
13559 FNDECL_USED_AUTO (decl1) = true;
13560 current_function_auto_return_pattern = restype;
13563 /* Start the statement-tree, start the tree now. */
13564 DECL_SAVED_TREE (decl1) = push_stmt_list ();
13566 /* If we are (erroneously) defining a function that we have already
13567 defined before, wipe out what we knew before. */
13568 if (!DECL_PENDING_INLINE_P (decl1))
13569 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
13571 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
13573 /* We know that this was set up by `grokclassfn'. We do not
13574 wait until `store_parm_decls', since evil parse errors may
13575 never get us to that point. Here we keep the consistency
13576 between `current_class_type' and `current_class_ptr'. */
13577 tree t = DECL_ARGUMENTS (decl1);
13579 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
13580 gcc_assert (TYPE_PTR_P (TREE_TYPE (t)));
13582 cp_function_chain->x_current_class_ref
13583 = cp_build_indirect_ref (t, RO_NULL, tf_warning_or_error);
13584 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13585 cp_function_chain->x_current_class_ptr = t;
13587 /* Constructors and destructors need to know whether they're "in
13588 charge" of initializing virtual base classes. */
13589 t = DECL_CHAIN (t);
13590 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
13592 current_in_charge_parm = t;
13593 t = DECL_CHAIN (t);
13595 if (DECL_HAS_VTT_PARM_P (decl1))
13597 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
13598 current_vtt_parm = t;
13602 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
13603 /* Implicitly-defined methods (like the
13604 destructor for a class in which no destructor
13605 is explicitly declared) must not be defined
13606 until their definition is needed. So, we
13607 ignore interface specifications for
13608 compiler-generated functions. */
13609 && !DECL_ARTIFICIAL (decl1));
13611 if (processing_template_decl)
13612 /* Don't mess with interface flags. */;
13613 else if (DECL_INTERFACE_KNOWN (decl1))
13615 tree ctx = decl_function_context (decl1);
13617 if (DECL_NOT_REALLY_EXTERN (decl1))
13618 DECL_EXTERNAL (decl1) = 0;
13620 if (ctx != NULL_TREE && vague_linkage_p (ctx))
13621 /* This is a function in a local class in an extern inline
13622 or template function. */
13623 comdat_linkage (decl1);
13625 /* If this function belongs to an interface, it is public.
13626 If it belongs to someone else's interface, it is also external.
13627 This only affects inlines and template instantiations. */
13628 else if (!finfo->interface_unknown && honor_interface)
13630 if (DECL_DECLARED_INLINE_P (decl1)
13631 || DECL_TEMPLATE_INSTANTIATION (decl1))
13633 DECL_EXTERNAL (decl1)
13634 = (finfo->interface_only
13635 || (DECL_DECLARED_INLINE_P (decl1)
13636 && ! flag_implement_inlines
13637 && !DECL_VINDEX (decl1)));
13639 /* For WIN32 we also want to put these in linkonce sections. */
13640 maybe_make_one_only (decl1);
13642 else
13643 DECL_EXTERNAL (decl1) = 0;
13644 DECL_INTERFACE_KNOWN (decl1) = 1;
13645 /* If this function is in an interface implemented in this file,
13646 make sure that the back end knows to emit this function
13647 here. */
13648 if (!DECL_EXTERNAL (decl1))
13649 mark_needed (decl1);
13651 else if (finfo->interface_unknown && finfo->interface_only
13652 && honor_interface)
13654 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13655 interface, we will have both finfo->interface_unknown and
13656 finfo->interface_only set. In that case, we don't want to
13657 use the normal heuristics because someone will supply a
13658 #pragma implementation elsewhere, and deducing it here would
13659 produce a conflict. */
13660 comdat_linkage (decl1);
13661 DECL_EXTERNAL (decl1) = 0;
13662 DECL_INTERFACE_KNOWN (decl1) = 1;
13663 DECL_DEFER_OUTPUT (decl1) = 1;
13665 else
13667 /* This is a definition, not a reference.
13668 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13669 if (!GNU_INLINE_P (decl1))
13670 DECL_EXTERNAL (decl1) = 0;
13672 if ((DECL_DECLARED_INLINE_P (decl1)
13673 || DECL_TEMPLATE_INSTANTIATION (decl1))
13674 && ! DECL_INTERFACE_KNOWN (decl1))
13675 DECL_DEFER_OUTPUT (decl1) = 1;
13676 else
13677 DECL_INTERFACE_KNOWN (decl1) = 1;
13680 /* Determine the ELF visibility attribute for the function. We must not
13681 do this before calling "pushdecl", as we must allow "duplicate_decls"
13682 to merge any attributes appropriately. We also need to wait until
13683 linkage is set. */
13684 if (!DECL_CLONED_FUNCTION_P (decl1))
13685 determine_visibility (decl1);
13687 if (!processing_template_decl)
13688 maybe_instantiate_noexcept (decl1);
13690 begin_scope (sk_function_parms, decl1);
13692 ++function_depth;
13694 if (DECL_DESTRUCTOR_P (decl1)
13695 || (DECL_CONSTRUCTOR_P (decl1)
13696 && targetm.cxx.cdtor_returns_this ()))
13698 cdtor_label = build_decl (input_location,
13699 LABEL_DECL, NULL_TREE, NULL_TREE);
13700 DECL_CONTEXT (cdtor_label) = current_function_decl;
13703 start_fname_decls ();
13705 store_parm_decls (current_function_parms);
13707 return true;
13711 /* Like start_preparsed_function, except that instead of a
13712 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13714 Returns true on success. If the DECLARATOR is not suitable
13715 for a function, we return false, which tells the parser to
13716 skip the entire function. */
13718 bool
13719 start_function (cp_decl_specifier_seq *declspecs,
13720 const cp_declarator *declarator,
13721 tree attrs)
13723 tree decl1;
13725 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
13726 if (decl1 == error_mark_node)
13727 return false;
13728 /* If the declarator is not suitable for a function definition,
13729 cause a syntax error. */
13730 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
13732 error ("invalid function declaration");
13733 return false;
13736 if (DECL_MAIN_P (decl1))
13737 /* main must return int. grokfndecl should have corrected it
13738 (and issued a diagnostic) if the user got it wrong. */
13739 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
13740 integer_type_node));
13742 return start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
13745 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13746 FN. */
13748 static bool
13749 use_eh_spec_block (tree fn)
13751 return (flag_exceptions && flag_enforce_eh_specs
13752 && !processing_template_decl
13753 && !type_throw_all_p (TREE_TYPE (fn))
13754 /* We insert the EH_SPEC_BLOCK only in the original
13755 function; then, it is copied automatically to the
13756 clones. */
13757 && !DECL_CLONED_FUNCTION_P (fn)
13758 /* Implicitly-generated constructors and destructors have
13759 exception specifications. However, those specifications
13760 are the union of the possible exceptions specified by the
13761 constructors/destructors for bases and members, so no
13762 unallowed exception will ever reach this function. By
13763 not creating the EH_SPEC_BLOCK we save a little memory,
13764 and we avoid spurious warnings about unreachable
13765 code. */
13766 && !DECL_DEFAULTED_FN (fn));
13769 /* Store the parameter declarations into the current function declaration.
13770 This is called after parsing the parameter declarations, before
13771 digesting the body of the function.
13773 Also install to binding contour return value identifier, if any. */
13775 static void
13776 store_parm_decls (tree current_function_parms)
13778 tree fndecl = current_function_decl;
13779 tree parm;
13781 /* This is a chain of any other decls that came in among the parm
13782 declarations. If a parm is declared with enum {foo, bar} x;
13783 then CONST_DECLs for foo and bar are put here. */
13784 tree nonparms = NULL_TREE;
13786 if (current_function_parms)
13788 /* This case is when the function was defined with an ANSI prototype.
13789 The parms already have decls, so we need not do anything here
13790 except record them as in effect
13791 and complain if any redundant old-style parm decls were written. */
13793 tree specparms = current_function_parms;
13794 tree next;
13796 /* Must clear this because it might contain TYPE_DECLs declared
13797 at class level. */
13798 current_binding_level->names = NULL;
13800 /* If we're doing semantic analysis, then we'll call pushdecl
13801 for each of these. We must do them in reverse order so that
13802 they end in the correct forward order. */
13803 specparms = nreverse (specparms);
13805 for (parm = specparms; parm; parm = next)
13807 next = DECL_CHAIN (parm);
13808 if (TREE_CODE (parm) == PARM_DECL)
13810 if (DECL_NAME (parm) == NULL_TREE
13811 || !VOID_TYPE_P (parm))
13812 pushdecl (parm);
13813 else
13814 error ("parameter %qD declared void", parm);
13816 else
13818 /* If we find an enum constant or a type tag,
13819 put it aside for the moment. */
13820 TREE_CHAIN (parm) = NULL_TREE;
13821 nonparms = chainon (nonparms, parm);
13825 /* Get the decls in their original chain order and record in the
13826 function. This is all and only the PARM_DECLs that were
13827 pushed into scope by the loop above. */
13828 DECL_ARGUMENTS (fndecl) = getdecls ();
13830 else
13831 DECL_ARGUMENTS (fndecl) = NULL_TREE;
13833 /* Now store the final chain of decls for the arguments
13834 as the decl-chain of the current lexical scope.
13835 Put the enumerators in as well, at the front so that
13836 DECL_ARGUMENTS is not modified. */
13837 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
13839 if (use_eh_spec_block (current_function_decl))
13840 current_eh_spec_block = begin_eh_spec_block ();
13844 /* We have finished doing semantic analysis on DECL, but have not yet
13845 generated RTL for its body. Save away our current state, so that
13846 when we want to generate RTL later we know what to do. */
13848 static void
13849 save_function_data (tree decl)
13851 struct language_function *f;
13853 /* Save the language-specific per-function data so that we can
13854 get it back when we really expand this function. */
13855 gcc_assert (!DECL_PENDING_INLINE_P (decl));
13857 /* Make a copy. */
13858 f = ggc_alloc<language_function> ();
13859 memcpy (f, cp_function_chain, sizeof (struct language_function));
13860 DECL_SAVED_FUNCTION_DATA (decl) = f;
13862 /* Clear out the bits we don't need. */
13863 f->base.x_stmt_tree.x_cur_stmt_list = NULL;
13864 f->bindings = NULL;
13865 f->x_local_names = NULL;
13866 f->base.local_typedefs = NULL;
13870 /* Set the return value of the constructor (if present). */
13872 static void
13873 finish_constructor_body (void)
13875 tree val;
13876 tree exprstmt;
13878 if (targetm.cxx.cdtor_returns_this ()
13879 && (! TYPE_FOR_JAVA (current_class_type)))
13881 /* Any return from a constructor will end up here. */
13882 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13884 val = DECL_ARGUMENTS (current_function_decl);
13885 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13886 DECL_RESULT (current_function_decl), val);
13887 /* Return the address of the object. */
13888 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13889 add_stmt (exprstmt);
13893 /* Do all the processing for the beginning of a destructor; set up the
13894 vtable pointers and cleanups for bases and members. */
13896 static void
13897 begin_destructor_body (void)
13899 tree compound_stmt;
13901 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13902 issued an error message. We still want to try to process the
13903 body of the function, but initialize_vtbl_ptrs will crash if
13904 TYPE_BINFO is NULL. */
13905 if (COMPLETE_TYPE_P (current_class_type))
13907 compound_stmt = begin_compound_stmt (0);
13908 /* Make all virtual function table pointers in non-virtual base
13909 classes point to CURRENT_CLASS_TYPE's virtual function
13910 tables. */
13911 initialize_vtbl_ptrs (current_class_ptr);
13912 finish_compound_stmt (compound_stmt);
13914 /* Insert a cleanup to let the back end know that the object is dead
13915 when we exit the destructor, either normally or via exception. */
13916 tree btype = CLASSTYPE_AS_BASE (current_class_type);
13917 tree clobber = build_constructor (btype, NULL);
13918 TREE_THIS_VOLATILE (clobber) = true;
13919 tree bref = build_nop (build_reference_type (btype), current_class_ptr);
13920 bref = convert_from_reference (bref);
13921 tree exprstmt = build2 (MODIFY_EXPR, btype, bref, clobber);
13922 finish_decl_cleanup (NULL_TREE, exprstmt);
13924 /* And insert cleanups for our bases and members so that they
13925 will be properly destroyed if we throw. */
13926 push_base_cleanups ();
13930 /* At the end of every destructor we generate code to delete the object if
13931 necessary. Do that now. */
13933 static void
13934 finish_destructor_body (void)
13936 tree exprstmt;
13938 /* Any return from a destructor will end up here; that way all base
13939 and member cleanups will be run when the function returns. */
13940 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
13942 /* In a virtual destructor, we must call delete. */
13943 if (DECL_VIRTUAL_P (current_function_decl))
13945 tree if_stmt;
13946 tree virtual_size = cxx_sizeof (current_class_type);
13948 /* [class.dtor]
13950 At the point of definition of a virtual destructor (including
13951 an implicit definition), non-placement operator delete shall
13952 be looked up in the scope of the destructor's class and if
13953 found shall be accessible and unambiguous. */
13954 exprstmt = build_op_delete_call (DELETE_EXPR, current_class_ptr,
13955 virtual_size,
13956 /*global_p=*/false,
13957 /*placement=*/NULL_TREE,
13958 /*alloc_fn=*/NULL_TREE,
13959 tf_warning_or_error);
13961 if_stmt = begin_if_stmt ();
13962 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
13963 current_in_charge_parm,
13964 integer_one_node),
13965 if_stmt);
13966 finish_expr_stmt (exprstmt);
13967 finish_then_clause (if_stmt);
13968 finish_if_stmt (if_stmt);
13971 if (targetm.cxx.cdtor_returns_this ())
13973 tree val;
13975 val = DECL_ARGUMENTS (current_function_decl);
13976 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
13977 DECL_RESULT (current_function_decl), val);
13978 /* Return the address of the object. */
13979 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
13980 add_stmt (exprstmt);
13984 /* Do the necessary processing for the beginning of a function body, which
13985 in this case includes member-initializers, but not the catch clauses of
13986 a function-try-block. Currently, this means opening a binding level
13987 for the member-initializers (in a ctor), member cleanups (in a dtor),
13988 and capture proxies (in a lambda operator()). */
13990 tree
13991 begin_function_body (void)
13993 tree stmt;
13995 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
13996 return NULL_TREE;
13998 if (processing_template_decl)
13999 /* Do nothing now. */;
14000 else
14001 /* Always keep the BLOCK node associated with the outermost pair of
14002 curly braces of a function. These are needed for correct
14003 operation of dwarfout.c. */
14004 keep_next_level (true);
14006 stmt = begin_compound_stmt (BCS_FN_BODY);
14008 if (processing_template_decl)
14009 /* Do nothing now. */;
14010 else if (DECL_DESTRUCTOR_P (current_function_decl))
14011 begin_destructor_body ();
14013 return stmt;
14016 /* Do the processing for the end of a function body. Currently, this means
14017 closing out the cleanups for fully-constructed bases and members, and in
14018 the case of the destructor, deleting the object if desired. Again, this
14019 is only meaningful for [cd]tors, since they are the only functions where
14020 there is a significant distinction between the main body and any
14021 function catch clauses. Handling, say, main() return semantics here
14022 would be wrong, as flowing off the end of a function catch clause for
14023 main() would also need to return 0. */
14025 void
14026 finish_function_body (tree compstmt)
14028 if (compstmt == NULL_TREE)
14029 return;
14031 /* Close the block. */
14032 finish_compound_stmt (compstmt);
14034 if (processing_template_decl)
14035 /* Do nothing now. */;
14036 else if (DECL_CONSTRUCTOR_P (current_function_decl))
14037 finish_constructor_body ();
14038 else if (DECL_DESTRUCTOR_P (current_function_decl))
14039 finish_destructor_body ();
14042 /* Given a function, returns the BLOCK corresponding to the outermost level
14043 of curly braces, skipping the artificial block created for constructor
14044 initializers. */
14046 tree
14047 outer_curly_brace_block (tree fndecl)
14049 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
14050 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
14051 /* Skip the artificial function body block. */
14052 block = BLOCK_SUBBLOCKS (block);
14053 return block;
14056 /* If FNDECL is a class's key method, add the class to the list of
14057 keyed classes that should be emitted. */
14059 static void
14060 record_key_method_defined (tree fndecl)
14062 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
14063 && DECL_VIRTUAL_P (fndecl)
14064 && !processing_template_decl)
14066 tree fnclass = DECL_CONTEXT (fndecl);
14067 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
14068 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
14072 /* Subroutine of finish_function.
14073 Save the body of constexpr functions for possible
14074 future compile time evaluation. */
14076 static void
14077 maybe_save_function_definition (tree fun)
14079 if (!processing_template_decl
14080 && DECL_DECLARED_CONSTEXPR_P (fun)
14081 && !cp_function_chain->invalid_constexpr
14082 && !DECL_CLONED_FUNCTION_P (fun))
14083 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
14086 /* Finish up a function declaration and compile that function
14087 all the way to assembler language output. The free the storage
14088 for the function definition.
14090 FLAGS is a bitwise or of the following values:
14091 2 - INCLASS_INLINE
14092 We just finished processing the body of an in-class inline
14093 function definition. (This processing will have taken place
14094 after the class definition is complete.) */
14096 tree
14097 finish_function (int flags)
14099 tree fndecl = current_function_decl;
14100 tree fntype, ctype = NULL_TREE;
14101 int inclass_inline = (flags & 2) != 0;
14103 /* When we get some parse errors, we can end up without a
14104 current_function_decl, so cope. */
14105 if (fndecl == NULL_TREE)
14106 return error_mark_node;
14108 if (c_dialect_objc ())
14109 objc_finish_function ();
14111 gcc_assert (!defer_mark_used_calls);
14112 defer_mark_used_calls = true;
14114 record_key_method_defined (fndecl);
14116 fntype = TREE_TYPE (fndecl);
14118 /* TREE_READONLY (fndecl) = 1;
14119 This caused &foo to be of type ptr-to-const-function
14120 which then got a warning when stored in a ptr-to-function variable. */
14122 gcc_assert (building_stmt_list_p ());
14123 /* The current function is being defined, so its DECL_INITIAL should
14124 be set, and unless there's a multiple definition, it should be
14125 error_mark_node. */
14126 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
14128 /* For a cloned function, we've already got all the code we need;
14129 there's no need to add any extra bits. */
14130 if (!DECL_CLONED_FUNCTION_P (fndecl))
14132 /* Make it so that `main' always returns 0 by default. */
14133 if (DECL_MAIN_P (current_function_decl))
14134 finish_return_stmt (integer_zero_node);
14136 if (use_eh_spec_block (current_function_decl))
14137 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14138 (TREE_TYPE (current_function_decl)),
14139 current_eh_spec_block);
14142 /* If we're saving up tree structure, tie off the function now. */
14143 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
14145 if (fn_contains_cilk_spawn_p (cfun) && !processing_template_decl)
14146 cfun->cilk_frame_decl = insert_cilk_frame (fndecl);
14148 finish_fname_decls ();
14150 /* If this function can't throw any exceptions, remember that. */
14151 if (!processing_template_decl
14152 && !cp_function_chain->can_throw
14153 && !flag_non_call_exceptions
14154 && !decl_replaceable_p (fndecl))
14155 TREE_NOTHROW (fndecl) = 1;
14157 /* This must come after expand_function_end because cleanups might
14158 have declarations (from inline functions) that need to go into
14159 this function's blocks. */
14161 /* If the current binding level isn't the outermost binding level
14162 for this function, either there is a bug, or we have experienced
14163 syntax errors and the statement tree is malformed. */
14164 if (current_binding_level->kind != sk_function_parms)
14166 /* Make sure we have already experienced errors. */
14167 gcc_assert (errorcount);
14169 /* Throw away the broken statement tree and extra binding
14170 levels. */
14171 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
14173 while (current_binding_level->kind != sk_function_parms)
14175 if (current_binding_level->kind == sk_class)
14176 pop_nested_class ();
14177 else
14178 poplevel (0, 0, 0);
14181 poplevel (1, 0, 1);
14183 /* Statements should always be full-expressions at the outermost set
14184 of curly braces for a function. */
14185 gcc_assert (stmts_are_full_exprs_p ());
14187 /* If there are no return statements in a function with auto return type,
14188 the return type is void. But if the declared type is something like
14189 auto*, this is an error. */
14190 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
14191 && TREE_TYPE (fntype) == current_function_auto_return_pattern)
14193 if (!is_auto (current_function_auto_return_pattern)
14194 && !current_function_returns_value && !current_function_returns_null)
14196 error ("no return statements in function returning %qT",
14197 current_function_auto_return_pattern);
14198 inform (input_location, "only plain %<auto%> return type can be "
14199 "deduced to %<void%>");
14201 apply_deduced_return_type (fndecl, void_type_node);
14202 fntype = TREE_TYPE (fndecl);
14205 /* Save constexpr function body before it gets munged by
14206 the NRV transformation. */
14207 maybe_save_function_definition (fndecl);
14209 /* Set up the named return value optimization, if we can. Candidate
14210 variables are selected in check_return_expr. */
14211 if (current_function_return_value)
14213 tree r = current_function_return_value;
14214 tree outer;
14216 if (r != error_mark_node
14217 /* This is only worth doing for fns that return in memory--and
14218 simpler, since we don't have to worry about promoted modes. */
14219 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
14220 /* Only allow this for variables declared in the outer scope of
14221 the function so we know that their lifetime always ends with a
14222 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14223 we were to do this optimization in tree-ssa. */
14224 && (outer = outer_curly_brace_block (fndecl))
14225 && chain_member (r, BLOCK_VARS (outer)))
14226 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
14228 current_function_return_value = NULL_TREE;
14231 /* Remember that we were in class scope. */
14232 if (current_class_name)
14233 ctype = current_class_type;
14235 /* Must mark the RESULT_DECL as being in this function. */
14236 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
14238 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14239 to the FUNCTION_DECL node itself. */
14240 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
14242 /* Save away current state, if appropriate. */
14243 if (!processing_template_decl)
14244 save_function_data (fndecl);
14246 /* Complain if there's just no return statement. */
14247 if (warn_return_type
14248 && !VOID_TYPE_P (TREE_TYPE (fntype))
14249 && !dependent_type_p (TREE_TYPE (fntype))
14250 && !current_function_returns_value && !current_function_returns_null
14251 /* Don't complain if we abort or throw. */
14252 && !current_function_returns_abnormally
14253 /* Don't complain if there's an infinite loop. */
14254 && !current_function_infinite_loop
14255 /* Don't complain if we are declared noreturn. */
14256 && !TREE_THIS_VOLATILE (fndecl)
14257 && !DECL_NAME (DECL_RESULT (fndecl))
14258 && !TREE_NO_WARNING (fndecl)
14259 /* Structor return values (if any) are set by the compiler. */
14260 && !DECL_CONSTRUCTOR_P (fndecl)
14261 && !DECL_DESTRUCTOR_P (fndecl)
14262 && targetm.warn_func_return (fndecl))
14264 warning (OPT_Wreturn_type,
14265 "no return statement in function returning non-void");
14266 TREE_NO_WARNING (fndecl) = 1;
14269 /* Store the end of the function, so that we get good line number
14270 info for the epilogue. */
14271 cfun->function_end_locus = input_location;
14273 /* Complain about parameters that are only set, but never otherwise used. */
14274 if (warn_unused_but_set_parameter
14275 && !processing_template_decl
14276 && errorcount == unused_but_set_errorcount
14277 && !DECL_CLONED_FUNCTION_P (fndecl))
14279 tree decl;
14281 for (decl = DECL_ARGUMENTS (fndecl);
14282 decl;
14283 decl = DECL_CHAIN (decl))
14284 if (TREE_USED (decl)
14285 && TREE_CODE (decl) == PARM_DECL
14286 && !DECL_READ_P (decl)
14287 && DECL_NAME (decl)
14288 && !DECL_ARTIFICIAL (decl)
14289 && !TREE_NO_WARNING (decl)
14290 && !DECL_IN_SYSTEM_HEADER (decl)
14291 && TREE_TYPE (decl) != error_mark_node
14292 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
14293 && (!CLASS_TYPE_P (TREE_TYPE (decl))
14294 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
14295 warning (OPT_Wunused_but_set_parameter,
14296 "parameter %q+D set but not used", decl);
14297 unused_but_set_errorcount = errorcount;
14300 /* Complain about locally defined typedefs that are not used in this
14301 function. */
14302 maybe_warn_unused_local_typedefs ();
14304 /* Genericize before inlining. */
14305 if (!processing_template_decl)
14307 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
14308 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
14309 cp_genericize (fndecl);
14310 /* Clear out the bits we don't need. */
14311 f->x_current_class_ptr = NULL;
14312 f->x_current_class_ref = NULL;
14313 f->x_eh_spec_block = NULL;
14314 f->x_in_charge_parm = NULL;
14315 f->x_vtt_parm = NULL;
14316 f->x_return_value = NULL;
14317 f->bindings = NULL;
14318 f->extern_decl_map = NULL;
14319 f->infinite_loops = NULL;
14321 /* Clear out the bits we don't need. */
14322 local_names = NULL;
14324 /* We're leaving the context of this function, so zap cfun. It's still in
14325 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14326 set_cfun (NULL);
14327 current_function_decl = NULL;
14329 /* If this is an in-class inline definition, we may have to pop the
14330 bindings for the template parameters that we added in
14331 maybe_begin_member_template_processing when start_function was
14332 called. */
14333 if (inclass_inline)
14334 maybe_end_member_template_processing ();
14336 /* Leave the scope of the class. */
14337 if (ctype)
14338 pop_nested_class ();
14340 --function_depth;
14342 /* Clean up. */
14343 current_function_decl = NULL_TREE;
14345 defer_mark_used_calls = false;
14346 if (deferred_mark_used_calls)
14348 unsigned int i;
14349 tree decl;
14351 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls, i, decl)
14352 mark_used (decl);
14353 vec_free (deferred_mark_used_calls);
14356 return fndecl;
14359 /* Create the FUNCTION_DECL for a function definition.
14360 DECLSPECS and DECLARATOR are the parts of the declaration;
14361 they describe the return type and the name of the function,
14362 but twisted together in a fashion that parallels the syntax of C.
14364 This function creates a binding context for the function body
14365 as well as setting up the FUNCTION_DECL in current_function_decl.
14367 Returns a FUNCTION_DECL on success.
14369 If the DECLARATOR is not suitable for a function (it defines a datum
14370 instead), we return 0, which tells yyparse to report a parse error.
14372 May return void_type_node indicating that this method is actually
14373 a friend. See grokfield for more details.
14375 Came here with a `.pushlevel' .
14377 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14378 CHANGES TO CODE IN `grokfield'. */
14380 tree
14381 grokmethod (cp_decl_specifier_seq *declspecs,
14382 const cp_declarator *declarator, tree attrlist)
14384 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
14385 &attrlist);
14387 if (fndecl == error_mark_node)
14388 return error_mark_node;
14390 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
14392 error ("invalid member function declaration");
14393 return error_mark_node;
14396 if (attrlist)
14397 cplus_decl_attributes (&fndecl, attrlist, 0);
14399 /* Pass friends other than inline friend functions back. */
14400 if (fndecl == void_type_node)
14401 return fndecl;
14403 if (DECL_IN_AGGR_P (fndecl))
14405 if (DECL_CLASS_SCOPE_P (fndecl))
14406 error ("%qD is already defined in class %qT", fndecl,
14407 DECL_CONTEXT (fndecl));
14408 return error_mark_node;
14411 check_template_shadow (fndecl);
14413 DECL_COMDAT (fndecl) = 1;
14414 DECL_DECLARED_INLINE_P (fndecl) = 1;
14415 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
14417 /* We process method specializations in finish_struct_1. */
14418 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
14420 fndecl = push_template_decl (fndecl);
14421 if (fndecl == error_mark_node)
14422 return fndecl;
14425 if (! DECL_FRIEND_P (fndecl))
14427 if (DECL_CHAIN (fndecl))
14429 fndecl = copy_node (fndecl);
14430 TREE_CHAIN (fndecl) = NULL_TREE;
14434 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
14436 DECL_IN_AGGR_P (fndecl) = 1;
14437 return fndecl;
14441 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14442 we can lay it out later, when and if its type becomes complete.
14444 Also handle constexpr variables where the initializer involves
14445 an unlowered PTRMEM_CST because the class isn't complete yet. */
14447 void
14448 maybe_register_incomplete_var (tree var)
14450 gcc_assert (VAR_P (var));
14452 /* Keep track of variables with incomplete types. */
14453 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
14454 && DECL_EXTERNAL (var))
14456 tree inner_type = TREE_TYPE (var);
14458 while (TREE_CODE (inner_type) == ARRAY_TYPE)
14459 inner_type = TREE_TYPE (inner_type);
14460 inner_type = TYPE_MAIN_VARIANT (inner_type);
14462 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
14463 /* RTTI TD entries are created while defining the type_info. */
14464 || (TYPE_LANG_SPECIFIC (inner_type)
14465 && TYPE_BEING_DEFINED (inner_type)))
14467 incomplete_var iv = {var, inner_type};
14468 vec_safe_push (incomplete_vars, iv);
14470 else if (!(DECL_LANG_SPECIFIC (var) && DECL_TEMPLATE_INFO (var))
14471 && decl_constant_var_p (var)
14472 && (TYPE_PTRMEM_P (inner_type) || CLASS_TYPE_P (inner_type)))
14474 /* When the outermost open class is complete we can resolve any
14475 pointers-to-members. */
14476 tree context = outermost_open_class ();
14477 incomplete_var iv = {var, context};
14478 vec_safe_push (incomplete_vars, iv);
14483 /* Called when a class type (given by TYPE) is defined. If there are
14484 any existing VAR_DECLs whose type has been completed by this
14485 declaration, update them now. */
14487 void
14488 complete_vars (tree type)
14490 unsigned ix;
14491 incomplete_var *iv;
14493 for (ix = 0; vec_safe_iterate (incomplete_vars, ix, &iv); )
14495 if (same_type_p (type, iv->incomplete_type))
14497 tree var = iv->decl;
14498 tree type = TREE_TYPE (var);
14500 if (TYPE_MAIN_VARIANT (strip_array_types (type))
14501 == iv->incomplete_type)
14503 /* Complete the type of the variable. The VAR_DECL itself
14504 will be laid out in expand_expr. */
14505 complete_type (type);
14506 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
14509 if (DECL_INITIAL (var)
14510 && decl_constant_var_p (var))
14511 DECL_INITIAL (var) = cplus_expand_constant (DECL_INITIAL (var));
14513 /* Remove this entry from the list. */
14514 incomplete_vars->unordered_remove (ix);
14516 else
14517 ix++;
14520 /* Check for pending declarations which may have abstract type. */
14521 complete_type_check_abstract (type);
14524 /* If DECL is of a type which needs a cleanup, build and return an
14525 expression to perform that cleanup here. Return NULL_TREE if no
14526 cleanup need be done. */
14528 tree
14529 cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
14531 tree type;
14532 tree attr;
14533 tree cleanup;
14535 /* Assume no cleanup is required. */
14536 cleanup = NULL_TREE;
14538 if (error_operand_p (decl))
14539 return cleanup;
14541 /* Handle "__attribute__((cleanup))". We run the cleanup function
14542 before the destructor since the destructor is what actually
14543 terminates the lifetime of the object. */
14544 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
14545 if (attr)
14547 tree id;
14548 tree fn;
14549 tree arg;
14551 /* Get the name specified by the user for the cleanup function. */
14552 id = TREE_VALUE (TREE_VALUE (attr));
14553 /* Look up the name to find the cleanup function to call. It is
14554 important to use lookup_name here because that is what is
14555 used in c-common.c:handle_cleanup_attribute when performing
14556 initial checks on the attribute. Note that those checks
14557 include ensuring that the function found is not an overloaded
14558 function, or an object with an overloaded call operator,
14559 etc.; we can rely on the fact that the function found is an
14560 ordinary FUNCTION_DECL. */
14561 fn = lookup_name (id);
14562 arg = build_address (decl);
14563 mark_used (decl);
14564 cleanup = cp_build_function_call_nary (fn, complain, arg, NULL_TREE);
14565 if (cleanup == error_mark_node)
14566 return error_mark_node;
14568 /* Handle ordinary C++ destructors. */
14569 type = TREE_TYPE (decl);
14570 if (type_build_dtor_call (type))
14572 int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR;
14573 tree addr;
14574 tree call;
14576 if (TREE_CODE (type) == ARRAY_TYPE)
14577 addr = decl;
14578 else
14579 addr = build_address (decl);
14581 call = build_delete (TREE_TYPE (addr), addr,
14582 sfk_complete_destructor, flags, 0, complain);
14583 if (call == error_mark_node)
14584 cleanup = error_mark_node;
14585 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
14586 /* Discard the call. */;
14587 else if (cleanup)
14588 cleanup = cp_build_compound_expr (cleanup, call, complain);
14589 else
14590 cleanup = call;
14593 /* build_delete sets the location of the destructor call to the
14594 current location, even though the destructor is going to be
14595 called later, at the end of the current scope. This can lead to
14596 a "jumpy" behaviour for users of debuggers when they step around
14597 the end of the block. So let's unset the location of the
14598 destructor call instead. */
14599 if (cleanup != NULL && EXPR_P (cleanup))
14600 SET_EXPR_LOCATION (cleanup, UNKNOWN_LOCATION);
14602 if (cleanup
14603 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl))))
14604 /* Treat objects with destructors as used; the destructor may do
14605 something substantive. */
14606 mark_used (decl);
14608 return cleanup;
14612 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14613 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14614 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14616 tree
14617 static_fn_type (tree memfntype)
14619 tree fntype;
14620 tree args;
14622 if (TYPE_PTRMEMFUNC_P (memfntype))
14623 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
14624 if (POINTER_TYPE_P (memfntype)
14625 || TREE_CODE (memfntype) == FUNCTION_DECL)
14626 memfntype = TREE_TYPE (memfntype);
14627 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
14628 return memfntype;
14629 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
14630 args = TYPE_ARG_TYPES (memfntype);
14631 cp_ref_qualifier rqual = type_memfn_rqual (memfntype);
14632 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
14633 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype), rqual);
14634 fntype = (cp_build_type_attribute_variant
14635 (fntype, TYPE_ATTRIBUTES (memfntype)));
14636 fntype = (build_exception_variant
14637 (fntype, TYPE_RAISES_EXCEPTIONS (memfntype)));
14638 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype))
14639 TYPE_HAS_LATE_RETURN_TYPE (fntype) = 1;
14640 return fntype;
14643 /* DECL was originally constructed as a non-static member function,
14644 but turned out to be static. Update it accordingly. */
14646 void
14647 revert_static_member_fn (tree decl)
14649 tree stype = static_fn_type (decl);
14650 cp_cv_quals quals = type_memfn_quals (stype);
14651 cp_ref_qualifier rqual = type_memfn_rqual (stype);
14653 if (quals != TYPE_UNQUALIFIED || rqual != REF_QUAL_NONE)
14654 stype = apply_memfn_quals (stype, TYPE_UNQUALIFIED, REF_QUAL_NONE);
14656 TREE_TYPE (decl) = stype;
14658 if (DECL_ARGUMENTS (decl))
14659 DECL_ARGUMENTS (decl) = DECL_CHAIN (DECL_ARGUMENTS (decl));
14660 DECL_STATIC_FUNCTION_P (decl) = 1;
14663 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14664 one of the language-independent trees. */
14666 enum cp_tree_node_structure_enum
14667 cp_tree_node_structure (union lang_tree_node * t)
14669 switch (TREE_CODE (&t->generic))
14671 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
14672 case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT;
14673 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
14674 case OVERLOAD: return TS_CP_OVERLOAD;
14675 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
14676 case PTRMEM_CST: return TS_CP_PTRMEM;
14677 case BASELINK: return TS_CP_BASELINK;
14678 case TEMPLATE_DECL: return TS_CP_TEMPLATE_DECL;
14679 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
14680 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
14681 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
14682 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR;
14683 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO;
14684 case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL;
14685 default: return TS_CP_GENERIC;
14689 /* Build the void_list_node (void_type_node having been created). */
14690 tree
14691 build_void_list_node (void)
14693 tree t = build_tree_list (NULL_TREE, void_type_node);
14694 return t;
14697 bool
14698 cp_missing_noreturn_ok_p (tree decl)
14700 /* A missing noreturn is ok for the `main' function. */
14701 return DECL_MAIN_P (decl);
14704 /* Return the decl used to identify the COMDAT group into which DECL should
14705 be placed. */
14707 tree
14708 cxx_comdat_group (tree decl)
14710 /* Virtual tables, construction virtual tables, and virtual table
14711 tables all go in a single COMDAT group, named after the primary
14712 virtual table. */
14713 if (VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl))
14714 decl = CLASSTYPE_VTABLES (DECL_CONTEXT (decl));
14715 /* For all other DECLs, the COMDAT group is the mangled name of the
14716 declaration itself. */
14717 else
14719 while (DECL_THUNK_P (decl))
14721 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14722 into the same section as the target function. In that case
14723 we must return target's name. */
14724 tree target = THUNK_TARGET (decl);
14725 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
14726 && DECL_SECTION_NAME (target) != NULL
14727 && DECL_ONE_ONLY (target))
14728 decl = target;
14729 else
14730 break;
14734 return decl;
14737 /* Returns the return type for FN as written by the user, which may include
14738 a placeholder for a deduced return type. */
14740 tree
14741 fndecl_declared_return_type (tree fn)
14743 fn = STRIP_TEMPLATE (fn);
14744 if (FNDECL_USED_AUTO (fn))
14746 struct language_function *f = NULL;
14747 if (DECL_STRUCT_FUNCTION (fn))
14748 f = DECL_STRUCT_FUNCTION (fn)->language;
14749 if (f == NULL)
14750 f = DECL_SAVED_FUNCTION_DATA (fn);
14751 return f->x_auto_return_pattern;
14753 return TREE_TYPE (TREE_TYPE (fn));
14756 /* Returns true iff DECL was declared with an auto return type and it has
14757 not yet been deduced to a real type. */
14759 bool
14760 undeduced_auto_decl (tree decl)
14762 if (cxx_dialect < cxx14)
14763 return false;
14764 return type_uses_auto (TREE_TYPE (decl));
14767 /* Complain if DECL has an undeduced return type. */
14769 void
14770 require_deduced_type (tree decl)
14772 if (undeduced_auto_decl (decl))
14773 error ("use of %qD before deduction of %<auto%>", decl);
14776 #include "gt-cp-decl.h"