1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2016 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
33 #include "c-family/c-target.h"
36 #include "stringpool.h"
38 #include "stor-layout.h"
42 #include "tree-iterator.h"
46 #include "c-family/c-objc.h"
47 #include "c-family/c-pragma.h"
48 #include "c-family/c-ubsan.h"
54 /* Possible cases of bad specifiers type used by bad_specifiers. */
56 BSP_VAR
, /* variable */
57 BSP_PARM
, /* parameter */
62 static const char *redeclaration_error_message (tree
, tree
);
64 static int decl_jump_unsafe (tree
);
65 static void require_complete_types_for_parms (tree
);
66 static int ambi_op_p (enum tree_code
);
67 static int unary_op_p (enum tree_code
);
68 static void push_local_name (tree
);
69 static tree
grok_reference_init (tree
, tree
, tree
, int);
70 static tree
grokvardecl (tree
, tree
, tree
, const cp_decl_specifier_seq
*,
72 static int check_static_variable_definition (tree
, tree
);
73 static void record_unknown_type (tree
, const char *);
74 static tree
builtin_function_1 (tree
, tree
, bool);
75 static int member_function_or_else (tree
, tree
, enum overload_flags
);
76 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
78 static void check_for_uninitialized_const_var (tree
);
79 static tree
local_variable_p_walkfn (tree
*, int *, void *);
80 static tree
record_builtin_java_type (const char *, int);
81 static const char *tag_name (enum tag_types
);
82 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
83 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
84 static void maybe_deduce_size_from_array_init (tree
, tree
);
85 static void layout_var_decl (tree
);
86 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
87 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
88 static void save_function_data (tree
);
89 static void copy_type_enum (tree
, tree
);
90 static void check_function_type (tree
, tree
);
91 static void finish_constructor_body (void);
92 static void begin_destructor_body (void);
93 static void finish_destructor_body (void);
94 static void record_key_method_defined (tree
);
95 static tree
create_array_type_for_decl (tree
, tree
, tree
);
96 static tree
get_atexit_node (void);
97 static tree
get_dso_handle_node (void);
98 static tree
start_cleanup_fn (void);
99 static void end_cleanup_fn (void);
100 static tree
cp_make_fname_decl (location_t
, tree
, int);
101 static void initialize_predefined_identifiers (void);
102 static tree check_special_function_return_type
103 (special_function_kind
, tree
, tree
, int, const location_t
*);
104 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
105 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
106 static void store_parm_decls (tree
);
107 static void initialize_local_var (tree
, tree
);
108 static void expand_static_init (tree
, tree
);
110 /* The following symbols are subsumed in the cp_global_trees array, and
111 listed here individually for documentation purposes.
114 tree wchar_decl_node;
116 tree vtable_entry_type;
117 tree delta_type_node;
118 tree __t_desc_type_node;
120 tree class_type_node;
121 tree unknown_type_node;
123 Array type `vtable_entry_type[]'
126 tree vtbl_ptr_type_node;
133 A FUNCTION_DECL which can call `abort'. Not necessarily the
134 one that the user will declare, but sufficient to be called
135 by routines that want to abort the program.
140 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
141 tree tinfo_var_id; */
143 tree cp_global_trees
[CPTI_MAX
];
145 /* Indicates that there is a type value in some namespace, although
146 that is not necessarily in scope at the moment. */
148 tree global_type_node
;
150 /* The node that holds the "name" of the global scope. */
151 tree global_scope_name
;
153 #define local_names cp_function_chain->x_local_names
155 /* A list of objects which have constructors or destructors
156 which reside in the global scope. The decl is stored in
157 the TREE_VALUE slot and the initializer is stored
158 in the TREE_PURPOSE slot. */
159 tree static_aggregates
;
161 /* Like static_aggregates, but for thread_local variables. */
166 /* A node for the integer constant 2. */
168 tree integer_two_node
;
170 /* Used only for jumps to as-yet undefined labels, since jumps to
171 defined labels can have their validity checked immediately. */
173 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
174 struct named_label_use_entry
*next
;
175 /* The binding level to which this entry is *currently* attached.
176 This is initially the binding level in which the goto appeared,
177 but is modified as scopes are closed. */
178 cp_binding_level
*binding_level
;
179 /* The head of the names list that was current when the goto appeared,
180 or the inner scope popped. These are the decls that will *not* be
181 skipped when jumping to the label. */
183 /* The location of the goto, for error reporting. */
184 location_t o_goto_locus
;
185 /* True if an OpenMP structured block scope has been closed since
186 the goto appeared. This means that the branch from the label will
187 illegally exit an OpenMP scope. */
191 /* A list of all LABEL_DECLs in the function that have names. Here so
192 we can clear out their names' definitions at the end of the
193 function, and so we can check the validity of jumps to these labels. */
195 struct GTY((for_user
)) named_label_entry
{
196 /* The decl itself. */
199 /* The binding level to which the label is *currently* attached.
200 This is initially set to the binding level in which the label
201 is defined, but is modified as scopes are closed. */
202 cp_binding_level
*binding_level
;
203 /* The head of the names list that was current when the label was
204 defined, or the inner scope popped. These are the decls that will
205 be skipped when jumping to the label. */
207 /* A vector of all decls from all binding levels that would be
208 crossed by a backward branch to the label. */
209 vec
<tree
, va_gc
> *bad_decls
;
211 /* A list of uses of the label, before the label is defined. */
212 struct named_label_use_entry
*uses
;
214 /* The following bits are set after the label is defined, and are
215 updated as scopes are popped. They indicate that a backward jump
216 to the label will illegally enter a scope of the given flavor. */
220 bool in_transaction_scope
;
223 #define named_labels cp_function_chain->x_named_labels
225 /* The number of function bodies which we are currently processing.
226 (Zero if we are at namespace scope, one inside the body of a
227 function, two inside the body of a function in a local class, etc.) */
230 /* States indicating how grokdeclarator() should handle declspecs marked
231 with __attribute__((deprecated)). An object declared as
232 __attribute__((deprecated)) suppresses warnings of uses of other
234 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
237 /* A list of VAR_DECLs whose type was incomplete at the time the
238 variable was declared. */
240 struct GTY(()) incomplete_var
{
242 tree incomplete_type
;
246 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
248 /* Returns the kind of template specialization we are currently
249 processing, given that it's declaration contained N_CLASS_SCOPES
250 explicit scope qualifications. */
253 current_tmpl_spec_kind (int n_class_scopes
)
255 int n_template_parm_scopes
= 0;
256 int seen_specialization_p
= 0;
257 int innermost_specialization_p
= 0;
260 /* Scan through the template parameter scopes. */
261 for (b
= current_binding_level
;
262 b
->kind
== sk_template_parms
;
265 /* If we see a specialization scope inside a parameter scope,
266 then something is wrong. That corresponds to a declaration
269 template <class T> template <> ...
271 which is always invalid since [temp.expl.spec] forbids the
272 specialization of a class member template if the enclosing
273 class templates are not explicitly specialized as well. */
274 if (b
->explicit_spec_p
)
276 if (n_template_parm_scopes
== 0)
277 innermost_specialization_p
= 1;
279 seen_specialization_p
= 1;
281 else if (seen_specialization_p
== 1)
282 return tsk_invalid_member_spec
;
284 ++n_template_parm_scopes
;
287 /* Handle explicit instantiations. */
288 if (processing_explicit_instantiation
)
290 if (n_template_parm_scopes
!= 0)
291 /* We've seen a template parameter list during an explicit
292 instantiation. For example:
294 template <class T> template void f(int);
296 This is erroneous. */
297 return tsk_invalid_expl_inst
;
299 return tsk_expl_inst
;
302 if (n_template_parm_scopes
< n_class_scopes
)
303 /* We've not seen enough template headers to match all the
304 specialized classes present. For example:
306 template <class T> void R<T>::S<T>::f(int);
308 This is invalid; there needs to be one set of template
309 parameters for each class. */
310 return tsk_insufficient_parms
;
311 else if (n_template_parm_scopes
== n_class_scopes
)
312 /* We're processing a non-template declaration (even though it may
313 be a member of a template class.) For example:
315 template <class T> void S<T>::f(int);
317 The `class T' matches the `S<T>', leaving no template headers
318 corresponding to the `f'. */
320 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
321 /* We've got too many template headers. For example:
323 template <> template <class T> void f (T);
325 There need to be more enclosing classes. */
326 return tsk_excessive_parms
;
328 /* This must be a template. It's of the form:
330 template <class T> template <class U> void S<T>::f(U);
332 This is a specialization if the innermost level was a
333 specialization; otherwise it's just a definition of the
335 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
338 /* Exit the current scope. */
346 /* When a label goes out of scope, check to see if that label was used
347 in a valid manner, and issue any appropriate warnings or errors. */
350 pop_label (tree label
, tree old_value
)
352 if (!processing_template_decl
)
354 if (DECL_INITIAL (label
) == NULL_TREE
)
358 error ("label %q+D used but not defined", label
);
359 location
= input_location
;
360 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
361 /* Avoid crashing later. */
362 define_label (location
, DECL_NAME (label
));
365 warn_for_unused_label (label
);
368 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
371 /* Push all named labels into a vector, so that we can sort it on DECL_UID
372 to avoid code generation differences. */
375 note_label (named_label_entry
**slot
, vec
<named_label_entry
**> &labels
)
377 labels
.quick_push (slot
);
381 /* Helper function to sort named label entries in a vector by DECL_UID. */
384 sort_labels (const void *a
, const void *b
)
386 named_label_entry
**slot1
= *(named_label_entry
**const *) a
;
387 named_label_entry
**slot2
= *(named_label_entry
**const *) b
;
388 if (DECL_UID ((*slot1
)->label_decl
) < DECL_UID ((*slot2
)->label_decl
))
390 if (DECL_UID ((*slot1
)->label_decl
) > DECL_UID ((*slot2
)->label_decl
))
395 /* At the end of a function, all labels declared within the function
396 go out of scope. BLOCK is the top-level block for the
400 pop_labels (tree block
)
404 auto_vec
<named_label_entry
**, 32> labels
;
405 named_label_entry
**slot
;
408 /* Push all the labels into a vector and sort them by DECL_UID,
409 so that gaps between DECL_UIDs don't affect code generation. */
410 labels
.reserve_exact (named_labels
->elements ());
411 named_labels
->traverse
<vec
<named_label_entry
**> &, note_label
> (labels
);
412 labels
.qsort (sort_labels
);
413 FOR_EACH_VEC_ELT (labels
, i
, slot
)
415 struct named_label_entry
*ent
= *slot
;
417 pop_label (ent
->label_decl
, NULL_TREE
);
419 /* Put the labels into the "variables" of the top-level block,
420 so debugger can see them. */
421 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
422 BLOCK_VARS (block
) = ent
->label_decl
;
424 named_labels
->clear_slot (slot
);
430 /* At the end of a block with local labels, restore the outer definition. */
433 pop_local_label (tree label
, tree old_value
)
435 struct named_label_entry dummy
;
437 pop_label (label
, old_value
);
439 dummy
.label_decl
= label
;
440 named_label_entry
**slot
= named_labels
->find_slot (&dummy
, NO_INSERT
);
441 named_labels
->clear_slot (slot
);
444 /* The following two routines are used to interface to Objective-C++.
445 The binding level is purposely treated as an opaque type. */
448 objc_get_current_scope (void)
450 return current_binding_level
;
453 /* The following routine is used by the NeXT-style SJLJ exceptions;
454 variables get marked 'volatile' so as to not be clobbered by
455 _setjmp()/_longjmp() calls. All variables in the current scope,
456 as well as parent scopes up to (but not including) ENCLOSING_BLK
457 shall be thusly marked. */
460 objc_mark_locals_volatile (void *enclosing_blk
)
462 cp_binding_level
*scope
;
464 for (scope
= current_binding_level
;
465 scope
&& scope
!= enclosing_blk
;
466 scope
= scope
->level_chain
)
470 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
471 objc_volatilize_decl (decl
);
473 /* Do not climb up past the current function. */
474 if (scope
->kind
== sk_function_parms
)
479 /* Update data for defined and undefined labels when leaving a scope. */
482 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
484 named_label_entry
*ent
= *slot
;
485 cp_binding_level
*obl
= bl
->level_chain
;
487 if (ent
->binding_level
== bl
)
491 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
492 TREE_LISTs representing OVERLOADs, so be careful. */
493 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
495 : TREE_CHAIN (decl
)))
496 if (decl_jump_unsafe (decl
))
497 vec_safe_push (ent
->bad_decls
, decl
);
499 ent
->binding_level
= obl
;
500 ent
->names_in_scope
= obl
->names
;
504 ent
->in_try_scope
= true;
507 ent
->in_catch_scope
= true;
510 ent
->in_omp_scope
= true;
513 ent
->in_transaction_scope
= true;
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;
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
552 If REVERSE is nonzero, reverse the order of decls before putting
553 them into the BLOCK. */
556 poplevel (int keep
, int reverse
, int functionbody
)
559 /* The chain of decls was accumulated in reverse order.
560 Put it into forward order, just for cleanliness. */
565 int leaving_for_scope
;
568 cp_label_binding
*label_bind
;
570 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
575 gcc_assert (current_binding_level
->kind
!= sk_class
);
577 if (current_binding_level
->kind
== sk_cleanup
)
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
)
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. */
602 current_binding_level
->names
603 = decls
= nreverse (current_binding_level
->names
);
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. */
611 /* Avoid function body block if possible. */
612 if (functionbody
&& subblocks
&& BLOCK_CHAIN (subblocks
) == NULL_TREE
)
614 else if (keep
== 1 || functionbody
)
615 block
= make_node (BLOCK
);
616 if (block
!= NULL_TREE
)
618 BLOCK_VARS (block
) = decls
;
619 BLOCK_SUBBLOCKS (block
) = subblocks
;
622 /* In each subblock, record that this is its superior. */
624 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
625 BLOCK_SUPERCONTEXT (link
) = block
;
627 /* We still support the old for-scope rules, whereby the variables
628 in a for-init statement were in scope after the for-statement
629 ended. We only use the new rules if flag_new_for_scope is
632 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
634 /* Before we remove the declarations first check for unused variables. */
635 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
636 && current_binding_level
->kind
!= sk_template_parms
637 && !processing_template_decl
)
638 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
640 /* There are cases where D itself is a TREE_LIST. See in
641 push_local_binding where the list of decls returned by
642 getdecls is built. */
643 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
644 tree type
= TREE_TYPE (decl
);
646 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
647 && ! DECL_IN_SYSTEM_HEADER (decl
)
648 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
649 && type
!= error_mark_node
650 && (!CLASS_TYPE_P (type
)
651 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
652 || lookup_attribute ("warn_unused",
653 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
655 if (! TREE_USED (decl
))
656 warning_at (DECL_SOURCE_LOCATION (decl
),
657 OPT_Wunused_variable
, "unused variable %qD", decl
);
658 else if (DECL_CONTEXT (decl
) == current_function_decl
659 // For -Wunused-but-set-variable leave references alone.
660 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
661 && errorcount
== unused_but_set_errorcount
)
663 warning_at (DECL_SOURCE_LOCATION (decl
),
664 OPT_Wunused_but_set_variable
,
665 "variable %qD set but not used", decl
);
666 unused_but_set_errorcount
= errorcount
;
671 /* Remove declarations for all the DECLs in this level. */
672 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
674 if (leaving_for_scope
&& VAR_P (link
)
675 /* It's hard to make this ARM compatibility hack play nicely with
676 lambdas, and it really isn't necessary in C++11 mode. */
677 && cxx_dialect
< cxx11
680 tree name
= DECL_NAME (link
);
684 ob
= outer_binding (name
,
685 IDENTIFIER_BINDING (name
),
688 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
690 ns_binding
= NULL_TREE
;
692 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
693 /* We have something like:
698 and we are leaving the `for' scope. There's no reason to
699 keep the binding of the inner `i' in this case. */
700 pop_binding (name
, link
);
701 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
702 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
703 /* Here, we have something like:
711 We must pop the for-scope binding so we know what's a
712 type and what isn't. */
713 pop_binding (name
, link
);
716 /* Mark this VAR_DECL as dead so that we can tell we left it
717 there only for backward compatibility. */
718 DECL_DEAD_FOR_LOCAL (link
) = 1;
720 /* Keep track of what should have happened when we
721 popped the binding. */
724 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
725 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
728 /* Add it to the list of dead variables in the next
729 outermost binding to that we can remove these when we
730 leave that binding. */
732 current_binding_level
->level_chain
->dead_vars_from_for
,
735 /* Although we don't pop the cxx_binding, we do clear
736 its SCOPE since the scope is going away now. */
737 IDENTIFIER_BINDING (name
)->scope
738 = current_binding_level
->level_chain
;
745 /* Remove the binding. */
748 if (TREE_CODE (decl
) == TREE_LIST
)
749 decl
= TREE_VALUE (decl
);
752 if (TREE_CODE (name
) == OVERLOAD
)
753 name
= OVL_FUNCTION (name
);
755 gcc_assert (DECL_P (name
));
756 pop_binding (DECL_NAME (name
), decl
);
760 /* Remove declarations for any `for' variables from inner scopes
761 that we kept around. */
762 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
764 pop_binding (DECL_NAME (decl
), decl
);
766 /* Restore the IDENTIFIER_TYPE_VALUEs. */
767 for (link
= current_binding_level
->type_shadowed
;
768 link
; link
= TREE_CHAIN (link
))
769 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
771 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
772 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
774 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
776 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
777 list if a `using' declaration put them there. The debugging
778 back ends won't understand OVERLOAD, so we remove them here.
779 Because the BLOCK_VARS are (temporarily) shared with
780 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
781 popped all the bindings. */
786 for (d
= &BLOCK_VARS (block
); *d
; )
788 if (TREE_CODE (*d
) == TREE_LIST
)
789 *d
= TREE_CHAIN (*d
);
791 d
= &DECL_CHAIN (*d
);
795 /* If the level being exited is the top level of a function,
796 check over all the labels. */
801 /* Since this is the top level block of a function, the vars are
802 the function's parameters. Don't leave them in the BLOCK
803 because they are found in the FUNCTION_DECL instead. */
804 BLOCK_VARS (block
) = 0;
808 pop_labels (subblocks
);
811 kind
= current_binding_level
->kind
;
812 if (kind
== sk_cleanup
)
816 /* If this is a temporary binding created for a cleanup, then we'll
817 have pushed a statement list level. Pop that, create a new
818 BIND_EXPR for the block, and insert it into the stream. */
819 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
820 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
827 /* The current function is being defined, so its DECL_INITIAL
828 should be error_mark_node. */
829 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
830 DECL_INITIAL (current_function_decl
) = block
? block
: subblocks
;
833 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
835 if (BLOCK_SUBBLOCKS (subblocks
))
836 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks
)) = 1;
839 BLOCK_OUTER_CURLY_BRACE_P (subblocks
) = 1;
843 current_binding_level
->blocks
844 = block_chainon (current_binding_level
->blocks
, block
);
846 /* If we did not make a block for the level just exited,
847 any blocks made for inner levels
848 (since they cannot be recorded as subblocks in that level)
849 must be carried forward so they will later become subblocks
850 of something else. */
852 current_binding_level
->blocks
853 = block_chainon (current_binding_level
->blocks
, subblocks
);
855 /* Each and every BLOCK node created here in `poplevel' is important
856 (e.g. for proper debugging information) so if we created one
857 earlier, mark it as "used". */
859 TREE_USED (block
) = 1;
861 /* All temporary bindings created for cleanups are popped silently. */
862 if (kind
== sk_cleanup
)
865 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
869 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
870 itself, calling F for each. The DATA is passed to F as well. */
873 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
876 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
878 result
|= (*f
) (name_space
, data
);
880 for (; current
; current
= DECL_CHAIN (current
))
881 result
|= walk_namespaces_r (current
, f
, data
);
886 /* Walk all the namespaces, calling F for each. The DATA is passed to
890 walk_namespaces (walk_namespaces_fn f
, void* data
)
892 return walk_namespaces_r (global_namespace
, f
, data
);
895 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
898 wrapup_globals_for_namespace (tree name_space
, void* data ATTRIBUTE_UNUSED
)
900 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
901 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
902 tree
*vec
= statics
->address ();
903 int len
= statics
->length ();
905 if (warn_unused_function
)
909 FOR_EACH_VEC_SAFE_ELT (statics
, i
, decl
)
910 if (TREE_CODE (decl
) == FUNCTION_DECL
911 && DECL_INITIAL (decl
) == 0
912 && DECL_EXTERNAL (decl
)
913 && !TREE_PUBLIC (decl
)
914 && !DECL_ARTIFICIAL (decl
)
915 && !TREE_NO_WARNING (decl
))
917 warning (OPT_Wunused_function
,
918 "%q+F declared %<static%> but never defined", decl
);
919 TREE_NO_WARNING (decl
) = 1;
923 /* Write out any globals that need to be output. */
924 return wrapup_global_declarations (vec
, len
);
927 /* In C++, you don't have to write `struct S' to refer to `S'; you
928 can just use `S'. We accomplish this by creating a TYPE_DECL as
929 if the user had written `typedef struct S S'. Create and return
930 the TYPE_DECL for TYPE. */
933 create_implicit_typedef (tree name
, tree type
)
937 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
938 DECL_ARTIFICIAL (decl
) = 1;
939 /* There are other implicit type declarations, like the one *within*
940 a class that allows you to write `S::S'. We must distinguish
942 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
943 TYPE_NAME (type
) = decl
;
944 TYPE_STUB_DECL (type
) = decl
;
949 /* Remember a local name for name-mangling purposes. */
952 push_local_name (tree decl
)
957 timevar_start (TV_NAME_LOOKUP
);
959 name
= DECL_NAME (decl
);
961 nelts
= vec_safe_length (local_names
);
962 for (i
= 0; i
< nelts
; i
++)
964 t
= (*local_names
)[i
];
965 if (DECL_NAME (t
) == name
)
967 if (!DECL_LANG_SPECIFIC (decl
))
968 retrofit_lang_decl (decl
);
969 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
970 if (DECL_DISCRIMINATOR_SET_P (t
))
971 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
973 DECL_DISCRIMINATOR (decl
) = 1;
975 (*local_names
)[i
] = decl
;
976 timevar_stop (TV_NAME_LOOKUP
);
981 vec_safe_push (local_names
, decl
);
982 timevar_stop (TV_NAME_LOOKUP
);
985 /* Subroutine of duplicate_decls: return truthvalue of whether
986 or not types of these decls match.
988 For C++, we must compare the parameter list so that `int' can match
989 `int&' in a parameter position, but `int&' is not confused with
993 decls_match (tree newdecl
, tree olddecl
)
997 if (newdecl
== olddecl
)
1000 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
1001 /* If the two DECLs are not even the same kind of thing, we're not
1002 interested in their types. */
1005 gcc_assert (DECL_P (newdecl
));
1007 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1009 tree f1
= TREE_TYPE (newdecl
);
1010 tree f2
= TREE_TYPE (olddecl
);
1011 tree p1
= TYPE_ARG_TYPES (f1
);
1012 tree p2
= TYPE_ARG_TYPES (f2
);
1015 /* Specializations of different templates are different functions
1016 even if they have the same type. */
1017 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
1018 ? DECL_TI_TEMPLATE (newdecl
)
1020 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
1021 ? DECL_TI_TEMPLATE (olddecl
)
1026 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1027 && ! (DECL_EXTERN_C_P (newdecl
)
1028 && DECL_EXTERN_C_P (olddecl
)))
1031 /* A new declaration doesn't match a built-in one unless it
1032 is also extern "C". */
1033 if (DECL_IS_BUILTIN (olddecl
)
1034 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1037 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1040 /* A declaration with deduced return type should use its pre-deduction
1041 type for declaration matching. */
1042 r2
= fndecl_declared_return_type (olddecl
);
1044 if (same_type_p (TREE_TYPE (f1
), r2
))
1046 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1047 && (DECL_BUILT_IN (olddecl
)
1048 #ifndef NO_IMPLICIT_EXTERN_C
1049 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1050 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1054 types_match
= self_promoting_args_p (p1
);
1055 if (p1
== void_list_node
)
1056 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1058 #ifndef NO_IMPLICIT_EXTERN_C
1059 else if (!prototype_p (f1
)
1060 && (DECL_EXTERN_C_P (olddecl
)
1061 && DECL_IN_SYSTEM_HEADER (olddecl
)
1062 && !DECL_CLASS_SCOPE_P (olddecl
))
1063 && (DECL_EXTERN_C_P (newdecl
)
1064 && DECL_IN_SYSTEM_HEADER (newdecl
)
1065 && !DECL_CLASS_SCOPE_P (newdecl
)))
1067 types_match
= self_promoting_args_p (p2
);
1068 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1074 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1075 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1076 || comp_type_attributes (TREE_TYPE (newdecl
),
1077 TREE_TYPE (olddecl
)) != 0);
1082 /* The decls dont match if they correspond to two different versions
1083 of the same function. Disallow extern "C" functions to be
1084 versions for now. */
1086 && !DECL_EXTERN_C_P (newdecl
)
1087 && !DECL_EXTERN_C_P (olddecl
)
1088 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1090 /* Mark functions as versions if necessary. Modify the mangled decl
1091 name if necessary. */
1092 if (DECL_FUNCTION_VERSIONED (newdecl
)
1093 && DECL_FUNCTION_VERSIONED (olddecl
))
1095 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1097 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1098 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1099 mangle_decl (newdecl
);
1101 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1103 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1104 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1105 mangle_decl (olddecl
);
1107 cgraph_node::record_function_versions (olddecl
, newdecl
);
1111 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1113 tree oldres
= DECL_TEMPLATE_RESULT (olddecl
);
1114 tree newres
= DECL_TEMPLATE_RESULT (newdecl
);
1116 if (TREE_CODE (newres
) != TREE_CODE (oldres
))
1119 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1120 DECL_TEMPLATE_PARMS (olddecl
)))
1123 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1124 types_match
= (same_type_p (TREE_TYPE (oldres
), TREE_TYPE (newres
))
1125 && equivalently_constrained (olddecl
, newdecl
));
1127 // We don't need to check equivalently_constrained for variable and
1128 // function templates because we check it on the results.
1129 types_match
= decls_match (oldres
, newres
);
1133 /* Need to check scope for variable declaration (VAR_DECL).
1134 For typedef (TYPE_DECL), scope is ignored. */
1136 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1138 Two declarations for an object with C language linkage
1139 with the same name (ignoring the namespace that qualify
1140 it) that appear in different namespace scopes refer to
1142 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1145 if (TREE_TYPE (newdecl
) == error_mark_node
)
1146 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1147 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1148 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1149 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1152 types_match
= comptypes (TREE_TYPE (newdecl
),
1153 TREE_TYPE (olddecl
),
1154 COMPARE_REDECLARATION
);
1157 // Normal functions can be constrained, as can variable partial
1159 if (types_match
&& VAR_OR_FUNCTION_DECL_P (newdecl
))
1160 types_match
= equivalently_constrained (newdecl
, olddecl
);
1165 /* If NEWDECL is `static' and an `extern' was seen previously,
1166 warn about it. OLDDECL is the previous declaration.
1168 Note that this does not apply to the C++ case of declaring
1169 a variable `extern const' and then later `const'.
1171 Don't complain about built-in functions, since they are beyond
1172 the user's control. */
1175 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1177 if (TREE_CODE (newdecl
) == TYPE_DECL
1178 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1179 || TREE_CODE (newdecl
) == CONST_DECL
1180 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1183 /* Don't get confused by static member functions; that's a different
1185 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1186 && DECL_STATIC_FUNCTION_P (newdecl
))
1189 /* If the old declaration was `static', or the new one isn't, then
1190 everything is OK. */
1191 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1194 /* It's OK to declare a builtin function as `static'. */
1195 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1196 && DECL_ARTIFICIAL (olddecl
))
1199 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1200 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1201 inform (DECL_SOURCE_LOCATION (olddecl
),
1202 "previous declaration of %qD", olddecl
);
1205 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1206 function templates. If their exception specifications do not
1207 match, issue a diagnostic. */
1210 check_redeclaration_exception_specification (tree new_decl
,
1213 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1214 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1216 /* Two default specs are equivalent, don't force evaluation. */
1217 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1218 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1221 maybe_instantiate_noexcept (new_decl
);
1222 maybe_instantiate_noexcept (old_decl
);
1223 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1224 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1228 If any declaration of a function has an exception-specification,
1229 all declarations, including the definition and an explicit
1230 specialization, of that function shall have an
1231 exception-specification with the same set of type-ids. */
1232 if (! DECL_IS_BUILTIN (old_decl
)
1233 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1236 = "declaration of %q+F has a different exception specifier";
1237 bool complained
= true;
1238 if (DECL_IN_SYSTEM_HEADER (old_decl
))
1239 complained
= pedwarn (0, OPT_Wsystem_headers
, msg
, new_decl
);
1240 else if (!flag_exceptions
)
1241 /* We used to silently permit mismatched eh specs with
1242 -fno-exceptions, so make them a pedwarn now. */
1243 complained
= pedwarn (0, OPT_Wpedantic
, msg
, new_decl
);
1245 error (msg
, new_decl
);
1247 inform (0, "from previous declaration %q+F", old_decl
);
1251 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1252 Otherwise issue diagnostics. */
1255 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1257 old_decl
= STRIP_TEMPLATE (old_decl
);
1258 new_decl
= STRIP_TEMPLATE (new_decl
);
1259 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1260 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1262 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1263 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1265 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1267 if (DECL_BUILT_IN (old_decl
))
1269 /* Hide a built-in declaration. */
1270 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1271 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1274 /* 7.1.5 [dcl.constexpr]
1275 Note: An explicit specialization can differ from the template
1276 declaration with respect to the constexpr specifier. */
1277 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1278 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1281 error ("redeclaration %q+D differs in %<constexpr%>", new_decl
);
1282 error ("from previous declaration %q+D", old_decl
);
1288 // If OLDDECL and NEWDECL are concept declarations with the same type
1289 // (i.e., and template parameters), but different requirements,
1290 // emit diagnostics and return true. Otherwise, return false.
1292 check_concept_refinement (tree olddecl
, tree newdecl
)
1294 if (!DECL_DECLARED_CONCEPT_P (olddecl
) || !DECL_DECLARED_CONCEPT_P (newdecl
))
1297 tree d1
= DECL_TEMPLATE_RESULT (olddecl
);
1298 tree d2
= DECL_TEMPLATE_RESULT (newdecl
);
1299 if (TREE_CODE (d1
) != TREE_CODE (d2
))
1302 tree t1
= TREE_TYPE (d1
);
1303 tree t2
= TREE_TYPE (d2
);
1304 if (TREE_CODE (d1
) == FUNCTION_DECL
)
1306 if (compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
))
1307 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl
),
1308 DECL_TEMPLATE_PARMS (newdecl
))
1309 && !equivalently_constrained (olddecl
, newdecl
))
1311 error ("cannot specialize concept %q#D", olddecl
);
1318 /* DECL is a redeclaration of a function or function template. If
1319 it does have default arguments issue a diagnostic. Note: this
1320 function is used to enforce the requirements in C++11 8.3.6 about
1321 no default arguments in redeclarations. */
1324 check_redeclaration_no_default_args (tree decl
)
1326 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1328 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1329 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1330 if (TREE_PURPOSE (t
))
1332 permerror (DECL_SOURCE_LOCATION (decl
),
1333 "redeclaration of %q#D may not have default "
1339 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1340 && lookup_attribute ("gnu_inline", \
1341 DECL_ATTRIBUTES (fn)))
1343 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1344 If the redeclaration is invalid, a diagnostic is issued, and the
1345 error_mark_node is returned. Otherwise, OLDDECL is returned.
1347 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1350 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1353 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1355 unsigned olddecl_uid
= DECL_UID (olddecl
);
1356 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1357 int new_defines_function
= 0;
1358 tree new_template_info
;
1360 if (newdecl
== olddecl
)
1363 types_match
= decls_match (newdecl
, olddecl
);
1365 /* If either the type of the new decl or the type of the old decl is an
1366 error_mark_node, then that implies that we have already issued an
1367 error (earlier) for some bogus type specification, and in that case,
1368 it is rather pointless to harass the user with yet more error message
1369 about the same declaration, so just pretend the types match here. */
1370 if (TREE_TYPE (newdecl
) == error_mark_node
1371 || TREE_TYPE (olddecl
) == error_mark_node
)
1372 return error_mark_node
;
1374 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1375 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1377 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1378 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1379 && check_raw_literal_operator (olddecl
))
1380 error ("literal operator template %q+D conflicts with"
1381 " raw literal operator %qD", newdecl
, olddecl
);
1382 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1383 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1384 && check_raw_literal_operator (newdecl
))
1385 error ("raw literal operator %q+D conflicts with"
1386 " literal operator template %qD", newdecl
, olddecl
);
1389 if (DECL_P (olddecl
)
1390 && TREE_CODE (newdecl
) == FUNCTION_DECL
1391 && TREE_CODE (olddecl
) == FUNCTION_DECL
1392 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1394 if (DECL_DECLARED_INLINE_P (newdecl
)
1395 && DECL_UNINLINABLE (newdecl
)
1396 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1397 /* Already warned elsewhere. */;
1398 else if (DECL_DECLARED_INLINE_P (olddecl
)
1399 && DECL_UNINLINABLE (olddecl
)
1400 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1401 /* Already warned. */;
1402 else if (DECL_DECLARED_INLINE_P (newdecl
)
1403 && DECL_UNINLINABLE (olddecl
)
1404 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1406 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1407 OPT_Wattributes
, "function %qD redeclared as inline",
1409 inform (DECL_SOURCE_LOCATION (olddecl
),
1410 "previous declaration of %qD with attribute noinline",
1413 else if (DECL_DECLARED_INLINE_P (olddecl
)
1414 && DECL_UNINLINABLE (newdecl
)
1415 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1417 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1418 OPT_Wattributes
, "function %qD redeclared with "
1419 "attribute noinline", newdecl
))
1420 inform (DECL_SOURCE_LOCATION (olddecl
),
1421 "previous declaration of %qD was inline",
1426 /* Check for redeclaration and other discrepancies. */
1427 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1428 && DECL_ARTIFICIAL (olddecl
))
1430 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1431 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1433 /* Avoid warnings redeclaring built-ins which have not been
1434 explicitly declared. */
1435 if (DECL_ANTICIPATED (olddecl
))
1438 /* If you declare a built-in or predefined function name as static,
1439 the old definition is overridden, but optionally warn this was a
1440 bad choice of name. */
1441 if (! TREE_PUBLIC (newdecl
))
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
);
1447 /* Discard the old built-in function. */
1450 /* If the built-in is not ansi, then programs can override
1451 it even globally without an error. */
1452 else if (! DECL_BUILT_IN (olddecl
))
1453 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1454 "library function %q#D redeclared as non-function %q#D",
1457 error ("declaration of %q+#D conflicts with built-in "
1458 "declaration %q#D", newdecl
, olddecl
);
1461 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1463 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1464 error_at (DECL_SOURCE_LOCATION (newdecl
),
1465 "redeclaration of %<pragma omp declare reduction%>");
1466 inform (DECL_SOURCE_LOCATION (olddecl
),
1467 "previous %<pragma omp declare reduction%> declaration");
1468 return error_mark_node
;
1470 else if (!types_match
)
1472 /* Avoid warnings redeclaring built-ins which have not been
1473 explicitly declared. */
1474 if (DECL_ANTICIPATED (olddecl
))
1476 /* Deal with fileptr_type_node. FILE type is not known
1477 at the time we create the builtins. */
1480 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1481 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1483 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1486 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1488 tree t
= TREE_VALUE (t1
);
1491 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1492 == get_identifier ("FILE")
1493 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1495 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1497 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1498 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1499 types_match
= decls_match (newdecl
, olddecl
);
1501 return duplicate_decls (newdecl
, olddecl
,
1503 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1506 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1509 else if ((DECL_EXTERN_C_P (newdecl
)
1510 && DECL_EXTERN_C_P (olddecl
))
1511 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1512 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1514 /* A near match; override the builtin. */
1516 if (TREE_PUBLIC (newdecl
))
1517 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1518 "new declaration %q#D ambiguates built-in "
1519 "declaration %q#D", newdecl
, olddecl
);
1521 warning (OPT_Wshadow
,
1522 DECL_BUILT_IN (olddecl
)
1523 ? G_("shadowing built-in function %q#D")
1524 : G_("shadowing library function %q#D"), olddecl
);
1527 /* Discard the old built-in function. */
1530 /* Replace the old RTL to avoid problems with inlining. */
1531 COPY_DECL_RTL (newdecl
, olddecl
);
1533 /* Even if the types match, prefer the new declarations type for
1534 built-ins which have not been explicitly declared, for
1535 exception lists, etc... */
1536 else if (DECL_IS_BUILTIN (olddecl
))
1538 tree type
= TREE_TYPE (newdecl
);
1539 tree attribs
= (*targetm
.merge_type_attributes
)
1540 (TREE_TYPE (olddecl
), type
);
1542 type
= cp_build_type_attribute_variant (type
, attribs
);
1543 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1546 /* If a function is explicitly declared "throw ()", propagate that to
1547 the corresponding builtin. */
1548 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1549 && DECL_ANTICIPATED (olddecl
)
1550 && TREE_NOTHROW (newdecl
)
1551 && !TREE_NOTHROW (olddecl
))
1553 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1554 tree tmpdecl
= builtin_decl_explicit (fncode
);
1555 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1556 TREE_NOTHROW (tmpdecl
) = 1;
1559 /* Whether or not the builtin can throw exceptions has no
1560 bearing on this declarator. */
1561 TREE_NOTHROW (olddecl
) = 0;
1563 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1565 /* If a builtin function is redeclared as `static', merge
1566 the declarations, but make the original one static. */
1567 DECL_THIS_STATIC (olddecl
) = 1;
1568 TREE_PUBLIC (olddecl
) = 0;
1570 /* Make the old declaration consistent with the new one so
1571 that all remnants of the builtin-ness of this function
1572 will be banished. */
1573 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1574 COPY_DECL_RTL (newdecl
, olddecl
);
1577 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1579 /* C++ Standard, 3.3, clause 4:
1580 "[Note: a namespace name or a class template name must be unique
1581 in its declarative region (7.3.2, clause 14). ]" */
1582 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1583 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1584 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1585 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1586 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1587 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1589 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1590 && TREE_CODE (newdecl
) != TYPE_DECL
)
1591 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1592 && TREE_CODE (olddecl
) != TYPE_DECL
))
1594 /* We do nothing special here, because C++ does such nasty
1595 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1596 get shadowed, and know that if we need to find a TYPE_DECL
1597 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1598 slot of the identifier. */
1602 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1603 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1604 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1605 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1609 error ("%q#D redeclared as different kind of symbol", newdecl
);
1610 if (TREE_CODE (olddecl
) == TREE_LIST
)
1611 olddecl
= TREE_VALUE (olddecl
);
1612 inform (DECL_SOURCE_LOCATION (olddecl
),
1613 "previous declaration %q#D", olddecl
);
1615 return error_mark_node
;
1617 else if (!types_match
)
1619 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1620 /* These are certainly not duplicate declarations; they're
1621 from different scopes. */
1624 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1626 /* The name of a class template may not be declared to refer to
1627 any other template, class, function, object, namespace, value,
1628 or type in the same scope. */
1629 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1630 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1632 error ("conflicting declaration of template %q+#D", newdecl
);
1633 inform (DECL_SOURCE_LOCATION (olddecl
),
1634 "previous declaration %q#D", olddecl
);
1635 return error_mark_node
;
1637 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1638 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1639 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1640 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1641 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1642 DECL_TEMPLATE_PARMS (olddecl
))
1643 /* Template functions can be disambiguated by
1645 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1646 TREE_TYPE (TREE_TYPE (olddecl
)))
1647 // Template functions can also be disambiguated by
1649 && equivalently_constrained (olddecl
, newdecl
))
1651 error ("ambiguating new declaration %q+#D", newdecl
);
1652 inform (DECL_SOURCE_LOCATION (olddecl
),
1653 "old declaration %q#D", olddecl
);
1655 else if (check_concept_refinement (olddecl
, newdecl
))
1656 return error_mark_node
;
1659 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1661 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1663 error ("conflicting declaration of C function %q+#D",
1665 inform (DECL_SOURCE_LOCATION (olddecl
),
1666 "previous declaration %q#D", olddecl
);
1669 /* For function versions, params and types match, but they
1670 are not ambiguous. */
1671 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1672 && !DECL_FUNCTION_VERSIONED (olddecl
))
1673 // The functions have the same parameter types.
1674 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1675 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))
1676 // And the same constraints.
1677 && equivalently_constrained (newdecl
, olddecl
))
1679 error ("ambiguating new declaration of %q+#D", newdecl
);
1680 inform (DECL_SOURCE_LOCATION (olddecl
),
1681 "old declaration %q#D", olddecl
);
1682 return error_mark_node
;
1689 error ("conflicting declaration %q+#D", newdecl
);
1690 inform (DECL_SOURCE_LOCATION (olddecl
),
1691 "previous declaration as %q#D", olddecl
);
1692 return error_mark_node
;
1695 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1696 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1697 && (!DECL_TEMPLATE_INFO (newdecl
)
1698 || (DECL_TI_TEMPLATE (newdecl
)
1699 != DECL_TI_TEMPLATE (olddecl
))))
1700 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1701 && (!DECL_TEMPLATE_INFO (olddecl
)
1702 || (DECL_TI_TEMPLATE (olddecl
)
1703 != DECL_TI_TEMPLATE (newdecl
))))))
1704 /* It's OK to have a template specialization and a non-template
1705 with the same type, or to have specializations of two
1706 different templates with the same type. Note that if one is a
1707 specialization, and the other is an instantiation of the same
1708 template, that we do not exit at this point. That situation
1709 can occur if we instantiate a template class, and then
1710 specialize one of its methods. This situation is valid, but
1711 the declarations must be merged in the usual way. */
1713 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1714 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1715 && !DECL_USE_TEMPLATE (newdecl
))
1716 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1717 && !DECL_USE_TEMPLATE (olddecl
))))
1718 /* One of the declarations is a template instantiation, and the
1719 other is not a template at all. That's OK. */
1721 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1723 /* In [namespace.alias] we have:
1725 In a declarative region, a namespace-alias-definition can be
1726 used to redefine a namespace-alias declared in that declarative
1727 region to refer only to the namespace to which it already
1730 Therefore, if we encounter a second alias directive for the same
1731 alias, we can just ignore the second directive. */
1732 if (DECL_NAMESPACE_ALIAS (newdecl
)
1733 && (DECL_NAMESPACE_ALIAS (newdecl
)
1734 == DECL_NAMESPACE_ALIAS (olddecl
)))
1736 /* [namespace.alias]
1738 A namespace-name or namespace-alias shall not be declared as
1739 the name of any other entity in the same declarative region.
1740 A namespace-name defined at global scope shall not be
1741 declared as the name of any other entity in any global scope
1743 error ("conflicting declaration of namespace %q+D", newdecl
);
1744 inform (DECL_SOURCE_LOCATION (olddecl
),
1745 "previous declaration of namespace %qD here", olddecl
);
1746 return error_mark_node
;
1750 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1753 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1754 if (DECL_NAME (olddecl
) != NULL_TREE
)
1755 inform (DECL_SOURCE_LOCATION (olddecl
),
1756 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1757 ? G_("%q#D previously defined here")
1758 : G_("%q#D previously declared here"), olddecl
);
1759 return error_mark_node
;
1761 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1762 && DECL_INITIAL (olddecl
) != NULL_TREE
1763 && !prototype_p (TREE_TYPE (olddecl
))
1764 && prototype_p (TREE_TYPE (newdecl
)))
1766 /* Prototype decl follows defn w/o prototype. */
1767 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1768 "prototype specified for %q#D", newdecl
))
1769 inform (DECL_SOURCE_LOCATION (olddecl
),
1770 "previous non-prototype definition here");
1772 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1773 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1776 If two declarations of the same function or object
1777 specify different linkage-specifications ..., the program
1778 is ill-formed.... Except for functions with C++ linkage,
1779 a function declaration without a linkage specification
1780 shall not precede the first linkage specification for
1781 that function. A function can be declared without a
1782 linkage specification after an explicit linkage
1783 specification has been seen; the linkage explicitly
1784 specified in the earlier declaration is not affected by
1785 such a function declaration.
1787 DR 563 raises the question why the restrictions on
1788 functions should not also apply to objects. Older
1789 versions of G++ silently ignore the linkage-specification
1797 which is clearly wrong. Therefore, we now treat objects
1799 if (current_lang_depth () == 0)
1801 /* There is no explicit linkage-specification, so we use
1802 the linkage from the previous declaration. */
1803 if (!DECL_LANG_SPECIFIC (newdecl
))
1804 retrofit_lang_decl (newdecl
);
1805 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1809 error ("conflicting declaration of %q+#D with %qL linkage",
1810 newdecl
, DECL_LANGUAGE (newdecl
));
1811 inform (DECL_SOURCE_LOCATION (olddecl
),
1812 "previous declaration with %qL linkage",
1813 DECL_LANGUAGE (olddecl
));
1817 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1819 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1821 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1822 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1823 && (/* grokfndecl passes member function templates too
1824 as FUNCTION_DECLs. */
1825 DECL_TEMPLATE_INFO (olddecl
)
1827 Default arguments for a member function of a class
1828 template shall be specified on the initial declaration
1829 of the member function within the class template. */
1830 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1831 check_redeclaration_no_default_args (newdecl
);
1834 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1835 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1838 for (; t1
&& t1
!= void_list_node
;
1839 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1840 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1842 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1845 if (permerror (input_location
,
1846 "default argument given for parameter "
1847 "%d of %q#D", i
, newdecl
))
1848 inform (DECL_SOURCE_LOCATION (olddecl
),
1849 "previous specification in %q#D here",
1854 error ("default argument given for parameter %d "
1855 "of %q#D", i
, newdecl
);
1856 inform (DECL_SOURCE_LOCATION (olddecl
),
1857 "previous specification in %q#D here",
1865 /* Do not merge an implicit typedef with an explicit one. In:
1869 typedef class A A __attribute__ ((foo));
1871 the attribute should apply only to the typedef. */
1872 if (TREE_CODE (olddecl
) == TYPE_DECL
1873 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1874 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1877 /* If new decl is `static' and an `extern' was seen previously,
1879 warn_extern_redeclared_static (newdecl
, olddecl
);
1881 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1882 return error_mark_node
;
1884 /* We have committed to returning 1 at this point. */
1885 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1887 /* Now that functions must hold information normally held
1888 by field decls, there is extra work to do so that
1889 declaration information does not get destroyed during
1891 if (DECL_VINDEX (olddecl
))
1892 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1893 if (DECL_CONTEXT (olddecl
))
1894 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1895 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1896 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1897 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1898 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1899 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1900 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1901 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1902 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1903 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1904 SET_OVERLOADED_OPERATOR_CODE
1905 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1906 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1908 /* Optionally warn about more than one declaration for the same
1909 name, but don't warn about a function declaration followed by a
1911 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1912 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1913 /* Don't warn about extern decl followed by definition. */
1914 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1915 /* Don't warn about friends, let add_friend take care of it. */
1916 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1917 /* Don't warn about declaration followed by specialization. */
1918 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1919 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1921 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1922 OPT_Wredundant_decls
,
1923 "redundant redeclaration of %qD in same scope",
1925 inform (DECL_SOURCE_LOCATION (olddecl
),
1926 "previous declaration of %qD", olddecl
);
1929 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1930 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1932 if (DECL_DELETED_FN (newdecl
))
1934 error ("deleted definition of %q+D", newdecl
);
1935 inform (DECL_SOURCE_LOCATION (olddecl
),
1936 "previous declaration of %qD", olddecl
);
1938 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1942 /* Deal with C++: must preserve virtual function table size. */
1943 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1945 tree newtype
= TREE_TYPE (newdecl
);
1946 tree oldtype
= TREE_TYPE (olddecl
);
1948 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1949 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1950 CLASSTYPE_FRIEND_CLASSES (newtype
)
1951 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1953 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1956 /* Copy all the DECL_... slots specified in the new decl
1957 except for any that we copy here from the old type. */
1958 DECL_ATTRIBUTES (newdecl
)
1959 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1961 if (DECL_DECLARES_FUNCTION_P (olddecl
) && DECL_DECLARES_FUNCTION_P (newdecl
))
1963 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1964 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1965 && DECL_HIDDEN_FRIEND_P (olddecl
)
1966 && newdecl_is_friend
);
1969 DECL_ANTICIPATED (olddecl
) = 0;
1970 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
1974 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1978 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1979 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1980 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1981 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1982 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1983 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1985 DECL_ATTRIBUTES (old_result
)
1986 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1988 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1990 /* Per C++11 8.3.6/4, default arguments cannot be added in later
1991 declarations of a function template. */
1992 if (DECL_SOURCE_LOCATION (newdecl
)
1993 != DECL_SOURCE_LOCATION (olddecl
))
1994 check_redeclaration_no_default_args (newdecl
);
1996 check_default_args (newdecl
);
1998 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1999 && DECL_INITIAL (new_result
))
2001 if (DECL_INITIAL (old_result
))
2002 DECL_UNINLINABLE (old_result
) = 1;
2004 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
2005 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
2006 DECL_NOT_REALLY_EXTERN (old_result
)
2007 = DECL_NOT_REALLY_EXTERN (new_result
);
2008 DECL_INTERFACE_KNOWN (old_result
)
2009 = DECL_INTERFACE_KNOWN (new_result
);
2010 DECL_DECLARED_INLINE_P (old_result
)
2011 = DECL_DECLARED_INLINE_P (new_result
);
2012 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2013 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2018 DECL_DECLARED_INLINE_P (old_result
)
2019 |= DECL_DECLARED_INLINE_P (new_result
);
2020 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2021 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2022 check_redeclaration_exception_specification (newdecl
, olddecl
);
2026 /* If the new declaration is a definition, update the file and
2027 line information on the declaration, and also make
2028 the old declaration the same definition. */
2029 if (DECL_INITIAL (new_result
) != NULL_TREE
)
2031 DECL_SOURCE_LOCATION (olddecl
)
2032 = DECL_SOURCE_LOCATION (old_result
)
2033 = DECL_SOURCE_LOCATION (newdecl
);
2034 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
2035 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2038 DECL_ARGUMENTS (old_result
)
2039 = DECL_ARGUMENTS (new_result
);
2040 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
2041 parm
= DECL_CHAIN (parm
))
2042 DECL_CONTEXT (parm
) = old_result
;
2051 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2052 check_redeclaration_exception_specification (newdecl
, olddecl
);
2054 /* Automatically handles default parameters. */
2055 tree oldtype
= TREE_TYPE (olddecl
);
2058 /* For typedefs use the old type, as the new type's DECL_NAME points
2059 at newdecl, which will be ggc_freed. */
2060 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2062 /* But NEWTYPE might have an attribute, honor that. */
2063 tree tem
= TREE_TYPE (newdecl
);
2066 if (TYPE_USER_ALIGN (tem
))
2068 if (TYPE_ALIGN (tem
) > TYPE_ALIGN (newtype
))
2069 TYPE_ALIGN (newtype
) = TYPE_ALIGN (tem
);
2070 TYPE_USER_ALIGN (newtype
) = true;
2073 /* And remove the new type from the variants list. */
2074 if (TYPE_NAME (TREE_TYPE (newdecl
)) == newdecl
)
2076 tree remove
= TREE_TYPE (newdecl
);
2077 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2078 t
= TYPE_NEXT_VARIANT (t
))
2079 if (TYPE_NEXT_VARIANT (t
) == remove
)
2081 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2087 /* Merge the data types specified in the two decls. */
2088 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2090 if (VAR_P (newdecl
))
2092 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2093 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2094 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2095 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2096 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2097 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2099 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2100 if (DECL_LANG_SPECIFIC (olddecl
)
2101 && CP_DECL_THREADPRIVATE_P (olddecl
))
2103 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2104 if (!DECL_LANG_SPECIFIC (newdecl
))
2105 retrofit_lang_decl (newdecl
);
2107 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2111 /* An explicit specialization of a function template or of a member
2112 function of a class template can be declared transaction_safe
2113 independently of whether the corresponding template entity is declared
2114 transaction_safe. */
2115 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2116 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2117 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2118 && tx_safe_fn_type_p (newtype
)
2119 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2120 newtype
= tx_unsafe_fn_variant (newtype
);
2122 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2124 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2125 check_default_args (newdecl
);
2127 /* Lay the type out, unless already done. */
2128 if (! same_type_p (newtype
, oldtype
)
2129 && TREE_TYPE (newdecl
) != error_mark_node
2130 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2131 layout_type (TREE_TYPE (newdecl
));
2133 if ((VAR_P (newdecl
)
2134 || TREE_CODE (newdecl
) == PARM_DECL
2135 || TREE_CODE (newdecl
) == RESULT_DECL
2136 || TREE_CODE (newdecl
) == FIELD_DECL
2137 || TREE_CODE (newdecl
) == TYPE_DECL
)
2138 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2139 layout_decl (newdecl
, 0);
2141 /* Merge the type qualifiers. */
2142 if (TREE_READONLY (newdecl
))
2143 TREE_READONLY (olddecl
) = 1;
2144 if (TREE_THIS_VOLATILE (newdecl
))
2145 TREE_THIS_VOLATILE (olddecl
) = 1;
2146 if (TREE_NOTHROW (newdecl
))
2147 TREE_NOTHROW (olddecl
) = 1;
2149 /* Merge deprecatedness. */
2150 if (TREE_DEPRECATED (newdecl
))
2151 TREE_DEPRECATED (olddecl
) = 1;
2153 /* Preserve function specific target and optimization options */
2154 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2156 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2157 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2158 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2159 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2161 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2162 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2163 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2164 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2167 /* Merge the initialization information. */
2168 if (DECL_INITIAL (newdecl
) == NULL_TREE
2169 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2171 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2172 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2173 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2175 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2176 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2180 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2182 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2183 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2184 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2185 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2186 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2187 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2188 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2189 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2190 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2191 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2192 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2193 /* Keep the old RTL. */
2194 COPY_DECL_RTL (olddecl
, newdecl
);
2196 else if (VAR_P (newdecl
)
2197 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2199 /* Keep the old RTL. We cannot keep the old RTL if the old
2200 declaration was for an incomplete object and the new
2201 declaration is not since many attributes of the RTL will
2203 COPY_DECL_RTL (olddecl
, newdecl
);
2206 /* If cannot merge, then use the new type and qualifiers,
2207 and don't preserve the old rtl. */
2210 /* Clean out any memory we had of the old declaration. */
2211 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2213 TREE_VALUE (oldstatic
) = error_mark_node
;
2215 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2216 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2217 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2218 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2221 /* Merge the storage class information. */
2222 merge_weak (newdecl
, olddecl
);
2224 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2225 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2226 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2227 if (! DECL_EXTERNAL (olddecl
))
2228 DECL_EXTERNAL (newdecl
) = 0;
2229 if (! DECL_COMDAT (olddecl
))
2230 DECL_COMDAT (newdecl
) = 0;
2232 new_template_info
= NULL_TREE
;
2233 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2235 bool new_redefines_gnu_inline
= false;
2237 if (new_defines_function
2238 && ((DECL_INTERFACE_KNOWN (olddecl
)
2239 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2240 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2241 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2242 == FUNCTION_DECL
))))
2246 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2247 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2249 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2252 if (!new_redefines_gnu_inline
)
2254 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2255 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2256 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2258 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2259 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2260 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2262 /* If the OLDDECL is an instantiation and/or specialization,
2263 then the NEWDECL must be too. But, it may not yet be marked
2264 as such if the caller has created NEWDECL, but has not yet
2265 figured out that it is a redeclaration. */
2266 if (!DECL_USE_TEMPLATE (newdecl
))
2267 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2269 /* Don't really know how much of the language-specific
2270 values we should copy from old to new. */
2271 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2272 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2273 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2274 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2276 if (LANG_DECL_HAS_MIN (newdecl
))
2278 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2279 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2280 if (DECL_TEMPLATE_INFO (newdecl
))
2282 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2283 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2284 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2285 /* Remember the presence of explicit specialization args. */
2286 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2287 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2289 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2291 /* Only functions have these fields. */
2292 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2294 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2295 DECL_BEFRIENDING_CLASSES (newdecl
)
2296 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2297 DECL_BEFRIENDING_CLASSES (olddecl
));
2298 /* DECL_THUNKS is only valid for virtual functions,
2299 otherwise it is a DECL_FRIEND_CONTEXT. */
2300 if (DECL_VIRTUAL_P (newdecl
))
2301 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2303 /* Only variables have this field. */
2304 else if (VAR_P (newdecl
)
2305 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2306 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2309 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2313 /* Merge parameter attributes. */
2314 tree oldarg
, newarg
;
2315 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2316 newarg
= DECL_ARGUMENTS(newdecl
);
2318 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2319 DECL_ATTRIBUTES (newarg
)
2320 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2321 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2324 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2325 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2327 /* If newdecl is not a specialization, then it is not a
2328 template-related function at all. And that means that we
2329 should have exited above, returning 0. */
2330 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2332 if (DECL_ODR_USED (olddecl
))
2333 /* From [temp.expl.spec]:
2335 If a template, a member template or the member of a class
2336 template is explicitly specialized then that
2337 specialization shall be declared before the first use of
2338 that specialization that would cause an implicit
2339 instantiation to take place, in every translation unit in
2340 which such a use occurs. */
2341 error ("explicit specialization of %qD after first use",
2344 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2345 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2346 && DECL_DECLARED_INLINE_P (newdecl
));
2348 /* Don't propagate visibility from the template to the
2349 specialization here. We'll do that in determine_visibility if
2351 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2353 /* [temp.expl.spec/14] We don't inline explicit specialization
2354 just because the primary template says so. */
2356 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2357 the always_inline attribute. */
2358 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2359 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2361 if (DECL_DECLARED_INLINE_P (newdecl
))
2362 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2364 DECL_ATTRIBUTES (newdecl
)
2365 = remove_attribute ("always_inline",
2366 DECL_ATTRIBUTES (newdecl
));
2369 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2371 /* Never inline re-defined extern inline functions.
2372 FIXME: this could be better handled by keeping both
2373 function as separate declarations. */
2374 DECL_UNINLINABLE (newdecl
) = 1;
2378 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2379 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2381 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2383 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2384 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2386 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2387 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2388 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2389 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2392 /* Preserve abstractness on cloned [cd]tors. */
2393 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2395 /* Update newdecl's parms to point at olddecl. */
2396 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2397 parm
= DECL_CHAIN (parm
))
2398 DECL_CONTEXT (parm
) = olddecl
;
2402 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2403 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2404 COPY_DECL_RTL (newdecl
, olddecl
);
2406 if (! types_match
|| new_defines_function
)
2408 /* These need to be copied so that the names are available.
2409 Note that if the types do match, we'll preserve inline
2410 info and other bits, but if not, we won't. */
2411 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2412 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2414 /* If redeclaring a builtin function, it stays built in
2415 if newdecl is a gnu_inline definition, or if newdecl is just
2417 if (DECL_BUILT_IN (olddecl
)
2418 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2420 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2421 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2422 /* If we're keeping the built-in definition, keep the rtl,
2423 regardless of declaration matches. */
2424 COPY_DECL_RTL (olddecl
, newdecl
);
2425 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2427 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2430 /* If a compatible prototype of these builtin functions
2431 is seen, assume the runtime implements it with the
2432 expected semantics. */
2433 case BUILT_IN_STPCPY
:
2434 if (builtin_decl_explicit_p (fncode
))
2435 set_builtin_decl_implicit_p (fncode
, true);
2438 if (builtin_decl_explicit_p (fncode
))
2439 set_builtin_decl_declared_p (fncode
, true);
2444 if (new_defines_function
)
2445 /* If defining a function declared with other language
2446 linkage, use the previously declared language linkage. */
2447 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2448 else if (types_match
)
2450 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2451 /* Don't clear out the arguments if we're just redeclaring a
2453 if (DECL_ARGUMENTS (olddecl
))
2454 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2457 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2458 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2460 /* Now preserve various other info from the definition. */
2461 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2462 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2463 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2464 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2466 /* Warn about conflicting visibility specifications. */
2467 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2468 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2469 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2471 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2472 "%qD: visibility attribute ignored because it "
2473 "conflicts with previous declaration", newdecl
))
2474 inform (DECL_SOURCE_LOCATION (olddecl
),
2475 "previous declaration of %qD", olddecl
);
2477 /* Choose the declaration which specified visibility. */
2478 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2480 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2481 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2483 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2484 so keep this behavior. */
2485 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2487 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2488 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2490 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2491 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2493 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2494 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2496 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2497 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2498 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2500 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2501 with that from NEWDECL below. */
2502 if (DECL_LANG_SPECIFIC (olddecl
))
2504 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2505 != DECL_LANG_SPECIFIC (newdecl
));
2506 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2509 /* Merge the USED information. */
2510 if (TREE_USED (olddecl
))
2511 TREE_USED (newdecl
) = 1;
2512 else if (TREE_USED (newdecl
))
2513 TREE_USED (olddecl
) = 1;
2514 if (VAR_P (newdecl
))
2516 if (DECL_READ_P (olddecl
))
2517 DECL_READ_P (newdecl
) = 1;
2518 else if (DECL_READ_P (newdecl
))
2519 DECL_READ_P (olddecl
) = 1;
2521 if (DECL_PRESERVE_P (olddecl
))
2522 DECL_PRESERVE_P (newdecl
) = 1;
2523 else if (DECL_PRESERVE_P (newdecl
))
2524 DECL_PRESERVE_P (olddecl
) = 1;
2526 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2527 to olddecl and deleted. */
2528 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2529 && DECL_FUNCTION_VERSIONED (olddecl
))
2531 /* Set the flag for newdecl so that it gets copied to olddecl. */
2532 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2533 /* newdecl will be purged after copying to olddecl and is no longer
2535 cgraph_node::delete_function_version (newdecl
);
2538 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2541 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2543 function_size
= sizeof (struct tree_decl_common
);
2545 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2546 (char *) newdecl
+ sizeof (struct tree_common
),
2547 function_size
- sizeof (struct tree_common
));
2549 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2550 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2551 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2553 /* Preserve symtab node mapping. */
2554 olddecl
->decl_with_vis
.symtab_node
= snode
;
2556 if (new_template_info
)
2557 /* If newdecl is a template instantiation, it is possible that
2558 the following sequence of events has occurred:
2560 o A friend function was declared in a class template. The
2561 class template was instantiated.
2563 o The instantiation of the friend declaration was
2564 recorded on the instantiation list, and is newdecl.
2566 o Later, however, instantiate_class_template called pushdecl
2567 on the newdecl to perform name injection. But, pushdecl in
2568 turn called duplicate_decls when it discovered that another
2569 declaration of a global function with the same name already
2572 o Here, in duplicate_decls, we decided to clobber newdecl.
2574 If we're going to do that, we'd better make sure that
2575 olddecl, and not newdecl, is on the list of
2576 instantiations so that if we try to do the instantiation
2577 again we won't get the clobbered declaration. */
2578 reregister_specialization (newdecl
,
2584 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2586 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2587 (char *) newdecl
+ sizeof (struct tree_common
),
2588 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2589 switch (TREE_CODE (newdecl
))
2599 struct symtab_node
*snode
= NULL
;
2602 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2603 || DECL_EXTERNAL (olddecl
)))
2604 snode
= symtab_node::get (olddecl
);
2605 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2606 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2607 size
- sizeof (struct tree_decl_common
)
2608 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2609 if (VAR_P (newdecl
))
2610 olddecl
->decl_with_vis
.symtab_node
= snode
;
2614 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2615 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2616 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2617 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2622 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2624 if (DECL_EXTERNAL (olddecl
)
2625 || TREE_PUBLIC (olddecl
)
2626 || TREE_STATIC (olddecl
))
2628 /* Merge the section attribute.
2629 We want to issue an error if the sections conflict but that must be
2630 done later in decl_attributes since we are called before attributes
2632 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2633 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2635 if (DECL_ONE_ONLY (newdecl
))
2637 struct symtab_node
*oldsym
, *newsym
;
2638 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2639 oldsym
= cgraph_node::get_create (olddecl
);
2641 oldsym
= varpool_node::get_create (olddecl
);
2642 newsym
= symtab_node::get (newdecl
);
2643 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2648 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2650 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2651 if (!processing_template_decl
)
2652 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2656 DECL_UID (olddecl
) = olddecl_uid
;
2658 DECL_FRIEND_P (olddecl
) = 1;
2661 DECL_ANTICIPATED (olddecl
) = 1;
2662 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2665 /* NEWDECL contains the merged attribute lists.
2666 Update OLDDECL to be the same. */
2667 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2669 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2670 so that encode_section_info has a chance to look at the new decl
2671 flags and attributes. */
2672 if (DECL_RTL_SET_P (olddecl
)
2673 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2675 && TREE_STATIC (olddecl
))))
2676 make_decl_rtl (olddecl
);
2678 /* The NEWDECL will no longer be needed. Because every out-of-class
2679 declaration of a member results in a call to duplicate_decls,
2680 freeing these nodes represents in a significant savings.
2682 Before releasing the node, be sore to remove function from symbol
2683 table that might have been inserted there to record comdat group.
2684 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2685 structure is shared in between newdecl and oldecl. */
2686 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2687 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2688 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2690 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2695 /* Remove the associated constraints for newdecl, if any, before
2696 reclaiming memory. */
2698 remove_constraints (newdecl
);
2705 /* Return zero if the declaration NEWDECL is valid
2706 when the declaration OLDDECL (assumed to be for the same name)
2707 has already been seen.
2708 Otherwise return an error message format string with a %s
2709 where the identifier should go. */
2712 redeclaration_error_message (tree newdecl
, tree olddecl
)
2714 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2716 /* Because C++ can put things into name space for free,
2717 constructs like "typedef struct foo { ... } foo"
2718 would look like an erroneous redeclaration. */
2719 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2722 return G_("redefinition of %q#D");
2724 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2726 /* If this is a pure function, its olddecl will actually be
2727 the original initialization to `0' (which we force to call
2728 abort()). Don't complain about redefinition in this case. */
2729 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2730 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2733 /* If both functions come from different namespaces, this is not
2734 a redeclaration - this is a conflict with a used function. */
2735 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2736 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2737 && ! decls_match (olddecl
, newdecl
))
2738 return G_("%qD conflicts with used function");
2740 /* We'll complain about linkage mismatches in
2741 warn_extern_redeclared_static. */
2743 /* Defining the same name twice is no good. */
2744 if (DECL_INITIAL (olddecl
) != NULL_TREE
2745 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2747 if (DECL_NAME (olddecl
) == NULL_TREE
)
2748 return G_("%q#D not declared in class");
2749 else if (!GNU_INLINE_P (olddecl
)
2750 || GNU_INLINE_P (newdecl
))
2751 return G_("redefinition of %q#D");
2754 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2756 bool olda
= GNU_INLINE_P (olddecl
);
2757 bool newa
= GNU_INLINE_P (newdecl
);
2762 return G_("%q+D redeclared inline with "
2763 "%<gnu_inline%> attribute");
2765 return G_("%q+D redeclared inline without "
2766 "%<gnu_inline%> attribute");
2770 check_abi_tag_redeclaration
2771 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2772 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2776 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2780 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2782 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2783 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2784 return G_("redefinition of %q#D");
2788 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2789 || (DECL_TEMPLATE_RESULT (newdecl
)
2790 == DECL_TEMPLATE_RESULT (olddecl
)))
2793 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2794 if (DECL_TEMPLATE_INFO (nt
))
2795 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2796 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2797 if (DECL_TEMPLATE_INFO (ot
))
2798 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2799 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2800 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2801 return G_("redefinition of %q#D");
2803 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2805 bool olda
= GNU_INLINE_P (ot
);
2806 bool newa
= GNU_INLINE_P (nt
);
2811 return G_("%q+D redeclared inline with "
2812 "%<gnu_inline%> attribute");
2814 return G_("%q+D redeclared inline without "
2815 "%<gnu_inline%> attribute");
2819 /* Core issue #226 (C++0x):
2821 If a friend function template declaration specifies a
2822 default template-argument, that declaration shall be a
2823 definition and shall be the only declaration of the
2824 function template in the translation unit. */
2825 if ((cxx_dialect
!= cxx98
)
2826 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2827 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2828 /*is_primary=*/true,
2829 /*is_partial=*/false,
2830 /*is_friend_decl=*/2))
2831 return G_("redeclaration of friend %q#D "
2832 "may not have default template arguments");
2836 else if (VAR_P (newdecl
)
2837 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2838 && (! DECL_LANG_SPECIFIC (olddecl
)
2839 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2840 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2842 /* Only variables can be thread-local, and all declarations must
2843 agree on this property. */
2844 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2845 return G_("thread-local declaration of %q#D follows "
2846 "non-thread-local declaration");
2848 return G_("non-thread-local declaration of %q#D follows "
2849 "thread-local declaration");
2851 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2853 /* The objects have been declared at namespace scope. If either
2854 is a member of an anonymous union, then this is an invalid
2855 redeclaration. For example:
2861 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2862 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2863 return G_("redeclaration of %q#D");
2864 /* If at least one declaration is a reference, there is no
2865 conflict. For example:
2871 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2873 /* Reject two definitions. */
2874 return G_("redefinition of %q#D");
2878 /* Objects declared with block scope: */
2879 /* Reject two definitions, and reject a definition
2880 together with an external reference. */
2881 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2882 return G_("redeclaration of %q#D");
2887 /* Hash and equality functions for the named_label table. */
2890 named_label_hasher::hash (named_label_entry
*ent
)
2892 return DECL_UID (ent
->label_decl
);
2896 named_label_hasher::equal (named_label_entry
*a
, named_label_entry
*b
)
2898 return a
->label_decl
== b
->label_decl
;
2901 /* Create a new label, named ID. */
2904 make_label_decl (tree id
, int local_p
)
2906 struct named_label_entry
*ent
;
2909 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2911 DECL_CONTEXT (decl
) = current_function_decl
;
2912 DECL_MODE (decl
) = VOIDmode
;
2913 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2915 /* Say where one reference is to the label, for the sake of the
2916 error if it is not defined. */
2917 DECL_SOURCE_LOCATION (decl
) = input_location
;
2919 /* Record the fact that this identifier is bound to this label. */
2920 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2922 /* Create the label htab for the function on demand. */
2924 named_labels
= hash_table
<named_label_hasher
>::create_ggc (13);
2926 /* Record this label on the list of labels used in this function.
2927 We do this before calling make_label_decl so that we get the
2928 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2929 ent
= ggc_cleared_alloc
<named_label_entry
> ();
2930 ent
->label_decl
= decl
;
2932 named_label_entry
**slot
= named_labels
->find_slot (ent
, INSERT
);
2933 gcc_assert (*slot
== NULL
);
2939 /* Look for a label named ID in the current function. If one cannot
2940 be found, create one. (We keep track of used, but undefined,
2941 labels, and complain about them at the end of a function.) */
2944 lookup_label_1 (tree id
)
2948 /* You can't use labels at global scope. */
2949 if (current_function_decl
== NULL_TREE
)
2951 error ("label %qE referenced outside of any function", id
);
2955 /* See if we've already got this label. */
2956 decl
= IDENTIFIER_LABEL_VALUE (id
);
2957 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2960 decl
= make_label_decl (id
, /*local_p=*/0);
2964 /* Wrapper for lookup_label_1. */
2967 lookup_label (tree id
)
2970 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2971 ret
= lookup_label_1 (id
);
2972 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2976 /* Declare a local label named ID. */
2979 declare_local_label (tree id
)
2982 cp_label_binding bind
;
2984 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2985 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2986 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2988 decl
= make_label_decl (id
, /*local_p=*/1);
2990 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2995 /* Returns nonzero if it is ill-formed to jump past the declaration of
2996 DECL. Returns 2 if it's also a real problem. */
2999 decl_jump_unsafe (tree decl
)
3001 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3002 with automatic storage duration is not in scope to a point where it is
3003 in scope is ill-formed unless the variable has scalar type, class type
3004 with a trivial default constructor and a trivial destructor, a
3005 cv-qualified version of one of these types, or an array of one of the
3006 preceding types and is declared without an initializer (8.5). */
3007 tree type
= TREE_TYPE (decl
);
3009 if (!VAR_P (decl
) || TREE_STATIC (decl
)
3010 || type
== error_mark_node
)
3013 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
3014 || variably_modified_type_p (type
, NULL_TREE
))
3017 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3023 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3027 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
3028 diagnostic_t diag_kind
)
3031 = (decl
? emit_diagnostic (diag_kind
, loc
, 0, "jump to label %qD", decl
)
3032 : emit_diagnostic (diag_kind
, loc
, 0, "jump to case label"));
3033 if (complained
&& locus
)
3034 inform (*locus
, " from here");
3038 /* Check that a single previously seen jump to a newly defined label
3039 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3040 the jump context; NAMES are the names in scope in LEVEL at the jump
3041 context; LOCUS is the source position of the jump or 0. Returns
3042 true if all is well. */
3045 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
3046 bool exited_omp
, const location_t
*locus
)
3048 cp_binding_level
*b
;
3049 bool complained
= false;
3051 bool saw_eh
= false, saw_omp
= false, saw_tm
= false;
3055 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3057 inform (input_location
, " exits OpenMP structured block");
3062 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3064 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3066 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3067 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3068 : TREE_CHAIN (new_decls
)))
3070 int problem
= decl_jump_unsafe (new_decls
);
3076 complained
= identify_goto (decl
, input_location
, locus
,
3083 inform (DECL_SOURCE_LOCATION (new_decls
),
3084 " crosses initialization of %q#D", new_decls
);
3086 inform (DECL_SOURCE_LOCATION (new_decls
),
3087 " enters scope of %q#D which has "
3088 "non-trivial destructor", new_decls
);
3094 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
3098 complained
= identify_goto (decl
, input_location
, locus
,
3104 if (b
->kind
== sk_try
)
3105 inform (input_location
, " enters try block");
3107 inform (input_location
, " enters catch block");
3111 if (b
->kind
== sk_omp
&& !saw_omp
)
3115 complained
= identify_goto (decl
, input_location
, locus
,
3120 inform (input_location
, " enters OpenMP structured block");
3123 if (b
->kind
== sk_transaction
&& !saw_tm
)
3127 complained
= identify_goto (decl
, input_location
, locus
,
3132 inform (input_location
,
3133 " enters synchronized or atomic statement");
3142 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3144 check_previous_goto_1 (decl
, use
->binding_level
,
3145 use
->names_in_scope
, use
->in_omp_scope
,
3146 &use
->o_goto_locus
);
3150 check_switch_goto (cp_binding_level
* level
)
3152 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3155 /* Check that a new jump to a label DECL is OK. Called by
3156 finish_goto_stmt. */
3159 check_goto (tree decl
)
3161 struct named_label_entry
*ent
, dummy
;
3162 bool saw_catch
= false, complained
= false;
3167 /* We can't know where a computed goto is jumping.
3168 So we assume that it's OK. */
3169 if (TREE_CODE (decl
) != LABEL_DECL
)
3172 /* We didn't record any information about this label when we created it,
3173 and there's not much point since it's trivial to analyze as a return. */
3174 if (decl
== cdtor_label
)
3177 dummy
.label_decl
= decl
;
3178 ent
= named_labels
->find (&dummy
);
3179 gcc_assert (ent
!= NULL
);
3181 /* If the label hasn't been defined yet, defer checking. */
3182 if (! DECL_INITIAL (decl
))
3184 struct named_label_use_entry
*new_use
;
3186 /* Don't bother creating another use if the last goto had the
3187 same data, and will therefore create the same set of errors. */
3189 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3192 new_use
= ggc_alloc
<named_label_use_entry
> ();
3193 new_use
->binding_level
= current_binding_level
;
3194 new_use
->names_in_scope
= current_binding_level
->names
;
3195 new_use
->o_goto_locus
= input_location
;
3196 new_use
->in_omp_scope
= false;
3198 new_use
->next
= ent
->uses
;
3199 ent
->uses
= new_use
;
3203 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3204 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3206 diagnostic_t diag_kind
= DK_PERMERROR
;
3207 if (ent
->in_try_scope
|| ent
->in_catch_scope
3208 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3209 diag_kind
= DK_ERROR
;
3210 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3211 &input_location
, diag_kind
);
3212 identified
= 1 + (diag_kind
== DK_ERROR
);
3215 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3217 int u
= decl_jump_unsafe (bad
);
3219 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3221 /* Can't skip init of __exception_info. */
3222 if (identified
== 1)
3224 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3225 &input_location
, DK_ERROR
);
3229 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3232 else if (complained
)
3235 inform (DECL_SOURCE_LOCATION (bad
),
3236 " skips initialization of %q#D", bad
);
3238 inform (DECL_SOURCE_LOCATION (bad
),
3239 " enters scope of %q#D which has "
3240 "non-trivial destructor", bad
);
3246 if (ent
->in_try_scope
)
3247 inform (input_location
, " enters try block");
3248 else if (ent
->in_catch_scope
&& !saw_catch
)
3249 inform (input_location
, " enters catch block");
3250 else if (ent
->in_transaction_scope
)
3251 inform (input_location
, " enters synchronized or atomic statement");
3254 if (ent
->in_omp_scope
)
3257 inform (input_location
, " enters OpenMP structured block");
3259 else if (flag_openmp
)
3261 cp_binding_level
*b
;
3262 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3264 if (b
== ent
->binding_level
)
3266 if (b
->kind
== sk_omp
)
3270 complained
= identify_goto (decl
,
3271 DECL_SOURCE_LOCATION (decl
),
3272 &input_location
, DK_ERROR
);
3276 inform (input_location
, " exits OpenMP structured block");
3283 /* Check that a return is ok wrt OpenMP structured blocks.
3284 Called by finish_return_stmt. Returns true if all is well. */
3287 check_omp_return (void)
3289 cp_binding_level
*b
;
3290 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3291 if (b
->kind
== sk_omp
)
3293 error ("invalid exit from OpenMP structured block");
3296 else if (b
->kind
== sk_function_parms
)
3301 /* Define a label, specifying the location in the source file.
3302 Return the LABEL_DECL node for the label. */
3305 define_label_1 (location_t location
, tree name
)
3307 struct named_label_entry
*ent
, dummy
;
3308 cp_binding_level
*p
;
3311 decl
= lookup_label (name
);
3313 dummy
.label_decl
= decl
;
3314 ent
= named_labels
->find (&dummy
);
3315 gcc_assert (ent
!= NULL
);
3317 /* After labels, make any new cleanups in the function go into their
3318 own new (temporary) binding contour. */
3319 for (p
= current_binding_level
;
3320 p
->kind
!= sk_function_parms
;
3322 p
->more_cleanups_ok
= 0;
3324 if (name
== get_identifier ("wchar_t"))
3325 permerror (input_location
, "label named wchar_t");
3327 if (DECL_INITIAL (decl
) != NULL_TREE
)
3329 error ("duplicate label %qD", decl
);
3330 return error_mark_node
;
3334 struct named_label_use_entry
*use
;
3336 /* Mark label as having been defined. */
3337 DECL_INITIAL (decl
) = error_mark_node
;
3338 /* Say where in the source. */
3339 DECL_SOURCE_LOCATION (decl
) = location
;
3341 ent
->binding_level
= current_binding_level
;
3342 ent
->names_in_scope
= current_binding_level
->names
;
3344 for (use
= ent
->uses
; use
; use
= use
->next
)
3345 check_previous_goto (decl
, use
);
3352 /* Wrapper for define_label_1. */
3355 define_label (location_t location
, tree name
)
3358 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3359 ret
= define_label_1 (location
, name
);
3360 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3367 cp_binding_level
*level
;
3368 struct cp_switch
*next
;
3369 /* The SWITCH_STMT being built. */
3371 /* A splay-tree mapping the low element of a case range to the high
3372 element, or NULL_TREE if there is no high element. Used to
3373 determine whether or not a new case label duplicates an old case
3374 label. We need a tree, rather than simply a hash table, because
3375 of the GNU case range extension. */
3377 /* Remember whether there was a case value that is outside the
3378 range of the original type of the controlling expression. */
3379 bool outside_range_p
;
3382 /* A stack of the currently active switch statements. The innermost
3383 switch statement is on the top of the stack. There is no need to
3384 mark the stack for garbage collection because it is only active
3385 during the processing of the body of a function, and we never
3386 collect at that point. */
3388 static struct cp_switch
*switch_stack
;
3390 /* Called right after a switch-statement condition is parsed.
3391 SWITCH_STMT is the switch statement being parsed. */
3394 push_switch (tree switch_stmt
)
3396 struct cp_switch
*p
= XNEW (struct cp_switch
);
3397 p
->level
= current_binding_level
;
3398 p
->next
= switch_stack
;
3399 p
->switch_stmt
= switch_stmt
;
3400 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3401 p
->outside_range_p
= false;
3408 struct cp_switch
*cs
= switch_stack
;
3409 location_t switch_location
;
3411 /* Emit warnings as needed. */
3412 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3413 const bool bool_cond_p
3414 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3415 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3416 if (!processing_template_decl
)
3417 c_do_switch_warnings (cs
->cases
, switch_location
,
3418 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3419 SWITCH_STMT_COND (cs
->switch_stmt
),
3420 bool_cond_p
, cs
->outside_range_p
);
3422 splay_tree_delete (cs
->cases
);
3423 switch_stack
= switch_stack
->next
;
3427 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3428 condition. Note that if TYPE and VALUE are already integral we don't
3429 really do the conversion because the language-independent
3430 warning/optimization code will work better that way. */
3433 case_conversion (tree type
, tree value
)
3435 if (value
== NULL_TREE
)
3438 if (cxx_dialect
>= cxx11
3439 && (SCOPED_ENUM_P (type
)
3440 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3442 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3443 type
= type_promotes_to (type
);
3444 value
= (perform_implicit_conversion_flags
3445 (type
, value
, tf_warning_or_error
,
3446 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3448 return cxx_constant_value (value
);
3451 /* Note that we've seen a definition of a case label, and complain if this
3452 is a bad place for one. */
3455 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3458 cp_binding_level
*p
;
3461 if (processing_template_decl
)
3465 /* For templates, just add the case label; we'll do semantic
3466 analysis at instantiation-time. */
3467 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3468 return add_stmt (build_case_label (low_value
, high_value
, label
));
3471 /* Find the condition on which this switch statement depends. */
3472 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3473 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3474 cond
= TREE_VALUE (cond
);
3476 if (!check_switch_goto (switch_stack
->level
))
3477 return error_mark_node
;
3479 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3481 low_value
= case_conversion (type
, low_value
);
3482 high_value
= case_conversion (type
, high_value
);
3484 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3485 low_value
, high_value
,
3486 &switch_stack
->outside_range_p
);
3488 /* After labels, make any new cleanups in the function go into their
3489 own new (temporary) binding contour. */
3490 for (p
= current_binding_level
;
3491 p
->kind
!= sk_function_parms
;
3493 p
->more_cleanups_ok
= 0;
3498 struct typename_info
{
3506 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3508 typedef typename_info
*compare_type
;
3510 /* Hash a TYPENAME_TYPE. */
3517 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3518 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3523 /* Compare two TYPENAME_TYPEs. */
3526 equal (tree t1
, const typename_info
*t2
)
3528 return (TYPE_IDENTIFIER (t1
) == t2
->name
3529 && TYPE_CONTEXT (t1
) == t2
->scope
3530 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3531 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3532 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3536 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3537 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3539 Returns the new TYPENAME_TYPE. */
3541 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3544 build_typename_type (tree context
, tree name
, tree fullname
,
3545 enum tag_types tag_type
)
3553 if (typename_htab
== NULL
)
3554 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3556 ti
.scope
= FROB_CONTEXT (context
);
3558 ti
.template_id
= fullname
;
3559 ti
.enum_p
= tag_type
== enum_type
;
3560 ti
.class_p
= (tag_type
== class_type
3561 || tag_type
== record_type
3562 || tag_type
== union_type
);
3563 hash
= (htab_hash_pointer (ti
.scope
)
3564 ^ htab_hash_pointer (ti
.name
));
3566 /* See if we already have this type. */
3567 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3572 /* Build the TYPENAME_TYPE. */
3573 t
= cxx_make_type (TYPENAME_TYPE
);
3574 TYPE_CONTEXT (t
) = ti
.scope
;
3575 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3576 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3577 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3579 /* Build the corresponding TYPE_DECL. */
3580 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3581 TYPE_NAME (TREE_TYPE (d
)) = d
;
3582 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3583 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3584 DECL_ARTIFICIAL (d
) = 1;
3586 /* Store it in the hash table. */
3589 /* TYPENAME_TYPEs must always be compared structurally, because
3590 they may or may not resolve down to another type depending on
3591 the currently open classes. */
3592 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3598 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3599 provided to name the type. Returns an appropriate type, unless an
3600 error occurs, in which case error_mark_node is returned. If we
3601 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3602 return that, rather than the _TYPE it corresponds to, in other
3603 cases we look through the type decl. If TF_ERROR is set, complain
3604 about errors, otherwise be quiet. */
3607 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3608 tsubst_flags_t complain
)
3614 if (name
== error_mark_node
3615 || context
== NULL_TREE
3616 || context
== error_mark_node
)
3617 return error_mark_node
;
3621 if (!(TYPE_LANG_SPECIFIC (name
)
3622 && (CLASSTYPE_IS_TEMPLATE (name
)
3623 || CLASSTYPE_USE_TEMPLATE (name
))))
3624 name
= TYPE_IDENTIFIER (name
);
3626 /* Create a TEMPLATE_ID_EXPR for the type. */
3627 name
= build_nt (TEMPLATE_ID_EXPR
,
3628 CLASSTYPE_TI_TEMPLATE (name
),
3629 CLASSTYPE_TI_ARGS (name
));
3631 else if (TREE_CODE (name
) == TYPE_DECL
)
3632 name
= DECL_NAME (name
);
3636 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3638 name
= TREE_OPERAND (name
, 0);
3639 if (DECL_TYPE_TEMPLATE_P (name
))
3640 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3641 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3643 if (complain
& tf_error
)
3644 error ("%qD is not a type", name
);
3645 return error_mark_node
;
3648 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3650 if (complain
& tf_error
)
3651 error ("%qD used without template parameters", name
);
3652 return error_mark_node
;
3654 gcc_assert (identifier_p (name
));
3655 gcc_assert (TYPE_P (context
));
3657 if (!MAYBE_CLASS_TYPE_P (context
))
3659 if (complain
& tf_error
)
3660 error ("%q#T is not a class", context
);
3661 return error_mark_node
;
3664 /* When the CONTEXT is a dependent type, NAME could refer to a
3665 dependent base class of CONTEXT. But look inside it anyway
3666 if CONTEXT is a currently open scope, in case it refers to a
3667 member of the current instantiation or a non-dependent base;
3668 lookup will stop when we hit a dependent base. */
3669 if (!dependent_scope_p (context
))
3670 /* We should only set WANT_TYPE when we're a nested typename type.
3671 Then we can give better diagnostics if we find a non-type. */
3672 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3676 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3677 return build_typename_type (context
, name
, fullname
, tag_type
);
3679 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3683 if (complain
& tf_error
)
3684 error (want_template
? G_("no class template named %q#T in %q#T")
3685 : G_("no type named %q#T in %q#T"), name
, context
);
3686 return error_mark_node
;
3689 /* Pull out the template from an injected-class-name (or multiple). */
3691 t
= maybe_get_template_decl_from_type_decl (t
);
3693 if (TREE_CODE (t
) == TREE_LIST
)
3695 if (complain
& tf_error
)
3697 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3698 print_candidates (t
);
3700 return error_mark_node
;
3703 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3705 if (complain
& tf_error
)
3706 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3708 return error_mark_node
;
3710 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3712 if (complain
& tf_error
)
3713 error ("%<typename %T::%D%> names %q#T, which is not a type",
3715 return error_mark_node
;
3718 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3719 return error_mark_node
;
3721 /* If we are currently parsing a template and if T is a typedef accessed
3722 through CONTEXT then we need to remember and check access of T at
3723 template instantiation time. */
3724 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3727 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3729 /*entering_scope=*/0,
3730 complain
| tf_user
);
3732 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3735 maybe_record_typedef_use (t
);
3740 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3741 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3742 in which case error_mark_node is returned.
3744 If PARM_LIST is non-NULL, also make sure that the template parameter
3745 list of TEMPLATE_DECL matches.
3747 If COMPLAIN zero, don't complain about any errors that occur. */
3750 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3751 tsubst_flags_t complain
)
3757 name
= TYPE_IDENTIFIER (name
);
3758 else if (DECL_P (name
))
3759 name
= DECL_NAME (name
);
3760 gcc_assert (identifier_p (name
));
3762 if (!dependent_type_p (context
)
3763 || currently_open_class (context
))
3765 tree tmpl
= NULL_TREE
;
3767 if (MAYBE_CLASS_TYPE_P (context
))
3768 tmpl
= lookup_field (context
, name
, 0, false);
3770 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3771 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3773 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3775 if (complain
& tf_error
)
3776 error ("no class template named %q#T in %q#T", name
, context
);
3777 return error_mark_node
;
3781 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3783 if (complain
& tf_error
)
3785 error ("template parameters do not match template %qD", tmpl
);
3786 inform (DECL_SOURCE_LOCATION (tmpl
),
3787 "%qD declared here", tmpl
);
3789 return error_mark_node
;
3792 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3794 return error_mark_node
;
3799 /* Build the UNBOUND_CLASS_TEMPLATE. */
3800 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3801 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3802 TREE_TYPE (t
) = NULL_TREE
;
3803 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3805 /* Build the corresponding TEMPLATE_DECL. */
3806 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3807 TYPE_NAME (TREE_TYPE (d
)) = d
;
3808 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3809 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3810 DECL_ARTIFICIAL (d
) = 1;
3811 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3818 /* Push the declarations of builtin types into the namespace.
3819 RID_INDEX is the index of the builtin type in the array
3820 RID_POINTERS. NAME is the name used when looking up the builtin
3821 type. TYPE is the _TYPE node for the builtin type. */
3824 record_builtin_type (enum rid rid_index
,
3828 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3829 tree tdecl
= NULL_TREE
;
3831 if ((int) rid_index
< (int) RID_MAX
)
3832 rname
= ridpointers
[(int) rid_index
];
3834 tname
= get_identifier (name
);
3836 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3837 eliminated. Built-in types should not be looked up name; their
3838 names are keywords that the parser can recognize. However, there
3839 is code in c-common.c that uses identifier_global_value to look
3840 up built-in types by name. */
3843 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3844 DECL_ARTIFICIAL (tdecl
) = 1;
3845 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3851 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3852 DECL_ARTIFICIAL (tdecl
) = 1;
3854 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3857 if (!TYPE_NAME (type
))
3858 TYPE_NAME (type
) = tdecl
;
3861 debug_hooks
->type_decl (tdecl
, 0);
3864 /* Record one of the standard Java types.
3865 * Declare it as having the given NAME.
3866 * If SIZE > 0, it is the size of one of the integral types;
3867 * otherwise it is the negative of the size of one of the other types. */
3870 record_builtin_java_type (const char* name
, int size
)
3875 type
= build_nonstandard_integer_type (size
, 0);
3876 type
= build_distinct_type_copy (type
);
3878 else if (size
> -32)
3881 /* "__java_char" or ""__java_boolean". */
3882 type
= build_nonstandard_integer_type (-size
, 1);
3883 type
= build_distinct_type_copy (type
);
3884 /* Get the signed type cached and attached to the unsigned type,
3885 so it doesn't get garbage-collected at "random" times,
3886 causing potential codegen differences out of different UIDs
3887 and different alias set numbers. */
3888 stype
= build_nonstandard_integer_type (-size
, 0);
3889 stype
= build_distinct_type_copy (stype
);
3890 TREE_CHAIN (type
) = stype
;
3891 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3894 { /* "__java_float" or ""__java_double". */
3895 type
= make_node (REAL_TYPE
);
3896 TYPE_PRECISION (type
) = - size
;
3899 record_builtin_type (RID_MAX
, name
, type
);
3900 decl
= TYPE_NAME (type
);
3902 /* Suppress generate debug symbol entries for these types,
3903 since for normal C++ they are just clutter.
3904 However, push_lang_context undoes this if extern "Java" is seen. */
3905 DECL_IGNORED_P (decl
) = 1;
3907 TYPE_FOR_JAVA (type
) = 1;
3911 /* Push a type into the namespace so that the back ends ignore it. */
3914 record_unknown_type (tree type
, const char* name
)
3916 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3917 TYPE_DECL
, get_identifier (name
), type
));
3918 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3919 DECL_IGNORED_P (decl
) = 1;
3920 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3921 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3922 TYPE_ALIGN (type
) = 1;
3923 TYPE_USER_ALIGN (type
) = 0;
3924 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3927 /* A string for which we should create an IDENTIFIER_NODE at
3930 struct predefined_identifier
3932 /* The name of the identifier. */
3933 const char *const name
;
3934 /* The place where the IDENTIFIER_NODE should be stored. */
3936 /* Nonzero if this is the name of a constructor or destructor. */
3937 const int ctor_or_dtor_p
;
3940 /* Create all the predefined identifiers. */
3943 initialize_predefined_identifiers (void)
3945 const predefined_identifier
*pid
;
3947 /* A table of identifiers to create at startup. */
3948 static const predefined_identifier predefined_identifiers
[] = {
3949 { "C++", &lang_name_cplusplus
, 0 },
3950 { "C", &lang_name_c
, 0 },
3951 { "Java", &lang_name_java
, 0 },
3952 /* Some of these names have a trailing space so that it is
3953 impossible for them to conflict with names written by users. */
3954 { "__ct ", &ctor_identifier
, 1 },
3955 { "__base_ctor ", &base_ctor_identifier
, 1 },
3956 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3957 { "__dt ", &dtor_identifier
, 1 },
3958 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3959 { "__base_dtor ", &base_dtor_identifier
, 1 },
3960 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3961 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3962 { "nelts", &nelts_identifier
, 0 },
3963 { THIS_NAME
, &this_identifier
, 0 },
3964 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3965 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3966 { "_vptr", &vptr_identifier
, 0 },
3967 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3968 { "::", &global_scope_name
, 0 },
3969 { "std", &std_identifier
, 0 },
3973 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3975 *pid
->node
= get_identifier (pid
->name
);
3976 if (pid
->ctor_or_dtor_p
)
3977 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3981 /* Create the predefined scalar types of C,
3982 and some nodes representing standard constants (0, 1, (void *)0).
3983 Initialize the global binding level.
3984 Make definitions for built-in primitive functions. */
3987 cxx_init_decl_processing (void)
3990 tree void_ftype_ptr
;
3992 /* Create all the identifiers we need. */
3993 initialize_predefined_identifiers ();
3995 /* Create the global variables. */
3996 push_to_top_level ();
3998 current_function_decl
= NULL_TREE
;
3999 current_binding_level
= NULL
;
4000 /* Enter the global namespace. */
4001 gcc_assert (global_namespace
== NULL_TREE
);
4002 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
4004 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
4005 debug_hooks
->register_main_translation_unit
4006 (DECL_CONTEXT (global_namespace
));
4007 TREE_PUBLIC (global_namespace
) = 1;
4008 begin_scope (sk_namespace
, global_namespace
);
4010 if (flag_visibility_ms_compat
)
4011 default_visibility
= VISIBILITY_HIDDEN
;
4014 current_lang_name
= lang_name_c
;
4016 /* Create the `std' namespace. */
4017 push_namespace (std_identifier
);
4018 std_node
= current_namespace
;
4021 c_common_nodes_and_builtins ();
4023 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
4024 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
4025 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
4026 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
4027 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
4028 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
4029 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
4030 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
4032 integer_two_node
= build_int_cst (NULL_TREE
, 2);
4034 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
4035 truthvalue_type_node
= boolean_type_node
;
4036 truthvalue_false_node
= boolean_false_node
;
4037 truthvalue_true_node
= boolean_true_node
;
4039 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
4040 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
4041 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
4044 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
4047 delta_type_node
= ptrdiff_type_node
;
4048 vtable_index_type
= ptrdiff_type_node
;
4050 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
4051 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
4052 void_ftype_ptr
= build_function_type_list (void_type_node
,
4053 ptr_type_node
, NULL_TREE
);
4055 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4057 /* C++ extensions */
4059 unknown_type_node
= make_node (LANG_TYPE
);
4060 record_unknown_type (unknown_type_node
, "unknown type");
4062 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4063 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4065 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4067 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4068 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4070 init_list_type_node
= make_node (LANG_TYPE
);
4071 record_unknown_type (init_list_type_node
, "init list");
4074 /* Make sure we get a unique function type, so we can give
4075 its pointer type a name. (This wins for gdb.) */
4076 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4077 TREE_TYPE (vfunc_type
) = integer_type_node
;
4078 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4079 layout_type (vfunc_type
);
4081 vtable_entry_type
= build_pointer_type (vfunc_type
);
4083 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
4086 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4087 layout_type (vtbl_type_node
);
4088 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4089 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4090 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4091 layout_type (vtbl_ptr_type_node
);
4092 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4094 push_namespace (get_identifier ("__cxxabiv1"));
4095 abi_node
= current_namespace
;
4098 global_type_node
= make_node (LANG_TYPE
);
4099 record_unknown_type (global_type_node
, "global type");
4102 current_lang_name
= lang_name_cplusplus
;
4105 tree newattrs
, extvisattr
;
4106 tree newtype
, deltype
;
4107 tree ptr_ftype_sizetype
;
4111 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4112 if (cxx_dialect
== cxx98
)
4115 tree bad_alloc_type_node
;
4116 tree bad_alloc_decl
;
4118 push_namespace (std_identifier
);
4119 bad_alloc_id
= get_identifier ("bad_alloc");
4120 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4121 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4123 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4124 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4128 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4131 new_eh_spec
= noexcept_false_spec
;
4133 /* Ensure attribs.c is initialized. */
4136 /* Ensure constraint.cc is initialized. */
4137 init_constraint_processing ();
4139 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4141 newattrs
= tree_cons (get_identifier ("alloc_size"),
4142 build_tree_list (NULL_TREE
, integer_one_node
),
4144 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4145 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4146 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4147 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4148 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4149 DECL_IS_MALLOC (opnew
) = 1;
4150 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4151 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4152 DECL_IS_MALLOC (opnew
) = 1;
4153 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4154 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4155 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4156 if (flag_sized_deallocation
)
4158 /* Also push the sized deallocation variants:
4159 void operator delete(void*, std::size_t) throw();
4160 void operator delete[](void*, std::size_t) throw(); */
4161 tree void_ftype_ptr_size
4162 = build_function_type_list (void_type_node
, ptr_type_node
,
4163 size_type_node
, NULL_TREE
);
4164 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4166 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4167 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4168 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4171 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4172 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4173 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4174 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4175 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4176 if (abi_version_at_least (9))
4177 TYPE_ALIGN (nullptr_type_node
) = GET_MODE_ALIGNMENT (ptr_mode
);
4178 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4179 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4180 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4184 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4185 ECF_NORETURN
| ECF_NOTHROW
);
4187 /* Perform other language dependent initializations. */
4188 init_class_processing ();
4189 init_rtti_processing ();
4190 init_template_processing ();
4192 if (flag_exceptions
)
4193 init_exception_processing ();
4195 if (! supports_one_only ())
4198 make_fname_decl
= cp_make_fname_decl
;
4199 start_fname_decls ();
4201 /* Show we use EH for cleanups. */
4202 if (flag_exceptions
)
4203 using_eh_for_cleanups ();
4206 /* Generate an initializer for a function naming variable from
4207 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4208 filled in with the type of the init. */
4211 cp_fname_init (const char* name
, tree
*type_p
)
4213 tree domain
= NULL_TREE
;
4215 tree init
= NULL_TREE
;
4220 length
= strlen (name
);
4221 domain
= build_index_type (size_int (length
));
4222 init
= build_string (length
+ 1, name
);
4225 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4226 type
= build_cplus_array_type (type
, domain
);
4231 TREE_TYPE (init
) = type
;
4233 init
= error_mark_node
;
4238 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4239 the decl, LOC is the location to give the decl, NAME is the
4240 initialization string and TYPE_DEP indicates whether NAME depended
4241 on the type of the function. We make use of that to detect
4242 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4243 at the point of first use, so we mustn't push the decl now. */
4246 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4248 const char *const name
= (type_dep
&& processing_template_decl
4249 ? NULL
: fname_as_string (type_dep
));
4251 tree init
= cp_fname_init (name
, &type
);
4252 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4255 free (CONST_CAST (char *, name
));
4257 /* As we're using pushdecl_with_scope, we must set the context. */
4258 DECL_CONTEXT (decl
) = current_function_decl
;
4260 TREE_STATIC (decl
) = 1;
4261 TREE_READONLY (decl
) = 1;
4262 DECL_ARTIFICIAL (decl
) = 1;
4264 TREE_USED (decl
) = 1;
4266 if (current_function_decl
)
4268 cp_binding_level
*b
= current_binding_level
;
4269 if (b
->kind
== sk_function_parms
)
4270 return error_mark_node
;
4271 while (b
->level_chain
->kind
!= sk_function_parms
)
4273 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
4274 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
4275 LOOKUP_ONLYCONVERTING
);
4279 DECL_THIS_STATIC (decl
) = true;
4280 pushdecl_top_level_and_finish (decl
, init
);
4287 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4289 tree id
= DECL_NAME (decl
);
4290 const char *name
= IDENTIFIER_POINTER (id
);
4292 retrofit_lang_decl (decl
);
4294 DECL_ARTIFICIAL (decl
) = 1;
4295 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
4296 SET_DECL_LANGUAGE (decl
, lang_c
);
4297 /* Runtime library routines are, by definition, available in an
4298 external shared object. */
4299 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4300 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4302 DECL_CONTEXT (decl
) = context
;
4305 pushdecl_top_level (decl
);
4309 /* A function in the user's namespace should have an explicit
4310 declaration before it is used. Mark the built-in function as
4311 anticipated but not actually declared. */
4312 if (name
[0] != '_' || name
[1] != '_')
4313 DECL_ANTICIPATED (decl
) = 1;
4314 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4316 size_t len
= strlen (name
);
4318 /* Treat __*_chk fortification functions as anticipated as well,
4319 unless they are __builtin_*. */
4320 if (len
> strlen ("___chk")
4321 && memcmp (name
+ len
- strlen ("_chk"),
4322 "_chk", strlen ("_chk") + 1) == 0)
4323 DECL_ANTICIPATED (decl
) = 1;
4330 cxx_builtin_function (tree decl
)
4332 tree id
= DECL_NAME (decl
);
4333 const char *name
= IDENTIFIER_POINTER (id
);
4334 /* All builtins that don't begin with an '_' should additionally
4335 go in the 'std' namespace. */
4338 tree decl2
= copy_node(decl
);
4339 push_namespace (std_identifier
);
4340 builtin_function_1 (decl2
, std_node
, false);
4344 return builtin_function_1 (decl
, NULL_TREE
, false);
4347 /* Like cxx_builtin_function, but guarantee the function is added to the global
4348 scope. This is to allow function specific options to add new machine
4349 dependent builtins when the target ISA changes via attribute((target(...)))
4350 which saves space on program startup if the program does not use non-generic
4354 cxx_builtin_function_ext_scope (tree decl
)
4357 tree id
= DECL_NAME (decl
);
4358 const char *name
= IDENTIFIER_POINTER (id
);
4359 /* All builtins that don't begin with an '_' should additionally
4360 go in the 'std' namespace. */
4363 tree decl2
= copy_node(decl
);
4364 push_namespace (std_identifier
);
4365 builtin_function_1 (decl2
, std_node
, true);
4369 return builtin_function_1 (decl
, NULL_TREE
, true);
4372 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4373 function. Not called directly. */
4376 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4379 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4380 DECL_EXTERNAL (fn
) = 1;
4381 TREE_PUBLIC (fn
) = 1;
4382 DECL_ARTIFICIAL (fn
) = 1;
4383 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4384 SET_DECL_LANGUAGE (fn
, lang_c
);
4385 /* Runtime library routines are, by definition, available in an
4386 external shared object. */
4387 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4388 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4389 set_call_expr_flags (fn
, ecf_flags
);
4393 /* Returns the _DECL for a library function with C++ linkage. */
4396 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4399 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4400 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4401 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4405 /* Like build_library_fn, but takes a C string instead of an
4409 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4411 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4414 /* Like build_cp_library_fn, but takes a C string instead of an
4418 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4420 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4424 /* Like build_library_fn, but also pushes the function so that we will
4425 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4426 may throw exceptions listed in RAISES. */
4429 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4434 type
= build_exception_variant (type
, raises
);
4436 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4437 pushdecl_top_level (fn
);
4441 /* Like build_cp_library_fn, but also pushes the function so that it
4442 will be found by normal lookup. */
4445 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4448 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4453 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4457 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4461 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4463 tree type
= build_function_type (void_type_node
, parmtypes
);
4464 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4467 /* Like push_library_fn, but also note that this function throws
4468 and does not return. Used for __throw_foo and the like. */
4471 push_throw_library_fn (tree name
, tree type
)
4473 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4477 /* When we call finish_struct for an anonymous union, we create
4478 default copy constructors and such. But, an anonymous union
4479 shouldn't have such things; this function undoes the damage to the
4480 anonymous union type T.
4482 (The reason that we create the synthesized methods is that we don't
4483 distinguish `union { int i; }' from `typedef union { int i; } U'.
4484 The first is an anonymous union; the second is just an ordinary
4488 fixup_anonymous_aggr (tree t
)
4492 /* Wipe out memory of synthesized methods. */
4493 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4494 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4495 TYPE_HAS_COPY_CTOR (t
) = 0;
4496 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4497 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4498 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4500 /* Splice the implicitly generated functions out of the TYPE_METHODS
4502 q
= &TYPE_METHODS (t
);
4505 if (DECL_ARTIFICIAL (*q
))
4506 *q
= TREE_CHAIN (*q
);
4508 q
= &DECL_CHAIN (*q
);
4511 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4512 if (TYPE_METHODS (t
))
4514 tree decl
= TYPE_MAIN_DECL (t
);
4516 if (TREE_CODE (t
) != UNION_TYPE
)
4517 error_at (DECL_SOURCE_LOCATION (decl
),
4518 "an anonymous struct cannot have function members");
4520 error_at (DECL_SOURCE_LOCATION (decl
),
4521 "an anonymous union cannot have function members");
4524 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4525 assignment operators (because they cannot have these methods themselves).
4526 For anonymous unions this is already checked because they are not allowed
4527 in any union, otherwise we have to check it. */
4528 if (TREE_CODE (t
) != UNION_TYPE
)
4532 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4533 if (TREE_CODE (field
) == FIELD_DECL
)
4535 type
= TREE_TYPE (field
);
4536 if (CLASS_TYPE_P (type
))
4538 if (TYPE_NEEDS_CONSTRUCTING (type
))
4539 error ("member %q+#D with constructor not allowed "
4540 "in anonymous aggregate", field
);
4541 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4542 error ("member %q+#D with destructor not allowed "
4543 "in anonymous aggregate", field
);
4544 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4545 error ("member %q+#D with copy assignment operator "
4546 "not allowed in anonymous aggregate", field
);
4552 /* Warn for an attribute located at LOCATION that appertains to the
4553 class type CLASS_TYPE that has not been properly placed after its
4554 class-key, in it class-specifier. */
4557 warn_misplaced_attr_for_class_type (source_location location
,
4560 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4562 if (warning_at (location
, OPT_Wattributes
,
4563 "attribute ignored in declaration "
4564 "of %q#T", class_type
))
4566 "attribute for %q#T must follow the %qs keyword",
4567 class_type
, class_key_or_enum_as_string (class_type
));
4570 /* Make sure that a declaration with no declarator is well-formed, i.e.
4571 just declares a tagged type or anonymous union.
4573 Returns the type declared; or NULL_TREE if none. */
4576 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4577 bool explicit_type_instantiation_p
)
4579 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4580 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4581 /* If a class, struct, or enum type is declared by the DECLSPECS
4582 (i.e, if a class-specifier, enum-specifier, or non-typename
4583 elaborated-type-specifier appears in the DECLSPECS),
4584 DECLARED_TYPE is set to the corresponding type. */
4585 tree declared_type
= NULL_TREE
;
4586 bool error_p
= false;
4588 if (declspecs
->multiple_types_p
)
4589 error ("multiple types in one declaration");
4590 else if (declspecs
->redefined_builtin_type
)
4592 if (!in_system_header_at (input_location
))
4593 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4594 "redeclaration of C++ built-in type %qT",
4595 declspecs
->redefined_builtin_type
);
4600 && TYPE_P (declspecs
->type
)
4601 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4602 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4603 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4604 declared_type
= declspecs
->type
;
4605 else if (declspecs
->type
== error_mark_node
)
4607 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4608 permerror (input_location
, "declaration does not declare anything");
4609 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4611 error_at (declspecs
->locations
[ds_type_spec
],
4612 "%<auto%> can only be specified for variables "
4613 "or function declarations");
4614 return error_mark_node
;
4616 /* Check for an anonymous union. */
4617 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4618 && TYPE_ANONYMOUS_P (declared_type
))
4620 /* 7/3 In a simple-declaration, the optional init-declarator-list
4621 can be omitted only when declaring a class (clause 9) or
4622 enumeration (7.2), that is, when the decl-specifier-seq contains
4623 either a class-specifier, an elaborated-type-specifier with
4624 a class-key (9.1), or an enum-specifier. In these cases and
4625 whenever a class-specifier or enum-specifier is present in the
4626 decl-specifier-seq, the identifiers in these specifiers are among
4627 the names being declared by the declaration (as class-name,
4628 enum-names, or enumerators, depending on the syntax). In such
4629 cases, and except for the declaration of an unnamed bit-field (9.6),
4630 the decl-specifier-seq shall introduce one or more names into the
4631 program, or shall redeclare a name introduced by a previous
4632 declaration. [Example:
4633 enum { }; // ill-formed
4634 typedef class { }; // ill-formed
4638 error ("missing type-name in typedef-declaration");
4641 /* Anonymous unions are objects, so they can have specifiers. */;
4642 SET_ANON_AGGR_TYPE_P (declared_type
);
4644 if (TREE_CODE (declared_type
) != UNION_TYPE
4645 && !in_system_header_at (input_location
))
4646 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4651 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4652 error_at (declspecs
->locations
[ds_inline
],
4653 "%<inline%> can only be specified for functions");
4654 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4655 error_at (declspecs
->locations
[ds_virtual
],
4656 "%<virtual%> can only be specified for functions");
4658 && (!current_class_type
4659 || current_scope () != current_class_type
))
4660 error_at (declspecs
->locations
[ds_friend
],
4661 "%<friend%> can only be specified inside a class");
4662 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4663 error_at (declspecs
->locations
[ds_explicit
],
4664 "%<explicit%> can only be specified for constructors");
4665 else if (declspecs
->storage_class
)
4666 error_at (declspecs
->locations
[ds_storage_class
],
4667 "a storage class can only be specified for objects "
4669 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4670 error_at (declspecs
->locations
[ds_const
],
4671 "%<const%> can only be specified for objects and "
4673 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4674 error_at (declspecs
->locations
[ds_volatile
],
4675 "%<volatile%> can only be specified for objects and "
4677 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4678 error_at (declspecs
->locations
[ds_restrict
],
4679 "%<__restrict%> can only be specified for objects and "
4681 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4682 error_at (declspecs
->locations
[ds_thread
],
4683 "%<__thread%> can only be specified for objects "
4685 else if (saw_typedef
)
4686 warning_at (declspecs
->locations
[ds_typedef
], 0,
4687 "%<typedef%> was ignored in this declaration");
4688 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4689 error_at (declspecs
->locations
[ds_constexpr
],
4690 "%<constexpr%> cannot be used for type declarations");
4693 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4696 if (!CLASS_TYPE_P (declared_type
)
4697 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4698 /* For a non-template class, use the name location. */
4699 loc
= location_of (declared_type
);
4701 /* For a template class (an explicit instantiation), use the
4702 current location. */
4703 loc
= input_location
;
4705 if (explicit_type_instantiation_p
)
4706 /* [dcl.attr.grammar]/4:
4708 No attribute-specifier-seq shall appertain to an explicit
4711 if (warning_at (loc
, OPT_Wattributes
,
4712 "attribute ignored in explicit instantiation %q#T",
4715 "no attribute can be applied to "
4716 "an explicit instantiation");
4719 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4722 return declared_type
;
4725 /* Called when a declaration is seen that contains no names to declare.
4726 If its type is a reference to a structure, union or enum inherited
4727 from a containing scope, shadow that tag name for the current scope
4728 with a forward reference.
4729 If its type defines a new named structure or union
4730 or defines an enum, it is valid but we need not do anything here.
4731 Otherwise, it is an error.
4733 C++: may have to grok the declspecs to learn about static,
4734 complain for anonymous unions.
4736 Returns the TYPE declared -- or NULL_TREE if none. */
4739 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4741 tree t
= check_tag_decl (declspecs
,
4742 /*explicit_type_instantiation_p=*/false);
4747 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4750 /* This is where the variables in an anonymous union are
4751 declared. An anonymous union declaration looks like:
4753 because there is no declarator after the union, the parser
4754 sends that declaration here. */
4755 if (ANON_AGGR_TYPE_P (t
))
4757 fixup_anonymous_aggr (t
);
4759 if (TYPE_FIELDS (t
))
4761 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4762 declspecs
, NORMAL
, 0, NULL
);
4763 finish_anon_union (decl
);
4770 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4773 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4774 const cp_declarator
*declarator
,
4775 bool is_template_arg
)
4779 enum decl_context context
4780 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4781 attrs
= type_specifiers
->attributes
;
4782 type_specifiers
->attributes
= NULL_TREE
;
4783 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4784 if (attrs
&& type
!= error_mark_node
)
4786 if (CLASS_TYPE_P (type
))
4787 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4788 "outside of definition", type
);
4789 else if (MAYBE_CLASS_TYPE_P (type
))
4790 /* A template type parameter or other dependent type. */
4791 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4792 "type %qT without an associated declaration", type
);
4794 cplus_decl_attributes (&type
, attrs
, 0);
4799 /* Process a DECLARATOR for a function-scope variable declaration,
4800 namespace-scope variable declaration, or function declaration.
4801 (Function definitions go through start_function; class member
4802 declarations appearing in the body of the class go through
4803 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4804 If an error occurs, the error_mark_node is returned instead.
4806 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4807 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4808 for an explicitly defaulted function, or SD_DELETED for an explicitly
4809 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4810 implicitly initialized via a default constructor. ATTRIBUTES and
4811 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4813 The scope represented by the context of the returned DECL is pushed
4814 (if it is not the global namespace) and is assigned to
4815 *PUSHED_SCOPE_P. The caller is then responsible for calling
4816 pop_scope on *PUSHED_SCOPE_P if it is set. */
4819 start_decl (const cp_declarator
*declarator
,
4820 cp_decl_specifier_seq
*declspecs
,
4823 tree prefix_attributes
,
4824 tree
*pushed_scope_p
)
4832 *pushed_scope_p
= NULL_TREE
;
4834 /* An object declared as __attribute__((deprecated)) suppresses
4835 warnings of uses of other deprecated items. */
4836 if (lookup_attribute ("deprecated", attributes
))
4837 deprecated_state
= DEPRECATED_SUPPRESS
;
4839 attributes
= chainon (attributes
, prefix_attributes
);
4841 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4844 deprecated_state
= DEPRECATED_NORMAL
;
4846 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4847 || decl
== error_mark_node
)
4848 return error_mark_node
;
4850 context
= CP_DECL_CONTEXT (decl
);
4851 if (context
!= global_namespace
)
4852 *pushed_scope_p
= push_scope (context
);
4854 /* Is it valid for this decl to have an initializer at all?
4855 If not, set INITIALIZED to zero, which will indirectly
4856 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4858 && TREE_CODE (decl
) == TYPE_DECL
)
4860 error ("typedef %qD is initialized (use decltype instead)", decl
);
4861 return error_mark_node
;
4866 if (! toplevel_bindings_p ()
4867 && DECL_EXTERNAL (decl
))
4868 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4870 DECL_EXTERNAL (decl
) = 0;
4871 if (toplevel_bindings_p ())
4872 TREE_STATIC (decl
) = 1;
4874 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4876 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4877 record_key_method_defined (decl
);
4879 /* If this is a typedef that names the class for linkage purposes
4880 (7.1.3p8), apply any attributes directly to the type. */
4881 if (TREE_CODE (decl
) == TYPE_DECL
4882 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4883 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4884 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4888 /* Set attributes here so if duplicate decl, will have proper attributes. */
4889 cplus_decl_attributes (&decl
, attributes
, flags
);
4891 /* Dllimported symbols cannot be defined. Static data members (which
4892 can be initialized in-class and dllimported) go through grokfield,
4893 not here, so we don't need to exclude those decls when checking for
4895 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4897 error ("definition of %q#D is marked %<dllimport%>", decl
);
4898 DECL_DLLIMPORT_P (decl
) = 0;
4901 /* If #pragma weak was used, mark the decl weak now. */
4902 if (!processing_template_decl
)
4903 maybe_apply_pragma_weak (decl
);
4905 if (TREE_CODE (decl
) == FUNCTION_DECL
4906 && DECL_DECLARED_INLINE_P (decl
)
4907 && DECL_UNINLINABLE (decl
)
4908 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4909 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4910 "inline function %qD given attribute noinline", decl
);
4912 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4914 bool this_tmpl
= (processing_template_decl
4915 > template_class_depth (context
));
4918 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4919 if (field
== NULL_TREE
4920 || !(VAR_P (field
) || variable_template_p (field
)))
4921 error ("%q+#D is not a static data member of %q#T", decl
, context
);
4922 else if (variable_template_p (field
) && !this_tmpl
)
4924 if (DECL_LANG_SPECIFIC (decl
)
4925 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4926 /* OK, specialization was already checked. */;
4929 error_at (DECL_SOURCE_LOCATION (decl
),
4930 "non-member-template declaration of %qD", decl
);
4931 inform (DECL_SOURCE_LOCATION (field
), "does not match "
4932 "member template declaration here");
4933 return error_mark_node
;
4938 if (variable_template_p (field
))
4939 field
= DECL_TEMPLATE_RESULT (field
);
4941 if (DECL_CONTEXT (field
) != context
)
4943 if (!same_type_p (DECL_CONTEXT (field
), context
))
4944 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4945 "to be defined as %<%T::%D%>",
4946 DECL_CONTEXT (field
), DECL_NAME (decl
),
4947 context
, DECL_NAME (decl
));
4948 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4950 /* Static data member are tricky; an in-class initialization
4951 still doesn't provide a definition, so the in-class
4952 declaration will have DECL_EXTERNAL set, but will have an
4953 initialization. Thus, duplicate_decls won't warn
4954 about this situation, and so we check here. */
4955 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4956 error ("duplicate initialization of %qD", decl
);
4957 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4959 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4960 && !DECL_DECLARED_CONSTEXPR_P (field
))
4961 error ("%qD declared %<constexpr%> outside its class", field
);
4966 tree field
= check_classfn (context
, decl
,
4968 ? current_template_parms
4970 if (field
&& field
!= error_mark_node
4971 && duplicate_decls (decl
, field
,
4972 /*newdecl_is_friend=*/false))
4976 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4977 DECL_IN_AGGR_P (decl
) = 0;
4978 /* Do not mark DECL as an explicit specialization if it was not
4979 already marked as an instantiation; a declaration should
4980 never be marked as a specialization unless we know what
4981 template is being specialized. */
4982 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4984 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4985 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4986 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
4987 && DECL_DECLARED_INLINE_P (decl
));
4989 DECL_COMDAT (decl
) = false;
4991 /* [temp.expl.spec] An explicit specialization of a static data
4992 member of a template is a definition if the declaration
4993 includes an initializer; otherwise, it is a declaration.
4995 We check for processing_specialization so this only applies
4996 to the new specialization syntax. */
4997 if (!initialized
&& processing_specialization
)
4998 DECL_EXTERNAL (decl
) = 1;
5001 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
5002 /* Aliases are definitions. */
5004 permerror (input_location
, "declaration of %q#D outside of class is not definition",
5008 was_public
= TREE_PUBLIC (decl
);
5010 /* Enter this declaration into the symbol table. Don't push the plain
5011 VAR_DECL for a variable template. */
5012 if (!template_parm_scope_p ()
5014 decl
= maybe_push_decl (decl
);
5016 if (processing_template_decl
)
5017 decl
= push_template_decl (decl
);
5018 if (decl
== error_mark_node
)
5019 return error_mark_node
;
5022 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
5023 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
5025 /* This is a const variable with implicit 'static'. Set
5026 DECL_THIS_STATIC so we can tell it from variables that are
5027 !TREE_PUBLIC because of the anonymous namespace. */
5028 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
5029 DECL_THIS_STATIC (decl
) = 1;
5032 if (current_function_decl
&& VAR_P (decl
)
5033 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
5036 if (CP_DECL_THREAD_LOCAL_P (decl
))
5037 error ("%qD declared %<thread_local%> in %<constexpr%> function",
5039 else if (TREE_STATIC (decl
))
5040 error ("%qD declared %<static%> in %<constexpr%> function", decl
);
5044 cp_function_chain
->invalid_constexpr
= true;
5047 if (!processing_template_decl
&& VAR_P (decl
))
5048 start_decl_1 (decl
, initialized
);
5053 /* Process the declaration of a variable DECL. INITIALIZED is true
5054 iff DECL is explicitly initialized. (INITIALIZED is false if the
5055 variable is initialized via an implicitly-called constructor.)
5056 This function must be called for ordinary variables (including, for
5057 example, implicit instantiations of templates), but must not be
5058 called for template declarations. */
5061 start_decl_1 (tree decl
, bool initialized
)
5065 bool aggregate_definition_p
;
5067 gcc_assert (!processing_template_decl
);
5069 if (error_operand_p (decl
))
5072 gcc_assert (VAR_P (decl
));
5074 type
= TREE_TYPE (decl
);
5075 complete_p
= COMPLETE_TYPE_P (type
);
5076 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5078 /* If an explicit initializer is present, or if this is a definition
5079 of an aggregate, then we need a complete type at this point.
5080 (Scalars are always complete types, so there is nothing to
5081 check.) This code just sets COMPLETE_P; errors (if necessary)
5082 are issued below. */
5083 if ((initialized
|| aggregate_definition_p
)
5085 && COMPLETE_TYPE_P (complete_type (type
)))
5088 /* We will not yet have set TREE_READONLY on DECL if the type
5089 was "const", but incomplete, before this point. But, now, we
5090 have a complete type, so we can try again. */
5091 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5095 /* Is it valid for this decl to have an initializer at all? */
5097 /* Don't allow initializations for incomplete types except for
5098 arrays which might be completed by the initialization. */
5100 ; /* A complete type is ok. */
5101 else if (type_uses_auto (type
))
5102 ; /* An auto type is ok. */
5103 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5105 error ("variable %q#D has initializer but incomplete type", decl
);
5106 type
= TREE_TYPE (decl
) = error_mark_node
;
5108 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5110 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5111 error ("elements of array %q#D have incomplete type", decl
);
5112 /* else we already gave an error in start_decl. */
5115 else if (aggregate_definition_p
&& !complete_p
)
5117 if (type_uses_auto (type
))
5118 error ("declaration of %q#D has no initializer", decl
);
5120 error ("aggregate %q#D has incomplete type and cannot be defined",
5122 /* Change the type so that assemble_variable will give
5123 DECL an rtl we can live with: (mem (const_int 0)). */
5124 type
= TREE_TYPE (decl
) = error_mark_node
;
5127 /* Create a new scope to hold this declaration if necessary.
5128 Whether or not a new scope is necessary cannot be determined
5129 until after the type has been completed; if the type is a
5130 specialization of a class template it is not until after
5131 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5132 will be set correctly. */
5133 maybe_push_cleanup_level (type
);
5136 /* Handle initialization of references. DECL, TYPE, and INIT have the
5137 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5138 but will be set to a new CLEANUP_STMT if a temporary is created
5139 that must be destroyed subsequently.
5141 Returns an initializer expression to use to initialize DECL, or
5142 NULL if the initialization can be performed statically.
5144 Quotes on semantics can be found in ARM 8.4.3. */
5147 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5149 if (init
== NULL_TREE
)
5151 if ((DECL_LANG_SPECIFIC (decl
) == 0
5152 || DECL_IN_AGGR_P (decl
) == 0)
5153 && ! DECL_THIS_EXTERN (decl
))
5154 error ("%qD declared as reference but not initialized", decl
);
5158 if (TREE_CODE (init
) == TREE_LIST
)
5159 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5160 tf_warning_or_error
);
5162 tree ttype
= TREE_TYPE (type
);
5163 if (TREE_CODE (ttype
) != ARRAY_TYPE
5164 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5165 /* Note: default conversion is only called in very special cases. */
5166 init
= decay_conversion (init
, tf_warning_or_error
);
5168 /* check_initializer handles this for non-reference variables, but for
5169 references we need to do it here or the initializer will get the
5170 incomplete array type and confuse later calls to
5171 cp_complete_array_type. */
5172 if (TREE_CODE (ttype
) == ARRAY_TYPE
5173 && TYPE_DOMAIN (ttype
) == NULL_TREE
5174 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5175 || TREE_CODE (init
) == STRING_CST
))
5177 cp_complete_array_type (&ttype
, init
, false);
5178 if (ttype
!= TREE_TYPE (type
))
5179 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5182 /* Convert INIT to the reference type TYPE. This may involve the
5183 creation of a temporary, whose lifetime must be the same as that
5184 of the reference. If so, a DECL_EXPR for the temporary will be
5185 added just after the DECL_EXPR for DECL. That's why we don't set
5186 DECL_INITIAL for local references (instead assigning to them
5187 explicitly); we need to allow the temporary to be initialized
5189 return initialize_reference (type
, init
, flags
,
5190 tf_warning_or_error
);
5193 /* Designated initializers in arrays are not supported in GNU C++.
5194 The parser cannot detect this error since it does not know whether
5195 a given brace-enclosed initializer is for a class type or for an
5196 array. This function checks that CE does not use a designated
5197 initializer. If it does, an error is issued. Returns true if CE
5198 is valid, i.e., does not have a designated initializer. */
5201 check_array_designated_initializer (constructor_elt
*ce
,
5202 unsigned HOST_WIDE_INT index
)
5204 /* Designated initializers for array elements are not supported. */
5207 /* The parser only allows identifiers as designated
5209 if (ce
->index
== error_mark_node
)
5211 error ("name used in a GNU-style designated "
5212 "initializer for an array");
5215 else if (identifier_p (ce
->index
))
5217 error ("name %qD used in a GNU-style designated "
5218 "initializer for an array", ce
->index
);
5222 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5225 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5226 && (TREE_CODE (ce_index
= maybe_constant_value (ce_index
))
5229 /* A C99 designator is OK if it matches the current index. */
5230 if (wi::eq_p (ce_index
, index
))
5233 sorry ("non-trivial designated initializers not supported");
5236 error ("C99 designator %qE is not an integral constant-expression",
5245 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5246 array until we finish parsing the initializer. If that's the
5247 situation we're in, update DECL accordingly. */
5250 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5252 tree type
= TREE_TYPE (decl
);
5254 if (TREE_CODE (type
) == ARRAY_TYPE
5255 && TYPE_DOMAIN (type
) == NULL_TREE
5256 && TREE_CODE (decl
) != TYPE_DECL
)
5258 /* do_default is really a C-ism to deal with tentative definitions.
5259 But let's leave it here to ease the eventual merge. */
5260 int do_default
= !DECL_EXTERNAL (decl
);
5261 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5264 /* Check that there are no designated initializers in INIT, as
5265 those are not supported in GNU C++, and as the middle-end
5266 will crash if presented with a non-numeric designated
5268 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5270 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5271 constructor_elt
*ce
;
5273 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5274 if (!check_array_designated_initializer (ce
, i
))
5280 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5284 error ("initializer fails to determine size of %qD", decl
);
5286 else if (failure
== 2)
5290 error ("array size missing in %qD", decl
);
5292 /* If a `static' var's size isn't known, make it extern as
5293 well as static, so it does not get allocated. If it's not
5294 `static', then don't mark it extern; finish_incomplete_decl
5295 will give it a default size and it will get allocated. */
5296 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5297 DECL_EXTERNAL (decl
) = 1;
5299 else if (failure
== 3)
5301 error ("zero-size array %qD", decl
);
5305 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5307 relayout_decl (decl
);
5311 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5312 any appropriate error messages regarding the layout. */
5315 layout_var_decl (tree decl
)
5319 type
= TREE_TYPE (decl
);
5320 if (type
== error_mark_node
)
5323 /* If we haven't already laid out this declaration, do so now.
5324 Note that we must not call complete type for an external object
5325 because it's type might involve templates that we are not
5326 supposed to instantiate yet. (And it's perfectly valid to say
5327 `extern X x' for some incomplete type `X'.) */
5328 if (!DECL_EXTERNAL (decl
))
5329 complete_type (type
);
5330 if (!DECL_SIZE (decl
)
5331 && TREE_TYPE (decl
) != error_mark_node
5332 && (COMPLETE_TYPE_P (type
)
5333 || (TREE_CODE (type
) == ARRAY_TYPE
5334 && !TYPE_DOMAIN (type
)
5335 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
5336 layout_decl (decl
, 0);
5338 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5340 /* An automatic variable with an incomplete type: that is an error.
5341 Don't talk about array types here, since we took care of that
5342 message in grokdeclarator. */
5343 error ("storage size of %qD isn%'t known", decl
);
5344 TREE_TYPE (decl
) = error_mark_node
;
5347 /* Keep this code around in case we later want to control debug info
5348 based on whether a type is "used". (jason 1999-11-11) */
5350 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5351 /* Let debugger know it should output info for this type. */
5352 note_debug_info_needed (ttype
);
5354 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5355 note_debug_info_needed (DECL_CONTEXT (decl
));
5358 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5359 && DECL_SIZE (decl
) != NULL_TREE
5360 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5362 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5363 constant_expression_warning (DECL_SIZE (decl
));
5366 error ("storage size of %qD isn%'t constant", decl
);
5367 TREE_TYPE (decl
) = error_mark_node
;
5372 /* If a local static variable is declared in an inline function, or if
5373 we have a weak definition, we must endeavor to create only one
5374 instance of the variable at link-time. */
5377 maybe_commonize_var (tree decl
)
5379 /* Static data in a function with comdat linkage also has comdat
5381 if (TREE_STATIC (decl
)
5382 /* Don't mess with __FUNCTION__. */
5383 && ! DECL_ARTIFICIAL (decl
)
5384 && DECL_FUNCTION_SCOPE_P (decl
)
5385 && vague_linkage_p (DECL_CONTEXT (decl
)))
5389 /* With weak symbols, we simply make the variable COMDAT;
5390 that will cause copies in multiple translations units to
5392 comdat_linkage (decl
);
5396 if (DECL_INITIAL (decl
) == NULL_TREE
5397 || DECL_INITIAL (decl
) == error_mark_node
)
5399 /* Without weak symbols, we can use COMMON to merge
5400 uninitialized variables. */
5401 TREE_PUBLIC (decl
) = 1;
5402 DECL_COMMON (decl
) = 1;
5406 /* While for initialized variables, we must use internal
5407 linkage -- which means that multiple copies will not
5409 TREE_PUBLIC (decl
) = 0;
5410 DECL_COMMON (decl
) = 0;
5411 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5412 "sorry: semantics of inline function static "
5413 "data %q#D are wrong (you%'ll wind up "
5414 "with multiple copies)", decl
))
5415 inform (DECL_SOURCE_LOCATION (decl
),
5416 "you can work around this by removing the initializer");
5422 /* Issue an error message if DECL is an uninitialized const variable. */
5425 check_for_uninitialized_const_var (tree decl
)
5427 tree type
= strip_array_types (TREE_TYPE (decl
));
5429 /* ``Unless explicitly declared extern, a const object does not have
5430 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5433 && TREE_CODE (type
) != REFERENCE_TYPE
5434 && (CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5435 && !DECL_INITIAL (decl
))
5437 tree field
= default_init_uninitialized_part (type
);
5441 if (CP_TYPE_CONST_P (type
))
5442 permerror (DECL_SOURCE_LOCATION (decl
),
5443 "uninitialized const %qD", decl
);
5446 error_at (DECL_SOURCE_LOCATION (decl
),
5447 "uninitialized variable %qD in %<constexpr%> function",
5449 cp_function_chain
->invalid_constexpr
= true;
5452 if (CLASS_TYPE_P (type
))
5454 tree defaulted_ctor
;
5456 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5457 "%q#T has no user-provided default constructor", type
);
5458 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5460 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5461 "constructor is not user-provided because it is "
5462 "explicitly defaulted in the class body");
5463 inform (DECL_SOURCE_LOCATION (field
),
5464 "and the implicitly-defined constructor does not "
5465 "initialize %q#D", field
);
5470 /* Structure holding the current initializer being processed by reshape_init.
5471 CUR is a pointer to the current element being processed, END is a pointer
5472 after the last element present in the initializer. */
5475 constructor_elt
*cur
;
5476 constructor_elt
*end
;
5479 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5481 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5482 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5483 initialized. If there are no more such fields, the return value
5487 next_initializable_field (tree field
)
5490 && (TREE_CODE (field
) != FIELD_DECL
5491 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5492 || DECL_ARTIFICIAL (field
)))
5493 field
= DECL_CHAIN (field
);
5498 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5499 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5500 INTEGER_CST representing the size of the array minus one (the maximum index),
5501 or NULL_TREE if the array was declared without specifying the size. D is
5502 the iterator within the constructor. */
5505 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5506 tsubst_flags_t complain
)
5509 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5510 unsigned HOST_WIDE_INT max_index_cst
= 0;
5511 unsigned HOST_WIDE_INT index
;
5513 /* The initializer for an array is always a CONSTRUCTOR. */
5514 new_init
= build_constructor (init_list_type_node
, NULL
);
5518 /* Minus 1 is used for zero sized arrays. */
5519 if (integer_all_onesp (max_index
))
5522 if (tree_fits_uhwi_p (max_index
))
5523 max_index_cst
= tree_to_uhwi (max_index
);
5524 /* sizetype is sign extended, not zero extended. */
5526 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5529 /* Loop until there are no more initializers. */
5531 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5535 constructor_elt
*old_cur
= d
->cur
;
5537 check_array_designated_initializer (d
->cur
, index
);
5538 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5540 if (elt_init
== error_mark_node
)
5541 return error_mark_node
;
5542 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5543 size_int (index
), elt_init
);
5544 if (!TREE_CONSTANT (elt_init
))
5545 TREE_CONSTANT (new_init
) = false;
5547 /* This can happen with an invalid initializer (c++/54501). */
5548 if (d
->cur
== old_cur
&& !sized_array_p
)
5555 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5556 Parameters are the same of reshape_init_r. */
5559 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5561 tree max_index
= NULL_TREE
;
5563 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5565 if (TYPE_DOMAIN (type
))
5566 max_index
= array_type_nelts (type
);
5568 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5571 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5572 Parameters are the same of reshape_init_r. */
5575 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5577 tree max_index
= NULL_TREE
;
5579 gcc_assert (VECTOR_TYPE_P (type
));
5581 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5583 tree value
= d
->cur
->value
;
5584 if (!same_type_p (TREE_TYPE (value
), type
))
5586 if (complain
& tf_error
)
5587 error ("invalid type %qT as initializer for a vector of type %qT",
5588 TREE_TYPE (d
->cur
->value
), type
);
5589 value
= error_mark_node
;
5595 /* For a vector, we initialize it as an array of the appropriate size. */
5596 if (VECTOR_TYPE_P (type
))
5597 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5599 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5602 /* Subroutine of reshape_init_r, processes the initializers for classes
5603 or union. Parameters are the same of reshape_init_r. */
5606 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5607 tsubst_flags_t complain
)
5612 gcc_assert (CLASS_TYPE_P (type
));
5614 /* The initializer for a class is always a CONSTRUCTOR. */
5615 new_init
= build_constructor (init_list_type_node
, NULL
);
5616 field
= next_initializable_field (TYPE_FIELDS (type
));
5622 An initializer for an aggregate member that is an
5623 empty class shall have the form of an empty
5624 initializer-list {}. */
5625 if (!first_initializer_p
)
5627 if (complain
& tf_error
)
5628 error ("initializer for %qT must be brace-enclosed", type
);
5629 return error_mark_node
;
5634 /* Loop through the initializable fields, gathering initializers. */
5635 while (d
->cur
!= d
->end
)
5638 constructor_elt
*old_cur
= d
->cur
;
5640 /* Handle designated initializers, as an extension. */
5643 if (d
->cur
->index
== error_mark_node
)
5644 return error_mark_node
;
5646 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5647 /* We already reshaped this. */
5648 gcc_assert (d
->cur
->index
== field
);
5649 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5650 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5653 if (complain
& tf_error
)
5654 error ("%<[%E] =%> used in a GNU-style designated initializer"
5655 " for class %qT", d
->cur
->index
, type
);
5656 return error_mark_node
;
5659 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5661 if (complain
& tf_error
)
5662 error ("%qT has no non-static data member named %qD", type
,
5664 return error_mark_node
;
5668 /* If we processed all the member of the class, we are done. */
5672 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5673 /*first_initializer_p=*/false, complain
);
5674 if (field_init
== error_mark_node
)
5675 return error_mark_node
;
5677 if (d
->cur
== old_cur
&& d
->cur
->index
)
5679 /* This can happen with an invalid initializer for a flexible
5680 array member (c++/54441). */
5681 if (complain
& tf_error
)
5682 error ("invalid initializer for %q#D", field
);
5683 return error_mark_node
;
5686 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5690 When a union is initialized with a brace-enclosed
5691 initializer, the braces shall only contain an
5692 initializer for the first member of the union. */
5693 if (TREE_CODE (type
) == UNION_TYPE
)
5696 field
= next_initializable_field (DECL_CHAIN (field
));
5702 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5703 designators are not valid; either complain or return true to indicate
5704 that reshape_init_r should return error_mark_node. */
5707 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5711 if (complain
& tf_error
)
5712 error ("C99 designator %qE outside aggregate initializer",
5720 /* Subroutine of reshape_init, which processes a single initializer (part of
5721 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5722 iterator within the CONSTRUCTOR which points to the initializer to process.
5723 FIRST_INITIALIZER_P is true if this is the first initializer of the
5724 outermost CONSTRUCTOR node. */
5727 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5728 tsubst_flags_t complain
)
5730 tree init
= d
->cur
->value
;
5732 if (error_operand_p (init
))
5733 return error_mark_node
;
5735 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5736 && has_designator_problem (d
, complain
))
5737 return error_mark_node
;
5739 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5741 /* A complex type can be initialized from one or two initializers,
5742 but braces are not elided. */
5744 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5746 if (CONSTRUCTOR_NELTS (init
) > 2)
5748 if (complain
& tf_error
)
5749 error ("too many initializers for %qT", type
);
5751 return error_mark_node
;
5754 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5756 vec
<constructor_elt
, va_gc
> *v
= 0;
5757 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5758 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5759 if (has_designator_problem (d
, complain
))
5760 return error_mark_node
;
5762 init
= build_constructor (init_list_type_node
, v
);
5767 /* A non-aggregate type is always initialized with a single
5769 if (!CP_AGGREGATE_TYPE_P (type
))
5771 /* It is invalid to initialize a non-aggregate type with a
5772 brace-enclosed initializer before C++0x.
5773 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5774 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5775 a CONSTRUCTOR (with a record type). */
5776 if (TREE_CODE (init
) == CONSTRUCTOR
5777 /* Don't complain about a capture-init. */
5778 && !CONSTRUCTOR_IS_DIRECT_INIT (init
)
5779 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5781 if (SCALAR_TYPE_P (type
))
5783 if (cxx_dialect
< cxx11
5784 /* Isn't value-initialization. */
5785 || CONSTRUCTOR_NELTS (init
) > 0)
5787 if (complain
& tf_error
)
5788 error ("braces around scalar initializer for type %qT",
5790 init
= error_mark_node
;
5794 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5801 /* "If T is a class type and the initializer list has a single element of
5802 type cv U, where U is T or a class derived from T, the object is
5803 initialized from that element." Even if T is an aggregate. */
5804 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5805 && first_initializer_p
5806 && d
->end
- d
->cur
== 1
5807 && reference_related_p (type
, TREE_TYPE (init
)))
5815 All implicit type conversions (clause _conv_) are considered when
5816 initializing the aggregate member with an initializer from an
5817 initializer-list. If the initializer can initialize a member,
5818 the member is initialized. Otherwise, if the member is itself a
5819 non-empty subaggregate, brace elision is assumed and the
5820 initializer is considered for the initialization of the first
5821 member of the subaggregate. */
5822 if (TREE_CODE (init
) != CONSTRUCTOR
5823 /* But don't try this for the first initializer, since that would be
5824 looking through the outermost braces; A a2 = { a1 }; is not a
5825 valid aggregate initialization. */
5826 && !first_initializer_p
5827 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5828 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5835 /* [dcl.init.string]
5837 A char array (whether plain char, signed char, or unsigned char)
5838 can be initialized by a string-literal (optionally enclosed in
5839 braces); a wchar_t array can be initialized by a wide
5840 string-literal (optionally enclosed in braces). */
5841 if (TREE_CODE (type
) == ARRAY_TYPE
5842 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5844 tree str_init
= init
;
5846 /* Strip one level of braces if and only if they enclose a single
5847 element (as allowed by [dcl.init.string]). */
5848 if (!first_initializer_p
5849 && TREE_CODE (str_init
) == CONSTRUCTOR
5850 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5852 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5855 /* If it's a string literal, then it's the initializer for the array
5856 as a whole. Otherwise, continue with normal initialization for
5857 array types (one value per array element). */
5858 if (TREE_CODE (str_init
) == STRING_CST
)
5860 if (has_designator_problem (d
, complain
))
5861 return error_mark_node
;
5867 /* The following cases are about aggregates. If we are not within a full
5868 initializer already, and there is not a CONSTRUCTOR, it means that there
5869 is a missing set of braces (that is, we are processing the case for
5870 which reshape_init exists). */
5871 if (!first_initializer_p
)
5873 if (TREE_CODE (init
) == CONSTRUCTOR
)
5875 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5876 /* There is no need to reshape pointer-to-member function
5877 initializers, as they are always constructed correctly
5878 by the front end. */
5880 else if (COMPOUND_LITERAL_P (init
))
5881 /* For a nested compound literal, there is no need to reshape since
5882 brace elision is not allowed. Even if we decided to allow it,
5883 we should add a call to reshape_init in finish_compound_literal,
5884 before calling digest_init, so changing this code would still
5885 not be necessary. */
5886 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5890 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5891 return reshape_init (type
, init
, complain
);
5895 if (variably_modified_type_p (type
, NULL_TREE
))
5897 /* Require VLAs to have their initializers fully braced
5898 to avoid initializing the wrong elements. */
5899 if (complain
& tf_error
)
5900 error ("missing braces around initializer for a variable length "
5902 return error_mark_node
;
5905 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5909 /* Dispatch to specialized routines. */
5910 if (CLASS_TYPE_P (type
))
5911 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5912 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5913 return reshape_init_array (type
, d
, complain
);
5914 else if (VECTOR_TYPE_P (type
))
5915 return reshape_init_vector (type
, d
, complain
);
5920 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5921 brace-enclosed aggregate initializer.
5923 INIT is the CONSTRUCTOR containing the list of initializers describing
5924 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5925 It may not presently match the shape of the TYPE; for example:
5927 struct S { int a; int b; };
5928 struct S a[] = { 1, 2, 3, 4 };
5930 Here INIT will hold a vector of four elements, rather than a
5931 vector of two elements, each itself a vector of two elements. This
5932 routine transforms INIT from the former form into the latter. The
5933 revised CONSTRUCTOR node is returned. */
5936 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5938 vec
<constructor_elt
, va_gc
> *v
;
5942 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5944 v
= CONSTRUCTOR_ELTS (init
);
5946 /* An empty constructor does not need reshaping, and it is always a valid
5948 if (vec_safe_is_empty (v
))
5951 /* Recurse on this CONSTRUCTOR. */
5953 d
.end
= d
.cur
+ v
->length ();
5955 new_init
= reshape_init_r (type
, &d
, true, complain
);
5956 if (new_init
== error_mark_node
)
5957 return error_mark_node
;
5959 /* Make sure all the element of the constructor were used. Otherwise,
5960 issue an error about exceeding initializers. */
5963 if (complain
& tf_error
)
5964 error ("too many initializers for %qT", type
);
5966 return error_mark_node
;
5972 /* Verify array initializer. Returns true if errors have been reported. */
5975 check_array_initializer (tree decl
, tree type
, tree init
)
5977 tree element_type
= TREE_TYPE (type
);
5979 /* The array type itself need not be complete, because the
5980 initializer may tell us how many elements are in the array.
5981 But, the elements of the array must be complete. */
5982 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5985 error ("elements of array %q#D have incomplete type", decl
);
5987 error ("elements of array %q#T have incomplete type", type
);
5990 /* A compound literal can't have variable size. */
5992 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5993 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5995 error ("variable-sized compound literal");
6001 /* Subroutine of check_initializer; args are passed down from that function.
6002 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6005 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
6008 gcc_assert (stmts_are_full_exprs_p ());
6009 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
6012 /* Verify INIT (the initializer for DECL), and record the
6013 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6014 grok_reference_init.
6016 If the return value is non-NULL, it is an expression that must be
6017 evaluated dynamically to initialize DECL. */
6020 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
6022 tree type
= TREE_TYPE (decl
);
6023 tree init_code
= NULL
;
6026 /* Things that are going to be initialized need to have complete
6028 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
6030 if (DECL_HAS_VALUE_EXPR_P (decl
))
6032 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6033 it doesn't have storage to be initialized. */
6034 gcc_assert (init
== NULL_TREE
);
6038 if (type
== error_mark_node
)
6039 /* We will have already complained. */
6042 if (TREE_CODE (type
) == ARRAY_TYPE
)
6044 if (check_array_initializer (decl
, type
, init
))
6047 else if (!COMPLETE_TYPE_P (type
))
6049 error ("%q#D has incomplete type", decl
);
6050 TREE_TYPE (decl
) = error_mark_node
;
6054 /* There is no way to make a variable-sized class type in GNU C++. */
6055 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6057 /* Initializer exression used to check invalid VLA bounds and excess
6058 initializer elements. */
6059 tree saved_init_for_vla_check
= NULL_TREE
;
6061 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6063 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
6064 if (SCALAR_TYPE_P (type
))
6068 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6069 init
= build_zero_init (type
, NULL_TREE
, false);
6071 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6073 error ("scalar object %qD requires one element in initializer",
6075 TREE_TYPE (decl
) = error_mark_node
;
6081 if (TREE_CODE (decl
) == CONST_DECL
)
6083 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
6085 DECL_INITIAL (decl
) = init
;
6087 gcc_assert (init
!= NULL_TREE
);
6090 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6092 else if (init
|| type_build_ctor_call (type
)
6093 || TREE_CODE (type
) == REFERENCE_TYPE
)
6095 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6097 init
= grok_reference_init (decl
, type
, init
, flags
);
6098 flags
|= LOOKUP_ALREADY_DIGESTED
;
6101 check_for_uninitialized_const_var (decl
);
6102 /* Do not reshape constructors of vectors (they don't need to be
6104 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6106 if (is_std_init_list (type
))
6108 init
= perform_implicit_conversion (type
, init
,
6109 tf_warning_or_error
);
6110 flags
|= LOOKUP_ALREADY_DIGESTED
;
6112 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6114 /* Don't reshape if the class has constructors. */
6115 if (cxx_dialect
== cxx98
)
6116 error ("in C++98 %qD must be initialized by constructor, "
6120 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6122 error ("opaque vector types cannot be initialized");
6123 init
= error_mark_node
;
6127 init
= reshape_init (type
, init
, tf_warning_or_error
);
6128 flags
|= LOOKUP_NO_NARROWING
;
6131 else if (TREE_CODE (init
) == TREE_LIST
6132 && TREE_TYPE (init
) != unknown_type_node
6133 && !MAYBE_CLASS_TYPE_P (type
))
6135 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6137 /* We get here with code like `int a (2);' */
6138 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6139 tf_warning_or_error
);
6142 /* If DECL has an array type without a specific bound, deduce the
6143 array size from the initializer. */
6144 maybe_deduce_size_from_array_init (decl
, init
);
6145 type
= TREE_TYPE (decl
);
6146 if (type
== error_mark_node
)
6149 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6150 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6151 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6152 && CP_AGGREGATE_TYPE_P (type
)
6153 && (CLASS_TYPE_P (type
)
6154 || !TYPE_NEEDS_CONSTRUCTING (type
)
6155 || type_has_extended_temps (type
))))
6157 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6159 /* A constructor call is a non-trivial initializer even if
6160 it isn't explicitly written. */
6161 if (TREE_SIDE_EFFECTS (init_code
))
6162 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6164 /* If this is a constexpr initializer, expand_default_init will
6165 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6166 case, pull the initializer back out and pass it down into
6167 store_init_value. */
6168 while (TREE_CODE (init_code
) == EXPR_STMT
6169 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6170 init_code
= TREE_OPERAND (init_code
, 0);
6171 if (TREE_CODE (init_code
) == INIT_EXPR
)
6173 init
= TREE_OPERAND (init_code
, 1);
6174 init_code
= NULL_TREE
;
6175 /* Don't call digest_init; it's unnecessary and will complain
6176 about aggregate initialization of non-aggregate classes. */
6177 flags
|= LOOKUP_ALREADY_DIGESTED
;
6179 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6181 /* Declared constexpr, but no suitable initializer; massage
6182 init appropriately so we can pass it into store_init_value
6184 if (CLASS_TYPE_P (type
)
6185 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6187 init
= build_functional_cast (type
, init
, tf_none
);
6188 if (TREE_CODE (init
) == TARGET_EXPR
)
6189 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6191 init_code
= NULL_TREE
;
6197 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6199 /* In aggregate initialization of a variable, each element
6200 initialization is a full-expression because there is no
6201 enclosing expression. */
6202 gcc_assert (stmts_are_full_exprs_p ());
6204 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6206 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6207 && DECL_INITIAL (decl
)
6208 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6209 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6210 warning (0, "array %qD initialized by parenthesized string literal %qE",
6211 decl
, DECL_INITIAL (decl
));
6213 saved_init_for_vla_check
= init
;
6219 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6220 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6221 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6222 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6225 check_for_uninitialized_const_var (decl
);
6228 if (TREE_CODE (type
) == ARRAY_TYPE
6229 && variably_modified_type_p (type
, NULL_TREE
)
6230 && !processing_template_decl
)
6232 /* Statically check for overflow in VLA bounds and build
6233 an expression that checks at runtime whether the VLA
6234 is erroneous due to invalid (runtime) bounds.
6235 Another expression to check for excess initializers
6236 is built in build_vec_init. */
6237 tree check
= build_vla_check (TREE_TYPE (decl
), saved_init_for_vla_check
);
6239 if (flag_exceptions
&& current_function_decl
6240 /* Avoid instrumenting constexpr functions for now.
6241 Those must be checked statically, and the (non-
6242 constexpr) dynamic instrumentation would cause
6243 them to be rejected. See c++/70507. */
6244 && !DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
6246 /* Use the runtime check only when exceptions are enabled.
6247 Otherwise let bad things happen... */
6248 check
= build3 (COND_EXPR
, void_type_node
, check
,
6249 throw_bad_array_length (), void_node
);
6251 finish_expr_stmt (check
);
6255 if (init
&& init
!= error_mark_node
)
6256 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6260 /* We might have set these in cp_finish_decl. */
6261 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6262 TREE_CONSTANT (decl
) = false;
6265 if (init_code
&& DECL_IN_AGGR_P (decl
))
6267 static int explained
= 0;
6269 if (cxx_dialect
< cxx11
)
6270 error ("initializer invalid for static member with constructor");
6272 error ("non-constant in-class initialization invalid for static "
6273 "member %qD", decl
);
6276 inform (input_location
,
6277 "(an out of class initialization is required)");
6286 /* If DECL is not a local variable, give it RTL. */
6289 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6291 int toplev
= toplevel_bindings_p ();
6294 /* Set the DECL_ASSEMBLER_NAME for the object. */
6297 /* The `register' keyword, when used together with an
6298 asm-specification, indicates that the variable should be
6299 placed in a particular register. */
6300 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6302 set_user_assembler_name (decl
, asmspec
);
6303 DECL_HARD_REGISTER (decl
) = 1;
6307 if (TREE_CODE (decl
) == FUNCTION_DECL
6308 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6309 set_builtin_user_assembler_name (decl
, asmspec
);
6310 set_user_assembler_name (decl
, asmspec
);
6314 /* Handle non-variables up front. */
6317 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6321 /* If we see a class member here, it should be a static data
6323 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6325 gcc_assert (TREE_STATIC (decl
));
6326 /* An in-class declaration of a static data member should be
6327 external; it is only a declaration, and not a definition. */
6328 if (init
== NULL_TREE
)
6329 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
6332 /* We don't create any RTL for local variables. */
6333 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6336 /* We defer emission of local statics until the corresponding
6337 DECL_EXPR is expanded. But with constexpr its function might never
6338 be expanded, so go ahead and tell cgraph about the variable now. */
6339 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6340 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (decl
)))
6341 || DECL_VIRTUAL_P (decl
));
6343 /* Defer template instantiations. */
6344 if (DECL_LANG_SPECIFIC (decl
)
6345 && DECL_IMPLICIT_INSTANTIATION (decl
))
6348 /* If we're not deferring, go ahead and assemble the variable. */
6350 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6353 /* walk_tree helper for wrap_temporary_cleanups, below. */
6356 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6358 /* Stop at types or full-expression boundaries. */
6359 if (TYPE_P (*stmt_p
)
6360 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6366 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6368 tree guard
= (tree
)data
;
6369 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6371 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6372 /* Tell honor_protect_cleanup_actions to handle this as a separate
6374 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6376 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6382 /* We're initializing a local variable which has a cleanup GUARD. If there
6383 are any temporaries used in the initializer INIT of this variable, we
6384 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6385 variable will be cleaned up properly if one of them throws.
6387 Unfortunately, there's no way to express this properly in terms of
6388 nesting, as the regions for the temporaries overlap the region for the
6389 variable itself; if there are two temporaries, the variable needs to be
6390 the first thing destroyed if either of them throws. However, we only
6391 want to run the variable's cleanup if it actually got constructed. So
6392 we need to guard the temporary cleanups with the variable's cleanup if
6393 they are run on the normal path, but not if they are run on the
6394 exceptional path. We implement this by telling
6395 honor_protect_cleanup_actions to strip the variable cleanup from the
6396 exceptional path. */
6399 wrap_temporary_cleanups (tree init
, tree guard
)
6401 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6404 /* Generate code to initialize DECL (a local variable). */
6407 initialize_local_var (tree decl
, tree init
)
6409 tree type
= TREE_TYPE (decl
);
6413 gcc_assert (VAR_P (decl
)
6414 || TREE_CODE (decl
) == RESULT_DECL
);
6415 gcc_assert (!TREE_STATIC (decl
));
6417 if (DECL_SIZE (decl
) == NULL_TREE
)
6419 /* If we used it already as memory, it must stay in memory. */
6420 DECL_INITIAL (decl
) = NULL_TREE
;
6421 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6425 if (type
== error_mark_node
)
6428 /* Compute and store the initial value. */
6429 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6430 if (TREE_USED (type
))
6431 DECL_READ_P (decl
) = 1;
6433 /* Generate a cleanup, if necessary. */
6434 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6436 /* Perform the initialization. */
6439 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6440 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6441 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6443 /* Stick simple initializers in DECL_INITIAL so that
6444 -Wno-init-self works (c++/34772). */
6445 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6446 DECL_INITIAL (decl
) = rinit
;
6448 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6452 warning_at (DECL_SOURCE_LOCATION (decl
),
6454 "reference %qD is initialized with itself", decl
);
6459 int saved_stmts_are_full_exprs_p
;
6461 /* If we're only initializing a single object, guard the
6462 destructors of any temporaries used in its initializer with
6463 its destructor. This isn't right for arrays because each
6464 element initialization is a full-expression. */
6465 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6466 wrap_temporary_cleanups (init
, cleanup
);
6468 gcc_assert (building_stmt_list_p ());
6469 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6470 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6471 finish_expr_stmt (init
);
6472 current_stmt_tree ()->stmts_are_full_exprs_p
=
6473 saved_stmts_are_full_exprs_p
;
6477 /* Set this to 0 so we can tell whether an aggregate which was
6478 initialized was ever used. Don't do this if it has a
6479 destructor, so we don't complain about the 'resource
6480 allocation is initialization' idiom. Now set
6481 attribute((unused)) on types so decls of that type will be
6482 marked used. (see TREE_USED, above.) */
6483 if (TYPE_NEEDS_CONSTRUCTING (type
)
6485 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6486 && DECL_NAME (decl
))
6487 TREE_USED (decl
) = 0;
6488 else if (already_used
)
6489 TREE_USED (decl
) = 1;
6492 finish_decl_cleanup (decl
, cleanup
);
6495 /* DECL is a VAR_DECL for a compiler-generated variable with static
6496 storage duration (like a virtual table) whose initializer is a
6497 compile-time constant. Initialize the variable and provide it to the
6501 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6504 gcc_assert (DECL_ARTIFICIAL (decl
));
6505 init
= build_constructor (TREE_TYPE (decl
), v
);
6506 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6507 DECL_INITIAL (decl
) = init
;
6508 DECL_INITIALIZED_P (decl
) = 1;
6509 determine_visibility (decl
);
6510 layout_var_decl (decl
);
6511 maybe_commonize_var (decl
);
6512 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6515 /* INIT is the initializer for a variable, as represented by the
6516 parser. Returns true iff INIT is type-dependent. */
6519 type_dependent_init_p (tree init
)
6521 if (TREE_CODE (init
) == TREE_LIST
)
6522 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6523 return any_type_dependent_elements_p (init
);
6524 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6525 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6527 vec
<constructor_elt
, va_gc
> *elts
;
6531 elts
= CONSTRUCTOR_ELTS (init
);
6532 nelts
= vec_safe_length (elts
);
6533 for (i
= 0; i
< nelts
; ++i
)
6534 if (type_dependent_init_p ((*elts
)[i
].value
))
6538 /* It must be a simple expression, e.g., int i = 3; */
6539 return type_dependent_expression_p (init
);
6544 /* INIT is the initializer for a variable, as represented by the
6545 parser. Returns true iff INIT is value-dependent. */
6548 value_dependent_init_p (tree init
)
6550 if (TREE_CODE (init
) == TREE_LIST
)
6551 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6552 return any_value_dependent_elements_p (init
);
6553 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6554 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6556 vec
<constructor_elt
, va_gc
> *elts
;
6560 elts
= CONSTRUCTOR_ELTS (init
);
6561 nelts
= vec_safe_length (elts
);
6562 for (i
= 0; i
< nelts
; ++i
)
6563 if (value_dependent_init_p ((*elts
)[i
].value
))
6567 /* It must be a simple expression, e.g., int i = 3; */
6568 return value_dependent_expression_p (init
);
6573 // Returns true if a DECL is VAR_DECL with the concept specifier.
6575 is_concept_var (tree decl
)
6577 return (VAR_P (decl
)
6578 // Not all variables have DECL_LANG_SPECIFIC.
6579 && DECL_LANG_SPECIFIC (decl
)
6580 && DECL_DECLARED_CONCEPT_P (decl
));
6583 /* A helper function to be called via walk_tree. If any label exists
6584 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6587 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6591 if (TREE_CODE (*tp
) == LABEL_DECL
)
6592 cfun
->has_forced_label_in_static
= 1;
6596 /* Finish processing of a declaration;
6597 install its line number and initial value.
6598 If the length of an array type is not known before,
6599 it must be determined now, from the initial value, or it is an error.
6601 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6602 true, then INIT is an integral constant expression.
6604 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6605 if the (init) syntax was used. */
6608 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6609 tree asmspec_tree
, int flags
)
6612 vec
<tree
, va_gc
> *cleanups
= NULL
;
6613 const char *asmspec
= NULL
;
6614 int was_readonly
= 0;
6615 bool var_definition_p
= false;
6618 if (decl
== error_mark_node
)
6623 error ("assignment (not initialization) in declaration");
6627 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6628 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6629 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6631 type
= TREE_TYPE (decl
);
6632 if (type
== error_mark_node
)
6635 /* If a name was specified, get the string. */
6636 if (at_namespace_scope_p ())
6637 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6638 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6639 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6641 if (current_class_type
6642 && CP_DECL_CONTEXT (decl
) == current_class_type
6643 && TYPE_BEING_DEFINED (current_class_type
)
6644 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6645 && (DECL_INITIAL (decl
) || init
))
6646 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6648 if (TREE_CODE (decl
) != FUNCTION_DECL
6649 && (auto_node
= type_uses_auto (type
)))
6652 if (init
== NULL_TREE
)
6654 if (DECL_LANG_SPECIFIC (decl
)
6655 && DECL_TEMPLATE_INSTANTIATION (decl
)
6656 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6658 /* init is null because we're deferring instantiating the
6659 initializer until we need it. Well, we need it now. */
6660 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6664 error ("declaration of %q#D has no initializer", decl
);
6665 TREE_TYPE (decl
) = error_mark_node
;
6669 if (TREE_CODE (d_init
) == TREE_LIST
)
6670 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6671 tf_warning_or_error
);
6672 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
6673 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6675 tf_warning_or_error
,
6677 if (type
== error_mark_node
)
6679 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6682 if (!ensure_literal_type_for_constexpr_object (decl
))
6683 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6686 && DECL_CLASS_SCOPE_P (decl
)
6687 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6688 check_static_variable_definition (decl
, type
);
6690 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6693 if (init
== ridpointers
[(int)RID_DELETE
])
6695 /* FIXME check this is 1st decl. */
6696 DECL_DELETED_FN (decl
) = 1;
6697 DECL_DECLARED_INLINE_P (decl
) = 1;
6698 DECL_INITIAL (decl
) = error_mark_node
;
6699 FOR_EACH_CLONE (clone
, decl
)
6701 DECL_DELETED_FN (clone
) = 1;
6702 DECL_DECLARED_INLINE_P (clone
) = 1;
6703 DECL_INITIAL (clone
) = error_mark_node
;
6707 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6709 if (defaultable_fn_check (decl
))
6710 DECL_DEFAULTED_FN (decl
) = 1;
6712 DECL_INITIAL (decl
) = NULL_TREE
;
6716 if (init
&& VAR_P (decl
))
6718 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6719 /* If DECL is a reference, then we want to know whether init is a
6720 reference constant; init_const_expr_p as passed tells us whether
6721 it's an rvalue constant. */
6722 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6723 init_const_expr_p
= potential_constant_expression (init
);
6724 if (init_const_expr_p
)
6726 /* Set these flags now for templates. We'll update the flags in
6727 store_init_value for instantiations. */
6728 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6729 if (decl_maybe_constant_var_p (decl
))
6730 TREE_CONSTANT (decl
) = 1;
6734 if (processing_template_decl
)
6736 bool type_dependent_p
;
6738 /* Add this declaration to the statement-tree. */
6739 if (at_function_scope_p ())
6740 add_decl_expr (decl
);
6742 type_dependent_p
= dependent_type_p (type
);
6744 if (check_for_bare_parameter_packs (init
))
6747 DECL_INITIAL (decl
) = NULL_TREE
;
6750 /* Generally, initializers in templates are expanded when the
6751 template is instantiated. But, if DECL is a variable constant
6752 then it can be used in future constant expressions, so its value
6753 must be available. */
6755 if (!VAR_P (decl
) || type_dependent_p
)
6756 /* We can't do anything if the decl has dependent type. */;
6758 && init_const_expr_p
6759 && TREE_CODE (type
) != REFERENCE_TYPE
6760 && decl_maybe_constant_var_p (decl
)
6761 && !type_dependent_init_p (init
)
6762 && !value_dependent_init_p (init
))
6764 /* This variable seems to be a non-dependent constant, so process
6765 its initializer. If check_initializer returns non-null the
6766 initialization wasn't constant after all. */
6768 cleanups
= make_tree_vector ();
6769 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6770 if (init_code
== NULL_TREE
)
6772 release_tree_vector (cleanups
);
6774 else if (!init
&& is_concept_var (decl
))
6775 error ("variable concept has no initializer");
6776 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6778 /* Deduce array size even if the initializer is dependent. */
6779 maybe_deduce_size_from_array_init (decl
, init
);
6780 /* And complain about multiple initializers. */
6781 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6782 && !MAYBE_CLASS_TYPE_P (type
))
6783 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6784 tf_warning_or_error
);
6788 DECL_INITIAL (decl
) = init
;
6792 /* Just store non-static data member initializers for later. */
6793 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6794 DECL_INITIAL (decl
) = init
;
6796 /* Take care of TYPE_DECLs up front. */
6797 if (TREE_CODE (decl
) == TYPE_DECL
)
6799 if (type
!= error_mark_node
6800 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6802 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6803 warning (0, "shadowing previous type declaration of %q#D", decl
);
6804 set_identifier_type_value (DECL_NAME (decl
), decl
);
6807 /* If we have installed this as the canonical typedef for this
6808 type, and that type has not been defined yet, delay emitting
6809 the debug information for it, as we will emit it later. */
6810 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6811 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6812 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6814 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6819 /* A reference will be modified here, as it is initialized. */
6820 if (! DECL_EXTERNAL (decl
)
6821 && TREE_READONLY (decl
)
6822 && TREE_CODE (type
) == REFERENCE_TYPE
)
6825 TREE_READONLY (decl
) = 0;
6830 /* If this is a local variable that will need a mangled name,
6831 register it now. We must do this before processing the
6832 initializer for the variable, since the initialization might
6833 require a guard variable, and since the mangled name of the
6834 guard variable will depend on the mangled name of this
6836 if (DECL_FUNCTION_SCOPE_P (decl
)
6837 && TREE_STATIC (decl
)
6838 && !DECL_ARTIFICIAL (decl
))
6840 push_local_name (decl
);
6841 /* Normally has_forced_label_in_static is set during GIMPLE
6842 lowering, but [cd]tors are never actually compiled directly.
6843 We need to set this early so we can deal with the label
6844 address extension. */
6845 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
6846 || DECL_DESTRUCTOR_P (current_function_decl
))
6849 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
6850 add_local_decl (cfun
, decl
);
6852 /* And make sure it's in the symbol table for
6853 c_parse_final_cleanups to find. */
6854 varpool_node::get_create (decl
);
6857 /* Convert the initializer to the type of DECL, if we have not
6858 already initialized DECL. */
6859 if (!DECL_INITIALIZED_P (decl
)
6860 /* If !DECL_EXTERNAL then DECL is being defined. In the
6861 case of a static data member initialized inside the
6862 class-specifier, there can be an initializer even if DECL
6863 is *not* defined. */
6864 && (!DECL_EXTERNAL (decl
) || init
))
6866 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6869 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6870 /* Allow libjava/prims.cc define primitive classes. */
6871 if (init
!= NULL_TREE
6872 || jclass
== NULL_TREE
6873 || TREE_CODE (jclass
) != TYPE_DECL
6874 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6875 || !same_type_ignoring_top_level_qualifiers_p
6876 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6877 error ("Java object %qD not allocated with %<new%>", decl
);
6880 cleanups
= make_tree_vector ();
6881 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6887 The memory occupied by any object of static storage
6888 duration is zero-initialized at program startup before
6889 any other initialization takes place.
6891 We cannot create an appropriate initializer until after
6892 the type of DECL is finalized. If DECL_INITIAL is set,
6893 then the DECL is statically initialized, and any
6894 necessary zero-initialization has already been performed. */
6895 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6896 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6897 /*nelts=*/NULL_TREE
,
6898 /*static_storage_p=*/true);
6899 /* Remember that the initialization for this variable has
6901 DECL_INITIALIZED_P (decl
) = 1;
6902 /* This declaration is the definition of this variable,
6903 unless we are initializing a static data member within
6904 the class specifier. */
6905 if (!DECL_EXTERNAL (decl
))
6906 var_definition_p
= true;
6908 /* If the variable has an array type, lay out the type, even if
6909 there is no initializer. It is valid to index through the
6910 array, and we must get TYPE_ALIGN set correctly on the array
6912 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6915 if (TREE_STATIC (decl
)
6916 && !at_function_scope_p ()
6917 && current_function_decl
== NULL
)
6918 /* So decl is a global variable or a static member of a
6919 non local class. Record the types it uses
6920 so that we can decide later to emit debug info for them. */
6921 record_types_used_by_current_var_decl (decl
);
6923 else if (TREE_CODE (decl
) == FIELD_DECL
6924 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6925 error ("non-static data member %qD has Java class type", decl
);
6927 /* Add this declaration to the statement-tree. This needs to happen
6928 after the call to check_initializer so that the DECL_EXPR for a
6929 reference temp is added before the DECL_EXPR for the reference itself. */
6930 if (DECL_FUNCTION_SCOPE_P (decl
))
6932 /* If we're building a variable sized type, and we might be
6933 reachable other than via the top of the current binding
6934 level, then create a new BIND_EXPR so that we deallocate
6935 the object at the right time. */
6938 && !TREE_CONSTANT (DECL_SIZE (decl
))
6939 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
6942 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6943 TREE_SIDE_EFFECTS (bind
) = 1;
6945 BIND_EXPR_BODY (bind
) = push_stmt_list ();
6947 add_decl_expr (decl
);
6950 /* Let the middle end know about variables and functions -- but not
6951 static data members in uninstantiated class templates. */
6952 if (VAR_OR_FUNCTION_DECL_P (decl
))
6956 layout_var_decl (decl
);
6957 maybe_commonize_var (decl
);
6960 /* This needs to happen after the linkage is set. */
6961 determine_visibility (decl
);
6963 if (var_definition_p
&& TREE_STATIC (decl
))
6965 /* If a TREE_READONLY variable needs initialization
6966 at runtime, it is no longer readonly and we need to
6967 avoid MEM_READONLY_P being set on RTL created for it. */
6970 if (TREE_READONLY (decl
))
6971 TREE_READONLY (decl
) = 0;
6974 else if (was_readonly
)
6975 TREE_READONLY (decl
) = 1;
6977 /* Likewise if it needs destruction. */
6978 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6979 TREE_READONLY (decl
) = 0;
6982 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6984 /* Check for abstractness of the type. Notice that there is no
6985 need to strip array types here since the check for those types
6986 is already done within create_array_type_for_decl. */
6987 abstract_virtuals_error (decl
, type
);
6989 if (TREE_TYPE (decl
) == error_mark_node
)
6990 /* No initialization required. */
6992 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6996 if (init
== ridpointers
[(int)RID_DEFAULT
])
6998 /* An out-of-class default definition is defined at
6999 the point where it is explicitly defaulted. */
7000 if (DECL_DELETED_FN (decl
))
7001 maybe_explain_implicit_delete (decl
);
7002 else if (DECL_INITIAL (decl
) == error_mark_node
)
7003 synthesize_method (decl
);
7006 error ("function %q#D is initialized like a variable", decl
);
7008 /* else no initialization required. */
7010 else if (DECL_EXTERNAL (decl
)
7011 && ! (DECL_LANG_SPECIFIC (decl
)
7012 && DECL_NOT_REALLY_EXTERN (decl
)))
7015 DECL_INITIAL (decl
) = init
;
7017 /* A variable definition. */
7018 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
7019 /* Initialize the local variable. */
7020 initialize_local_var (decl
, init
);
7022 /* If a variable is defined, and then a subsequent
7023 definition with external linkage is encountered, we will
7024 get here twice for the same variable. We want to avoid
7025 calling expand_static_init more than once. For variables
7026 that are not static data members, we can call
7027 expand_static_init only when we actually process the
7028 initializer. It is not legal to redeclare a static data
7029 member, so this issue does not arise in that case. */
7030 else if (var_definition_p
&& TREE_STATIC (decl
))
7031 expand_static_init (decl
, init
);
7034 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7035 reference, insert it in the statement-tree now. */
7039 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
7040 push_cleanup (decl
, t
, false);
7041 release_tree_vector (cleanups
);
7045 TREE_READONLY (decl
) = 1;
7047 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7050 /* Returns a declaration for a VAR_DECL as if:
7052 extern "C" TYPE NAME;
7054 had been seen. Used to create compiler-generated global
7058 declare_global_var (tree name
, tree type
)
7062 push_to_top_level ();
7063 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7064 TREE_PUBLIC (decl
) = 1;
7065 DECL_EXTERNAL (decl
) = 1;
7066 DECL_ARTIFICIAL (decl
) = 1;
7067 /* If the user has explicitly declared this variable (perhaps
7068 because the code we are compiling is part of a low-level runtime
7069 library), then it is possible that our declaration will be merged
7070 with theirs by pushdecl. */
7071 decl
= pushdecl (decl
);
7072 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7073 pop_from_top_level ();
7078 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7079 if "__cxa_atexit" is not being used) corresponding to the function
7080 to be called when the program exits. */
7083 get_atexit_fn_ptr_type (void)
7087 if (!atexit_fn_ptr_type_node
)
7090 if (flag_use_cxa_atexit
7091 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7092 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7093 arg_type
= ptr_type_node
;
7095 /* The parameter to "atexit" is "void (*)(void)". */
7096 arg_type
= NULL_TREE
;
7098 fn_type
= build_function_type_list (void_type_node
,
7099 arg_type
, NULL_TREE
);
7100 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
7103 return atexit_fn_ptr_type_node
;
7106 /* Returns a pointer to the `atexit' function. Note that if
7107 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7108 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7111 get_atexit_node (void)
7117 bool use_aeabi_atexit
;
7122 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7124 /* The declaration for `__cxa_atexit' is:
7126 int __cxa_atexit (void (*)(void *), void *, void *)
7128 We build up the argument types and then the function type
7130 tree argtype0
, argtype1
, argtype2
;
7132 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
7133 /* First, build the pointer-to-function type for the first
7135 fn_ptr_type
= get_atexit_fn_ptr_type ();
7136 /* Then, build the rest of the argument types. */
7137 argtype2
= ptr_type_node
;
7138 if (use_aeabi_atexit
)
7140 argtype1
= fn_ptr_type
;
7141 argtype0
= ptr_type_node
;
7145 argtype1
= ptr_type_node
;
7146 argtype0
= fn_ptr_type
;
7148 /* And the final __cxa_atexit type. */
7149 fn_type
= build_function_type_list (integer_type_node
,
7150 argtype0
, argtype1
, argtype2
,
7152 if (use_aeabi_atexit
)
7153 name
= "__aeabi_atexit";
7155 name
= "__cxa_atexit";
7159 /* The declaration for `atexit' is:
7161 int atexit (void (*)());
7163 We build up the argument types and then the function type
7165 fn_ptr_type
= get_atexit_fn_ptr_type ();
7166 /* Build the final atexit type. */
7167 fn_type
= build_function_type_list (integer_type_node
,
7168 fn_ptr_type
, NULL_TREE
);
7172 /* Now, build the function declaration. */
7173 push_lang_context (lang_name_c
);
7174 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
7175 mark_used (atexit_fndecl
);
7176 pop_lang_context ();
7177 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7182 /* Like get_atexit_node, but for thread-local cleanups. */
7185 get_thread_atexit_node (void)
7187 /* The declaration for `__cxa_thread_atexit' is:
7189 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
7190 tree fn_type
= build_function_type_list (integer_type_node
,
7191 get_atexit_fn_ptr_type (),
7192 ptr_type_node
, ptr_type_node
,
7195 /* Now, build the function declaration. */
7196 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
7197 ECF_LEAF
| ECF_NOTHROW
);
7198 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7201 /* Returns the __dso_handle VAR_DECL. */
7204 get_dso_handle_node (void)
7206 if (dso_handle_node
)
7207 return dso_handle_node
;
7209 /* Declare the variable. */
7210 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
7213 #ifdef HAVE_GAS_HIDDEN
7214 if (dso_handle_node
!= error_mark_node
)
7216 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
7217 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
7221 return dso_handle_node
;
7224 /* Begin a new function with internal linkage whose job will be simply
7225 to destroy some particular variable. */
7227 static GTY(()) int start_cleanup_cnt
;
7230 start_cleanup_fn (void)
7235 bool use_cxa_atexit
= flag_use_cxa_atexit
7236 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
7238 push_to_top_level ();
7240 /* No need to mangle this. */
7241 push_lang_context (lang_name_c
);
7243 /* Build the name of the function. */
7244 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
7245 /* Build the function declaration. */
7246 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
7247 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
7248 /* It's a function with internal linkage, generated by the
7250 TREE_PUBLIC (fndecl
) = 0;
7251 DECL_ARTIFICIAL (fndecl
) = 1;
7252 /* Make the function `inline' so that it is only emitted if it is
7253 actually needed. It is unlikely that it will be inlined, since
7254 it is only called via a function pointer, but we avoid unnecessary
7255 emissions this way. */
7256 DECL_DECLARED_INLINE_P (fndecl
) = 1;
7257 DECL_INTERFACE_KNOWN (fndecl
) = 1;
7258 /* Build the parameter. */
7263 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
7264 DECL_CONTEXT (parmdecl
) = fndecl
;
7265 TREE_USED (parmdecl
) = 1;
7266 DECL_READ_P (parmdecl
) = 1;
7267 DECL_ARGUMENTS (fndecl
) = parmdecl
;
7271 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
7273 pop_lang_context ();
7275 return current_function_decl
;
7278 /* Finish the cleanup function begun by start_cleanup_fn. */
7281 end_cleanup_fn (void)
7283 expand_or_defer_fn (finish_function (0));
7285 pop_from_top_level ();
7288 /* Generate code to handle the destruction of DECL, an object with
7289 static storage duration. */
7292 register_dtor_fn (tree decl
)
7299 bool ob_parm
, dso_parm
, use_dtor
;
7300 tree arg0
, arg1
, arg2
;
7303 type
= TREE_TYPE (decl
);
7304 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7307 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7308 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7309 destructor to "__cxa_atexit"; we don't have to build a temporary
7310 function to do the cleanup. */
7311 dso_parm
= (flag_use_cxa_atexit
7312 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7313 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7314 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7319 /* Find the destructor. */
7320 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
7321 gcc_assert (idx
>= 0);
7322 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
7323 /* Make sure it is accessible. */
7324 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7325 tf_warning_or_error
);
7329 /* Call build_cleanup before we enter the anonymous function so
7330 that any access checks will be done relative to the current
7331 scope, rather than the scope of the anonymous function. */
7332 build_cleanup (decl
);
7334 /* Now start the function. */
7335 cleanup
= start_cleanup_fn ();
7337 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7338 to the original function, rather than the anonymous one. That
7339 will make the back end think that nested functions are in use,
7340 which causes confusion. */
7341 push_deferring_access_checks (dk_no_check
);
7342 fcall
= build_cleanup (decl
);
7343 pop_deferring_access_checks ();
7345 /* Create the body of the anonymous function. */
7346 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7347 finish_expr_stmt (fcall
);
7348 finish_compound_stmt (compound_stmt
);
7352 /* Call atexit with the cleanup function. */
7353 mark_used (cleanup
);
7354 cleanup
= build_address (cleanup
);
7356 if (CP_DECL_THREAD_LOCAL_P (decl
))
7357 atex_node
= get_thread_atexit_node ();
7359 atex_node
= get_atexit_node ();
7363 /* We must convert CLEANUP to the type that "__cxa_atexit"
7365 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7366 /* "__cxa_atexit" will pass the address of DECL to the
7367 cleanup function. */
7369 addr
= build_address (decl
);
7370 /* The declared type of the parameter to "__cxa_atexit" is
7371 "void *". For plain "T*", we could just let the
7372 machinery in cp_build_function_call convert it -- but if the
7373 type is "cv-qualified T *", then we need to convert it
7374 before passing it in, to avoid spurious errors. */
7375 addr
= build_nop (ptr_type_node
, addr
);
7378 /* Since the cleanup functions we build ignore the address
7379 they're given, there's no reason to pass the actual address
7380 in, and, in general, it's cheaper to pass NULL than any
7382 addr
= null_pointer_node
;
7385 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7386 tf_warning_or_error
);
7388 /* Just pass NULL to the dso handle parm if we don't actually
7389 have a DSO handle on this target. */
7390 arg2
= null_pointer_node
;
7396 if (!CP_DECL_THREAD_LOCAL_P (decl
)
7397 && targetm
.cxx
.use_aeabi_atexit ())
7413 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7414 arg0
, arg1
, arg2
, NULL_TREE
);
7417 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7418 is its initializer. Generate code to handle the construction
7419 and destruction of DECL. */
7422 expand_static_init (tree decl
, tree init
)
7424 gcc_assert (VAR_P (decl
));
7425 gcc_assert (TREE_STATIC (decl
));
7427 /* Some variables require no dynamic initialization. */
7428 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7430 /* Make sure the destructor is callable. */
7431 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7436 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7437 && !DECL_FUNCTION_SCOPE_P (decl
))
7440 error ("non-local variable %qD declared %<__thread%> "
7441 "needs dynamic initialization", decl
);
7443 error ("non-local variable %qD declared %<__thread%> "
7444 "has a non-trivial destructor", decl
);
7445 static bool informed
;
7448 inform (DECL_SOURCE_LOCATION (decl
),
7449 "C++11 %<thread_local%> allows dynamic initialization "
7456 if (DECL_FUNCTION_SCOPE_P (decl
))
7458 /* Emit code to perform this initialization but once. */
7459 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7460 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7461 tree guard
, guard_addr
;
7463 /* We don't need thread-safety code for thread-local vars. */
7464 bool thread_guard
= (flag_threadsafe_statics
7465 && !CP_DECL_THREAD_LOCAL_P (decl
));
7467 /* Emit code to perform this initialization but once. This code
7470 static <type> guard;
7471 if (!__atomic_load (guard.first_byte)) {
7472 if (__cxa_guard_acquire (&guard)) {
7475 // Do initialization.
7476 flag = true; __cxa_guard_release (&guard);
7477 // Register variable for destruction at end of program.
7479 if (!flag) __cxa_guard_abort (&guard);
7483 Note that the `flag' variable is only set to 1 *after* the
7484 initialization is complete. This ensures that an exception,
7485 thrown during the construction, will cause the variable to
7486 reinitialized when we pass through this code again, as per:
7490 If the initialization exits by throwing an exception, the
7491 initialization is not complete, so it will be tried again
7492 the next time control enters the declaration.
7494 This process should be thread-safe, too; multiple threads
7495 should not be able to initialize the variable more than
7498 /* Create the guard variable. */
7499 guard
= get_guard (decl
);
7501 /* Begin the conditional initialization. */
7502 if_stmt
= begin_if_stmt ();
7504 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
7505 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7509 tree vfntype
= NULL_TREE
;
7510 tree acquire_name
, release_name
, abort_name
;
7511 tree acquire_fn
, release_fn
, abort_fn
;
7512 guard_addr
= build_address (guard
);
7514 acquire_name
= get_identifier ("__cxa_guard_acquire");
7515 release_name
= get_identifier ("__cxa_guard_release");
7516 abort_name
= get_identifier ("__cxa_guard_abort");
7517 acquire_fn
= identifier_global_value (acquire_name
);
7518 release_fn
= identifier_global_value (release_name
);
7519 abort_fn
= identifier_global_value (abort_name
);
7521 acquire_fn
= push_library_fn
7522 (acquire_name
, build_function_type_list (integer_type_node
,
7523 TREE_TYPE (guard_addr
),
7525 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7526 if (!release_fn
|| !abort_fn
)
7527 vfntype
= build_function_type_list (void_type_node
,
7528 TREE_TYPE (guard_addr
),
7531 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7532 ECF_NOTHROW
| ECF_LEAF
);
7534 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7535 ECF_NOTHROW
| ECF_LEAF
);
7537 inner_if_stmt
= begin_if_stmt ();
7538 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7541 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7542 begin
= get_target_expr (boolean_false_node
);
7543 flag
= TARGET_EXPR_SLOT (begin
);
7545 TARGET_EXPR_CLEANUP (begin
)
7546 = build3 (COND_EXPR
, void_type_node
, flag
,
7548 build_call_n (abort_fn
, 1, guard_addr
));
7549 CLEANUP_EH_ONLY (begin
) = 1;
7551 /* Do the initialization itself. */
7552 init
= add_stmt_to_compound (begin
, init
);
7553 init
= add_stmt_to_compound
7554 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7555 init
= add_stmt_to_compound
7556 (init
, build_call_n (release_fn
, 1, guard_addr
));
7559 init
= add_stmt_to_compound (init
, set_guard (guard
));
7561 /* Use atexit to register a function for destroying this static
7563 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7565 finish_expr_stmt (init
);
7569 finish_compound_stmt (inner_then_clause
);
7570 finish_then_clause (inner_if_stmt
);
7571 finish_if_stmt (inner_if_stmt
);
7574 finish_compound_stmt (then_clause
);
7575 finish_then_clause (if_stmt
);
7576 finish_if_stmt (if_stmt
);
7578 else if (CP_DECL_THREAD_LOCAL_P (decl
))
7579 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7581 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7585 /* Make TYPE a complete type based on INITIAL_VALUE.
7586 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7587 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7588 3 if the initializer list is empty (in pedantic mode). */
7591 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7594 tree type
, elt_type
;
7596 /* Don't get confused by a CONSTRUCTOR for some other type. */
7597 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
7598 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
7599 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
7604 unsigned HOST_WIDE_INT i
;
7607 /* An array of character type can be initialized from a
7608 brace-enclosed string constant.
7610 FIXME: this code is duplicated from reshape_init. Probably
7611 we should just call reshape_init here? */
7612 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7613 && TREE_CODE (initial_value
) == CONSTRUCTOR
7614 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7616 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7617 tree value
= (*v
)[0].value
;
7619 if (TREE_CODE (value
) == STRING_CST
7620 && v
->length () == 1)
7621 initial_value
= value
;
7624 /* If any of the elements are parameter packs, we can't actually
7625 complete this type now because the array size is dependent. */
7626 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7628 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7631 if (PACK_EXPANSION_P (value
))
7637 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7639 /* We can create the array before the element type is complete, which
7640 means that we didn't have these two bits set in the original type
7641 either. In completing the type, we are expected to propagate these
7642 bits. See also complete_type which does the same thing for arrays
7645 if (TYPE_DOMAIN (type
))
7647 elt_type
= TREE_TYPE (type
);
7648 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7649 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7650 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7656 /* As above, but either give an error or reject zero-size arrays, depending
7660 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7661 bool do_default
, tsubst_flags_t complain
)
7664 bool sfinae
= !(complain
& tf_error
);
7665 /* In SFINAE context we can't be lenient about zero-size arrays. */
7668 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7674 /* Not an error. */;
7675 else if (failure
== 1)
7676 error ("initializer fails to determine size of %qT", *ptype
);
7677 else if (failure
== 2)
7680 error ("array size missing in %qT", *ptype
);
7682 else if (failure
== 3)
7683 error ("zero-size array %qT", *ptype
);
7684 *ptype
= error_mark_node
;
7689 /* Return zero if something is declared to be a member of type
7690 CTYPE when in the context of CUR_TYPE. STRING is the error
7691 message to print in that case. Otherwise, quietly return 1. */
7694 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7696 if (ctype
&& ctype
!= cur_type
)
7698 if (flags
== DTOR_FLAG
)
7699 error ("destructor for alien class %qT cannot be a member", ctype
);
7701 error ("constructor for alien class %qT cannot be a member", ctype
);
7707 /* Subroutine of `grokdeclarator'. */
7709 /* Generate errors possibly applicable for a given set of specifiers.
7710 This is for ARM $7.1.2. */
7713 bad_specifiers (tree object
,
7714 enum bad_spec_place type
,
7725 error ("%qD declared as a %<virtual%> variable", object
);
7727 error ("%qD declared as an %<inline%> variable", object
);
7729 error ("%<const%> and %<volatile%> function specifiers on "
7730 "%qD invalid in variable declaration", object
);
7734 error ("%qD declared as a %<virtual%> parameter", object
);
7736 error ("%qD declared as an %<inline%> parameter", object
);
7738 error ("%<const%> and %<volatile%> function specifiers on "
7739 "%qD invalid in parameter declaration", object
);
7743 error ("%qD declared as a %<virtual%> type", object
);
7745 error ("%qD declared as an %<inline%> type", object
);
7747 error ("%<const%> and %<volatile%> function specifiers on "
7748 "%qD invalid in type declaration", object
);
7752 error ("%qD declared as a %<virtual%> field", object
);
7754 error ("%qD declared as an %<inline%> field", object
);
7756 error ("%<const%> and %<volatile%> function specifiers on "
7757 "%qD invalid in field declaration", object
);
7763 error ("%q+D declared as a friend", object
);
7765 && (TREE_CODE (object
) == TYPE_DECL
7766 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7767 && !TYPE_REFFN_P (TREE_TYPE (object
))
7768 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7769 error ("%q+D declared with an exception specification", object
);
7772 /* DECL is a member function or static data member and is presently
7773 being defined. Check that the definition is taking place in a
7777 check_class_member_definition_namespace (tree decl
)
7779 /* These checks only apply to member functions and static data
7781 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7782 /* We check for problems with specializations in pt.c in
7783 check_specialization_namespace, where we can issue better
7785 if (processing_specialization
)
7787 /* There are no restrictions on the placement of
7788 explicit instantiations. */
7789 if (processing_explicit_instantiation
)
7793 A member function definition that appears outside of the
7794 class definition shall appear in a namespace scope enclosing
7795 the class definition.
7799 The definition for a static data member shall appear in a
7800 namespace scope enclosing the member's class definition. */
7801 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7802 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7803 decl
, DECL_CONTEXT (decl
));
7806 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7807 METHOD_TYPE for a non-static member function; QUALS are the
7808 cv-qualifiers that apply to the function. */
7811 build_this_parm (tree type
, cp_cv_quals quals
)
7816 cp_cv_quals this_quals
;
7818 if (CLASS_TYPE_P (type
))
7821 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7822 this_type
= build_pointer_type (this_type
);
7825 this_type
= type_of_this_parm (type
);
7826 /* The `this' parameter is implicitly `const'; it cannot be
7828 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7829 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7830 parm
= build_artificial_parm (this_identifier
, qual_type
);
7831 cp_apply_type_quals_to_decl (this_quals
, parm
);
7835 /* DECL is a static member function. Complain if it was declared
7836 with function-cv-quals. */
7839 check_static_quals (tree decl
, cp_cv_quals quals
)
7841 if (quals
!= TYPE_UNQUALIFIED
)
7842 error ("static member function %q#D declared with type qualifiers",
7846 // Check that FN takes no arguments and returns bool.
7848 check_concept_fn (tree fn
)
7850 // A constraint is nullary.
7851 if (DECL_ARGUMENTS (fn
))
7852 error ("concept %q#D declared with function parameters", fn
);
7854 // The declared return type of the concept shall be bool, and
7855 // it shall not be deduced from it definition.
7856 tree type
= TREE_TYPE (TREE_TYPE (fn
));
7858 error ("concept %q#D declared with a deduced return type", fn
);
7859 else if (type
!= boolean_type_node
)
7860 error ("concept %q#D with non-%<bool%> return type %qT", fn
, type
);
7863 /* Helper function. Replace the temporary this parameter injected
7864 during cp_finish_omp_declare_simd with the real this parameter. */
7867 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7869 tree this_parm
= (tree
) data
;
7870 if (TREE_CODE (*tp
) == PARM_DECL
7871 && DECL_NAME (*tp
) == this_identifier
7872 && *tp
!= this_parm
)
7874 else if (TYPE_P (*tp
))
7879 /* CTYPE is class type, or null if non-class.
7880 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7882 DECLARATOR is the function's name.
7883 PARMS is a chain of PARM_DECLs for the function.
7884 VIRTUALP is truthvalue of whether the function is virtual or not.
7885 FLAGS are to be passed through to `grokclassfn'.
7886 QUALS are qualifiers indicating whether the function is `const'
7888 RAISES is a list of exceptions that this function can raise.
7889 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7890 not look, and -1 if we should not call `grokclassfn' at all.
7892 SFK is the kind of special function (if any) for the new function.
7894 Returns `NULL_TREE' if something goes wrong, after issuing
7895 applicable error messages. */
7898 grokfndecl (tree ctype
,
7902 tree orig_declarator
,
7905 enum overload_flags flags
,
7907 cp_ref_qualifier rqual
,
7914 special_function_kind sfk
,
7919 location_t location
)
7922 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7925 // Was the concept specifier present?
7926 bool concept_p
= inlinep
& 4;
7928 // Concept declarations must have a corresponding definition.
7929 if (concept_p
&& !funcdef_flag
)
7931 error ("concept %qD has no definition", declarator
);
7936 type
= build_ref_qualified_type (type
, rqual
);
7938 type
= build_exception_variant (type
, raises
);
7940 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7942 /* Set the constraints on the declaration. */
7945 tree tmpl_reqs
= NULL_TREE
;
7946 if (processing_template_decl
> template_class_depth (ctype
))
7947 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
7949 /* Adjust the required expression into a constraint. */
7951 decl_reqs
= make_predicate_constraint (decl_reqs
);
7953 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
7954 set_constraints (decl
, ci
);
7957 /* If we have an explicit location, use it, otherwise use whatever
7958 build_lang_decl used (probably input_location). */
7959 if (location
!= UNKNOWN_LOCATION
)
7960 DECL_SOURCE_LOCATION (decl
) = location
;
7962 if (TREE_CODE (type
) == METHOD_TYPE
)
7965 parm
= build_this_parm (type
, quals
);
7966 DECL_CHAIN (parm
) = parms
;
7969 /* Allocate space to hold the vptr bit if needed. */
7970 DECL_ALIGN (decl
) = MINIMUM_METHOD_BOUNDARY
;
7972 DECL_ARGUMENTS (decl
) = parms
;
7973 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7974 DECL_CONTEXT (t
) = decl
;
7975 /* Propagate volatile out from type to decl. */
7976 if (TYPE_VOLATILE (type
))
7977 TREE_THIS_VOLATILE (decl
) = 1;
7979 /* Setup decl according to sfk. */
7982 case sfk_constructor
:
7983 case sfk_copy_constructor
:
7984 case sfk_move_constructor
:
7985 DECL_CONSTRUCTOR_P (decl
) = 1;
7987 case sfk_destructor
:
7988 DECL_DESTRUCTOR_P (decl
) = 1;
7995 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7999 ("defining explicit specialization %qD in friend declaration",
8003 tree fns
= TREE_OPERAND (orig_declarator
, 0);
8004 tree args
= TREE_OPERAND (orig_declarator
, 1);
8006 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8008 /* Something like `template <class T> friend void f<T>()'. */
8009 error ("invalid use of template-id %qD in declaration "
8010 "of primary template",
8016 /* A friend declaration of the form friend void f<>(). Record
8017 the information in the TEMPLATE_ID_EXPR. */
8018 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
8020 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
8021 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
8023 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
8024 if (TREE_PURPOSE (t
)
8025 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
8027 error ("default arguments are not allowed in declaration "
8028 "of friend template specialization %qD",
8035 error ("%<inline%> is not allowed in declaration of friend "
8036 "template specialization %qD",
8043 /* If this decl has namespace scope, set that up. */
8045 set_decl_namespace (decl
, in_namespace
, friendp
);
8047 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8049 /* `main' and builtins have implicit 'C' linkage. */
8050 if ((MAIN_NAME_P (declarator
)
8051 || (IDENTIFIER_LENGTH (declarator
) > 10
8052 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8053 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8054 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
8055 || (targetcm
.cxx_implicit_extern_c
8056 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
8057 && current_lang_name
== lang_name_cplusplus
8058 && ctype
== NULL_TREE
8059 && DECL_FILE_SCOPE_P (decl
))
8060 SET_DECL_LANGUAGE (decl
, lang_c
);
8062 /* Should probably propagate const out from type to decl I bet (mrs). */
8065 DECL_STATIC_FUNCTION_P (decl
) = 1;
8066 DECL_CONTEXT (decl
) = ctype
;
8070 DECL_DELETED_FN (decl
) = 1;
8074 DECL_CONTEXT (decl
) = ctype
;
8076 check_class_member_definition_namespace (decl
);
8079 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8081 if (PROCESSING_REAL_TEMPLATE_DECL_P())
8082 error ("cannot declare %<::main%> to be a template");
8084 error ("cannot declare %<::main%> to be inline");
8086 error ("cannot declare %<::main%> to be constexpr");
8088 error ("cannot declare %<::main%> to be static");
8093 /* Members of anonymous types and local classes have no linkage; make
8094 them internal. If a typedef is made later, this will be changed. */
8095 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
8096 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8099 if (publicp
&& cxx_dialect
== cxx98
)
8101 /* [basic.link]: A name with no linkage (notably, the name of a class
8102 or enumeration declared in a local scope) shall not be used to
8103 declare an entity with linkage.
8105 DR 757 relaxes this restriction for C++0x. */
8106 no_linkage_error (decl
);
8109 TREE_PUBLIC (decl
) = publicp
;
8112 DECL_INTERFACE_KNOWN (decl
) = 1;
8113 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8116 /* If the declaration was declared inline, mark it as such. */
8119 DECL_DECLARED_INLINE_P (decl
) = 1;
8121 DECL_COMDAT (decl
) = 1;
8124 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
8126 // If the concept declaration specifier was found, check
8127 // that the declaration satisfies the necessary requirements.
8130 DECL_DECLARED_CONCEPT_P (decl
) = true;
8131 check_concept_fn (decl
);
8134 DECL_EXTERNAL (decl
) = 1;
8135 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8138 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
8145 ? G_("static member function %qD cannot have cv-qualifier")
8146 : G_("non-member function %qD cannot have cv-qualifier"),
8148 quals
= TYPE_UNQUALIFIED
;
8154 ? G_("static member function %qD cannot have ref-qualifier")
8155 : G_("non-member function %qD cannot have ref-qualifier"),
8157 rqual
= REF_QUAL_NONE
;
8161 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
8162 && !grok_op_properties (decl
, /*complain=*/true))
8164 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
8166 bool long_long_unsigned_p
;
8168 const char *suffix
= NULL
;
8169 /* [over.literal]/6: Literal operators shall not have C linkage. */
8170 if (DECL_LANGUAGE (decl
) == lang_c
)
8172 error ("literal operator with C linkage");
8176 if (DECL_NAMESPACE_SCOPE_P (decl
))
8178 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
8181 error ("%qD has invalid argument list", decl
);
8185 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
8186 if (long_long_unsigned_p
)
8188 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
8189 warning (0, "integer suffix %<%s%>"
8190 " shadowed by implementation", suffix
);
8192 else if (long_double_p
)
8194 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
8195 warning (0, "floating point suffix %<%s%>"
8196 " shadowed by implementation", suffix
);
8201 error ("%qD must be a non-member function", decl
);
8207 /* Make the init_value nonzero so pushdecl knows this is not
8208 tentative. error_mark_node is replaced later with the BLOCK. */
8209 DECL_INITIAL (decl
) = error_mark_node
;
8211 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8212 TREE_NOTHROW (decl
) = 1;
8214 if (flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
8216 /* Adjust "omp declare simd" attributes. */
8217 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
8221 for (attr
= ods
; attr
;
8222 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
8224 if (TREE_CODE (type
) == METHOD_TYPE
)
8225 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
8226 DECL_ARGUMENTS (decl
), NULL
);
8227 if (TREE_VALUE (attr
) != NULL_TREE
)
8229 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
8230 cl
= c_omp_declare_simd_clauses_to_numbers
8231 (DECL_ARGUMENTS (decl
), cl
);
8233 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
8235 TREE_VALUE (attr
) = NULL_TREE
;
8241 /* Caller will do the rest of this. */
8245 if (ctype
!= NULL_TREE
)
8246 grokclassfn (ctype
, decl
, flags
);
8249 if (cxx_dialect
>= cxx11
8250 && DECL_DESTRUCTOR_P (decl
)
8251 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
8252 && !processing_template_decl
)
8253 deduce_noexcept_on_destructor (decl
);
8255 decl
= check_explicit_specialization (orig_declarator
, decl
,
8258 4 * (friendp
!= 0) +
8260 if (decl
== error_mark_node
)
8263 if (DECL_STATIC_FUNCTION_P (decl
))
8264 check_static_quals (decl
, quals
);
8268 cplus_decl_attributes (&decl
, *attrlist
, 0);
8269 *attrlist
= NULL_TREE
;
8272 /* Check main's type after attributes have been applied. */
8273 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8275 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8278 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8280 error ("%<::main%> must return %<int%>");
8281 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
8282 TREE_TYPE (decl
) = newtype
;
8285 check_main_parameter_types (decl
);
8288 if (ctype
!= NULL_TREE
8289 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8292 tree old_decl
= check_classfn (ctype
, decl
,
8293 (processing_template_decl
8294 > template_class_depth (ctype
))
8295 ? current_template_parms
8298 if (old_decl
== error_mark_node
)
8306 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8307 /* Because grokfndecl is always supposed to return a
8308 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8309 here. We depend on our callers to figure out that its
8310 really a template that's being returned. */
8311 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8313 if (DECL_STATIC_FUNCTION_P (old_decl
)
8314 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8316 /* Remove the `this' parm added by grokclassfn. */
8317 revert_static_member_fn (decl
);
8318 check_static_quals (decl
, quals
);
8320 if (DECL_ARTIFICIAL (old_decl
))
8322 error ("definition of implicitly-declared %qD", old_decl
);
8325 else if (DECL_DEFAULTED_FN (old_decl
))
8327 error ("definition of explicitly-defaulted %q+D", decl
);
8328 error ("%q+#D explicitly defaulted here", old_decl
);
8332 /* Since we've smashed OLD_DECL to its
8333 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8334 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8335 decl
= DECL_TEMPLATE_RESULT (decl
);
8337 /* Attempt to merge the declarations. This can fail, in
8338 the case of some invalid specialization declarations. */
8339 pushed_scope
= push_scope (ctype
);
8340 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8342 pop_scope (pushed_scope
);
8345 error ("no %q#D member function declared in class %qT",
8349 if (ok
== error_mark_node
)
8355 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8358 if (ctype
== NULL_TREE
|| check
)
8362 DECL_VIRTUAL_P (decl
) = 1;
8367 /* decl is a FUNCTION_DECL.
8368 specifiers are the parsed virt-specifiers.
8370 Set flags to reflect the virt-specifiers.
8375 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8377 if (decl
== NULL_TREE
)
8379 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8380 DECL_OVERRIDE_P (decl
) = 1;
8381 if (specifiers
& VIRT_SPEC_FINAL
)
8382 DECL_FINAL_P (decl
) = 1;
8386 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8387 the linkage that DECL will receive in the object file. */
8390 set_linkage_for_static_data_member (tree decl
)
8392 /* A static data member always has static storage duration and
8393 external linkage. Note that static data members are forbidden in
8394 local classes -- the only situation in which a class has
8395 non-external linkage. */
8396 TREE_PUBLIC (decl
) = 1;
8397 TREE_STATIC (decl
) = 1;
8398 /* For non-template classes, static data members are always put
8399 out in exactly those files where they are defined, just as
8400 with ordinary namespace-scope variables. */
8401 if (!processing_template_decl
)
8402 DECL_INTERFACE_KNOWN (decl
) = 1;
8405 /* Create a VAR_DECL named NAME with the indicated TYPE.
8407 If SCOPE is non-NULL, it is the class type or namespace containing
8408 the variable. If SCOPE is NULL, the variable should is created in
8409 the innermost enclosing scope. */
8412 grokvardecl (tree type
,
8414 tree orig_declarator
,
8415 const cp_decl_specifier_seq
*declspecs
,
8422 tree explicit_scope
;
8424 gcc_assert (!name
|| identifier_p (name
));
8426 bool constp
= flags
&1;
8427 bool conceptp
= flags
&2;
8429 /* Compute the scope in which to place the variable, but remember
8430 whether or not that scope was explicitly specified by the user. */
8431 explicit_scope
= scope
;
8434 /* An explicit "extern" specifier indicates a namespace-scope
8436 if (declspecs
->storage_class
== sc_extern
)
8437 scope
= current_decl_namespace ();
8438 else if (!at_function_scope_p ())
8439 scope
= current_scope ();
8443 && (/* If the variable is a namespace-scope variable declared in a
8444 template, we need DECL_LANG_SPECIFIC. */
8445 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8446 /* Similarly for namespace-scope variables with language linkage
8448 || (TREE_CODE (scope
) == NAMESPACE_DECL
8449 && current_lang_name
!= lang_name_cplusplus
)
8450 /* Similarly for static data members. */
8452 /* Similarly for explicit specializations. */
8454 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8455 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8457 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8459 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8460 set_decl_namespace (decl
, explicit_scope
, 0);
8462 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
8464 if (declspecs
->storage_class
== sc_extern
)
8466 DECL_THIS_EXTERN (decl
) = 1;
8467 DECL_EXTERNAL (decl
) = !initialized
;
8470 if (DECL_CLASS_SCOPE_P (decl
))
8472 set_linkage_for_static_data_member (decl
);
8473 /* This function is only called with out-of-class definitions. */
8474 DECL_EXTERNAL (decl
) = 0;
8475 check_class_member_definition_namespace (decl
);
8477 /* At top level, either `static' or no s.c. makes a definition
8478 (perhaps tentative), and absence of `static' makes it public. */
8479 else if (toplevel_bindings_p ())
8481 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
8482 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8483 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8485 /* Not at top level, only `static' makes a static definition. */
8488 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
8489 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8492 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
8494 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
8496 CP_DECL_THREAD_LOCAL_P (decl
) = true;
8497 if (!processing_template_decl
)
8498 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
8500 if (declspecs
->gnu_thread_keyword_p
)
8501 SET_DECL_GNU_TLS_P (decl
);
8504 /* If the type of the decl has no linkage, make sure that we'll
8505 notice that in mark_used. */
8506 if (cxx_dialect
> cxx98
8507 && decl_linkage (decl
) != lk_none
8508 && DECL_LANG_SPECIFIC (decl
) == NULL
8509 && !DECL_EXTERN_C_P (decl
)
8510 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
8511 retrofit_lang_decl (decl
);
8513 if (TREE_PUBLIC (decl
))
8515 /* [basic.link]: A name with no linkage (notably, the name of a class
8516 or enumeration declared in a local scope) shall not be used to
8517 declare an entity with linkage.
8519 DR 757 relaxes this restriction for C++0x. */
8520 if (cxx_dialect
< cxx11
)
8521 no_linkage_error (decl
);
8524 DECL_INTERFACE_KNOWN (decl
) = 1;
8526 if (DECL_NAME (decl
)
8527 && MAIN_NAME_P (DECL_NAME (decl
))
8528 && scope
== global_namespace
)
8529 error ("cannot declare %<::main%> to be a global variable");
8531 /* Check that the variable can be safely declared as a concept.
8532 Note that this also forbids explicit specializations. */
8535 if (!processing_template_decl
)
8537 error ("a non-template variable cannot be %<concept%>");
8541 DECL_DECLARED_CONCEPT_P (decl
) = true;
8542 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
8543 error_at (declspecs
->locations
[ds_type_spec
],
8544 "concept must have type %<bool%>");
8546 else if (flag_concepts
8547 && processing_template_decl
> template_class_depth (scope
))
8549 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8550 tree ci
= build_constraints (reqs
, NULL_TREE
);
8551 set_constraints (decl
, ci
);
8554 // Handle explicit specializations and instantiations of variable templates.
8555 if (orig_declarator
)
8556 decl
= check_explicit_specialization (orig_declarator
, decl
,
8557 template_count
, conceptp
* 8);
8559 return decl
!= error_mark_node
? decl
: NULL_TREE
;
8562 /* Create and return a canonical pointer to member function type, for
8563 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8566 build_ptrmemfunc_type (tree type
)
8571 if (type
== error_mark_node
)
8574 /* Make sure that we always have the unqualified pointer-to-member
8576 if (cp_cv_quals quals
= cp_type_quals (type
))
8578 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8579 return cp_build_qualified_type (unqual
, quals
);
8582 /* If a canonical type already exists for this type, use it. We use
8583 this method instead of type_hash_canon, because it only does a
8584 simple equality check on the list of field members. */
8586 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8589 t
= make_node (RECORD_TYPE
);
8591 /* Let the front end know this is a pointer to member function. */
8592 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8594 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8597 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8599 DECL_CHAIN (field
) = fields
;
8602 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8604 /* Zap out the name so that the back end will give us the debugging
8605 information for this anonymous RECORD_TYPE. */
8606 TYPE_NAME (t
) = NULL_TREE
;
8608 /* Cache this pointer-to-member type so that we can find it again
8610 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8612 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8613 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8614 else if (TYPE_CANONICAL (type
) != type
)
8615 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8620 /* Create and return a pointer to data member type. */
8623 build_ptrmem_type (tree class_type
, tree member_type
)
8625 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8627 cp_cv_quals quals
= type_memfn_quals (member_type
);
8628 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8629 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8630 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8634 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8635 return build_offset_type (class_type
, member_type
);
8639 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8640 Check to see that the definition is valid. Issue appropriate error
8641 messages. Return 1 if the definition is particularly bad, or 0
8645 check_static_variable_definition (tree decl
, tree type
)
8647 /* Can't check yet if we don't know the type. */
8648 if (dependent_type_p (type
))
8650 /* If DECL is declared constexpr, we'll do the appropriate checks
8651 in check_initializer. */
8652 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8654 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8656 if (!COMPLETE_TYPE_P (type
))
8657 error ("in-class initialization of static data member %q#D of "
8658 "incomplete type", decl
);
8659 else if (literal_type_p (type
))
8660 permerror (input_location
,
8661 "%<constexpr%> needed for in-class initialization of "
8662 "static data member %q#D of non-integral type", decl
);
8664 error ("in-class initialization of static data member %q#D of "
8665 "non-literal type", decl
);
8669 /* Motion 10 at San Diego: If a static const integral data member is
8670 initialized with an integral constant expression, the initializer
8671 may appear either in the declaration (within the class), or in
8672 the definition, but not both. If it appears in the class, the
8673 member is a member constant. The file-scope definition is always
8675 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8677 error ("invalid in-class initialization of static data member "
8678 "of non-integral type %qT",
8682 else if (!CP_TYPE_CONST_P (type
))
8683 error ("ISO C++ forbids in-class initialization of non-const "
8684 "static member %qD",
8686 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8687 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8688 "%qD of non-integral type %qT", decl
, type
);
8693 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8694 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8695 expressions out into temporary variables so that walk_tree doesn't
8696 step into them (c++/15764). */
8699 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8701 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
8702 tree expr
= *expr_p
;
8703 if (TREE_CODE (expr
) == SAVE_EXPR
)
8705 tree op
= TREE_OPERAND (expr
, 0);
8706 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8707 if (TREE_SIDE_EFFECTS (op
))
8708 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8711 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8716 /* Entry point for the above. */
8719 stabilize_vla_size (tree size
)
8721 hash_set
<tree
> pset
;
8722 /* Break out any function calls into temporary variables. */
8723 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
8726 /* Reduce a SIZEOF_EXPR to its value. */
8729 fold_sizeof_expr (tree t
)
8732 if (SIZEOF_EXPR_TYPE_P (t
))
8733 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
8734 SIZEOF_EXPR
, false);
8735 else if (TYPE_P (TREE_OPERAND (t
, 0)))
8736 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8739 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8741 if (r
== error_mark_node
)
8746 /* Given the SIZE (i.e., number of elements) in an array, compute
8747 an appropriate index type for the array. If non-NULL, NAME is
8748 the name of the entity being declared. */
8751 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8756 if (error_operand_p (size
))
8757 return error_mark_node
;
8759 if (!type_dependent_expression_p (size
))
8761 tree type
= TREE_TYPE (size
);
8763 mark_rvalue_use (size
);
8765 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8766 && TREE_SIDE_EFFECTS (size
))
8767 /* In C++98, we mark a non-constant array bound with a magic
8768 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8771 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
8773 if (CLASS_TYPE_P (type
)
8774 && CLASSTYPE_LITERAL_P (type
))
8776 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8779 if (!(complain
& tf_error
))
8780 return error_mark_node
;
8782 error ("size of array %qD has non-integral type %qT",
8785 error ("size of array has non-integral type %qT", type
);
8786 size
= integer_one_node
;
8788 if (size
== error_mark_node
)
8789 return error_mark_node
;
8790 type
= TREE_TYPE (size
);
8793 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8794 size
= maybe_constant_value (size
);
8796 if (!TREE_CONSTANT (size
))
8800 if (error_operand_p (size
))
8801 return error_mark_node
;
8803 /* The array bound must be an integer type. */
8804 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8806 if (!(complain
& tf_error
))
8807 return error_mark_node
;
8809 error ("size of array %qD has non-integral type %qT", name
, type
);
8811 error ("size of array has non-integral type %qT", type
);
8812 size
= integer_one_node
;
8813 type
= TREE_TYPE (size
);
8817 /* A type is dependent if it is...an array type constructed from any
8818 dependent type or whose size is specified by a constant expression
8819 that is value-dependent. */
8820 /* We can only call value_dependent_expression_p on integral constant
8821 expressions; treat non-constant expressions as dependent, too. */
8822 if (processing_template_decl
8823 && (type_dependent_expression_p (size
)
8824 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8826 /* We cannot do any checking for a SIZE that isn't known to be
8827 constant. Just build the index type and mark that it requires
8828 structural equality checks. */
8829 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8830 size
, size_one_node
));
8831 TYPE_DEPENDENT_P (itype
) = 1;
8832 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8833 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8837 if (TREE_CODE (size
) != INTEGER_CST
)
8839 tree folded
= cp_fully_fold (size
);
8840 if (TREE_CODE (folded
) == INTEGER_CST
)
8841 pedwarn (location_of (size
), OPT_Wpedantic
,
8842 "size of array is not an integral constant-expression");
8843 /* Use the folded result for VLAs, too; it will have resolved
8848 /* Normally, the array-bound will be a constant. */
8849 if (TREE_CODE (size
) == INTEGER_CST
)
8851 /* Check to see if the array bound overflowed. Make that an
8852 error, no matter how generous we're being. */
8853 constant_expression_error (size
);
8855 /* An array must have a positive number of elements. */
8856 if (tree_int_cst_lt (size
, integer_zero_node
))
8858 if (!(complain
& tf_error
))
8859 return error_mark_node
;
8861 error ("size of array %qD is negative", name
);
8863 error ("size of array is negative");
8864 size
= integer_one_node
;
8866 /* As an extension we allow zero-sized arrays. */
8867 else if (integer_zerop (size
))
8869 if (!(complain
& tf_error
))
8870 /* We must fail if performing argument deduction (as
8871 indicated by the state of complain), so that
8872 another substitution can be found. */
8873 return error_mark_node
;
8874 else if (in_system_header_at (input_location
))
8875 /* Allow them in system headers because glibc uses them. */;
8877 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8879 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8882 else if (TREE_CONSTANT (size
)
8883 /* We don't allow VLAs at non-function scopes, or during
8884 tentative template substitution. */
8885 || !at_function_scope_p ()
8886 || !(complain
& tf_error
))
8888 if (!(complain
& tf_error
))
8889 return error_mark_node
;
8890 /* `(int) &fn' is not a valid array bound. */
8892 error ("size of array %qD is not an integral constant-expression",
8895 error ("size of array is not an integral constant-expression");
8896 size
= integer_one_node
;
8898 else if (pedantic
&& warn_vla
!= 0)
8901 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8903 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8905 else if (warn_vla
> 0)
8909 "variable length array %qD is used", name
);
8912 "variable length array is used");
8915 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8916 /* A variable sized array. */
8917 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8920 HOST_WIDE_INT saved_processing_template_decl
;
8922 /* Compute the index of the largest element in the array. It is
8923 one less than the number of elements in the array. We save
8924 and restore PROCESSING_TEMPLATE_DECL so that computations in
8925 cp_build_binary_op will be appropriately folded. */
8926 saved_processing_template_decl
= processing_template_decl
;
8927 processing_template_decl
= 0;
8928 itype
= cp_build_binary_op (input_location
,
8930 cp_convert (ssizetype
, size
, complain
),
8931 cp_convert (ssizetype
, integer_one_node
,
8934 itype
= maybe_constant_value (itype
);
8935 processing_template_decl
= saved_processing_template_decl
;
8937 if (!TREE_CONSTANT (itype
))
8939 /* A variable sized array. */
8940 itype
= variable_size (itype
);
8942 stabilize_vla_size (itype
);
8944 if (flag_sanitize
& SANITIZE_VLA
8945 && do_ubsan_in_current_function ())
8947 /* We have to add 1 -- in the ubsan routine we generate
8948 LE_EXPR rather than LT_EXPR. */
8949 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8950 build_one_cst (TREE_TYPE (itype
)));
8951 t
= ubsan_instrument_vla (input_location
, t
);
8952 finish_expr_stmt (t
);
8955 /* Make sure that there was no overflow when creating to a signed
8956 index type. (For example, on a 32-bit machine, an array with
8957 size 2^32 - 1 is too big.) */
8958 else if (TREE_CODE (itype
) == INTEGER_CST
8959 && TREE_OVERFLOW (itype
))
8961 if (!(complain
& tf_error
))
8962 return error_mark_node
;
8963 error ("overflow in array dimension");
8964 TREE_OVERFLOW (itype
) = 0;
8968 /* Create and return the appropriate index type. */
8969 itype
= build_index_type (itype
);
8971 /* If the index type were dependent, we would have returned early, so
8972 remember that it isn't. */
8973 TYPE_DEPENDENT_P (itype
) = 0;
8974 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8978 /* Returns the scope (if any) in which the entity declared by
8979 DECLARATOR will be located. If the entity was declared with an
8980 unqualified name, NULL_TREE is returned. */
8983 get_scope_of_declarator (const cp_declarator
*declarator
)
8985 while (declarator
&& declarator
->kind
!= cdk_id
)
8986 declarator
= declarator
->declarator
;
8988 /* If the declarator-id is a SCOPE_REF, the scope in which the
8989 declaration occurs is the first operand. */
8991 && declarator
->u
.id
.qualifying_scope
)
8992 return declarator
->u
.id
.qualifying_scope
;
8994 /* Otherwise, the declarator is not a qualified name; the entity will
8995 be declared in the current scope. */
8999 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9000 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9004 create_array_type_for_decl (tree name
, tree type
, tree size
)
9006 tree itype
= NULL_TREE
;
9008 /* If things have already gone awry, bail now. */
9009 if (type
== error_mark_node
|| size
== error_mark_node
)
9010 return error_mark_node
;
9012 /* 8.3.4/1: If the type of the identifier of D contains the auto
9013 type-specifier, the program is ill-formed. */
9014 if (type_uses_auto (type
))
9016 error ("%qD declared as array of %qT", name
, type
);
9017 return error_mark_node
;
9020 /* If there are some types which cannot be array elements,
9021 issue an error-message and return. */
9022 switch (TREE_CODE (type
))
9026 error ("declaration of %qD as array of void", name
);
9028 error ("creating array of void");
9029 return error_mark_node
;
9033 error ("declaration of %qD as array of functions", name
);
9035 error ("creating array of functions");
9036 return error_mark_node
;
9038 case REFERENCE_TYPE
:
9040 error ("declaration of %qD as array of references", name
);
9042 error ("creating array of references");
9043 return error_mark_node
;
9047 error ("declaration of %qD as array of function members", name
);
9049 error ("creating array of function members");
9050 return error_mark_node
;
9058 The constant expressions that specify the bounds of the arrays
9059 can be omitted only for the first member of the sequence. */
9060 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9063 error ("declaration of %qD as multidimensional array must "
9064 "have bounds for all dimensions except the first",
9067 error ("multidimensional array must have bounds for all "
9068 "dimensions except the first");
9070 return error_mark_node
;
9073 /* Figure out the index type for the array. */
9075 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
9078 T is called the array element type; this type shall not be [...] an
9079 abstract class type. */
9080 abstract_virtuals_error (name
, type
);
9082 return build_cplus_array_type (type
, itype
);
9085 /* Returns the smallest location != UNKNOWN_LOCATION among the
9086 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
9087 and LOCATIONS[ds_restrict]. */
9090 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
9092 location_t loc
= UNKNOWN_LOCATION
;
9094 if (type_quals
& TYPE_QUAL_CONST
)
9095 loc
= locations
[ds_const
];
9097 if ((type_quals
& TYPE_QUAL_VOLATILE
)
9098 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_volatile
] < loc
))
9099 loc
= locations
[ds_volatile
];
9101 if ((type_quals
& TYPE_QUAL_RESTRICT
)
9102 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_restrict
] < loc
))
9103 loc
= locations
[ds_restrict
];
9108 /* Check that it's OK to declare a function with the indicated TYPE
9109 and TYPE_QUALS. SFK indicates the kind of special function (if any)
9110 that this function is. OPTYPE is the type given in a conversion
9111 operator declaration, or the class type for a constructor/destructor.
9112 Returns the actual return type of the function; that may be different
9113 than TYPE if an error occurs, or for certain special functions. */
9116 check_special_function_return_type (special_function_kind sfk
,
9120 const location_t
* locations
)
9124 case sfk_constructor
:
9126 error ("return type specification for constructor invalid");
9127 else if (type_quals
!= TYPE_UNQUALIFIED
)
9128 error_at (smallest_type_quals_location (type_quals
, locations
),
9129 "qualifiers are not allowed on constructor declaration");
9131 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9132 type
= build_pointer_type (optype
);
9134 type
= void_type_node
;
9137 case sfk_destructor
:
9139 error ("return type specification for destructor invalid");
9140 else if (type_quals
!= TYPE_UNQUALIFIED
)
9141 error_at (smallest_type_quals_location (type_quals
, locations
),
9142 "qualifiers are not allowed on destructor declaration");
9144 /* We can't use the proper return type here because we run into
9145 problems with ambiguous bases and covariant returns.
9146 Java classes are left unchanged because (void *) isn't a valid
9147 Java type, and we don't want to change the Java ABI. */
9148 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9149 type
= build_pointer_type (void_type_node
);
9151 type
= void_type_node
;
9154 case sfk_conversion
:
9156 error ("return type specified for %<operator %T%>", optype
);
9157 else if (type_quals
!= TYPE_UNQUALIFIED
)
9158 error_at (smallest_type_quals_location (type_quals
, locations
),
9159 "qualifiers are not allowed on declaration of "
9160 "%<operator %T%>", optype
);
9172 /* A variable or data member (whose unqualified name is IDENTIFIER)
9173 has been declared with the indicated TYPE. If the TYPE is not
9174 acceptable, issue an error message and return a type to use for
9175 error-recovery purposes. */
9178 check_var_type (tree identifier
, tree type
)
9180 if (VOID_TYPE_P (type
))
9183 error ("unnamed variable or field declared void");
9184 else if (identifier_p (identifier
))
9186 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
9187 error ("variable or field %qE declared void", identifier
);
9190 error ("variable or field declared void");
9191 type
= error_mark_node
;
9197 /* Given declspecs and a declarator (abstract or otherwise), determine
9198 the name and type of the object declared and construct a DECL node
9201 DECLSPECS points to the representation of declaration-specifier
9202 sequence that precedes declarator.
9204 DECL_CONTEXT says which syntactic context this declaration is in:
9205 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9206 FUNCDEF for a function definition. Like NORMAL but a few different
9207 error messages in each case. Return value may be zero meaning
9208 this definition is too screwy to try to parse.
9209 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9210 handle member functions (which have FIELD context).
9211 Return value may be zero meaning this definition is too screwy to
9213 PARM for a parameter declaration (either within a function prototype
9214 or before a function body). Make a PARM_DECL, or return void_type_node.
9215 TPARM for a template parameter declaration.
9216 CATCHPARM for a parameter declaration before a catch clause.
9217 TYPENAME if for a typename (in a cast or sizeof).
9218 Don't make a DECL node; just return the ..._TYPE node.
9219 FIELD for a struct or union field; make a FIELD_DECL.
9220 BITFIELD for a field with specified width.
9222 INITIALIZED is as for start_decl.
9224 ATTRLIST is a pointer to the list of attributes, which may be NULL
9225 if there are none; *ATTRLIST may be modified if attributes from inside
9226 the declarator should be applied to the declaration.
9228 When this function is called, scoping variables (such as
9229 CURRENT_CLASS_TYPE) should reflect the scope in which the
9230 declaration occurs, not the scope in which the new declaration will
9231 be placed. For example, on:
9235 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9238 Returns a DECL (if a declarator is present), a TYPE (if there is no
9239 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
9243 grokdeclarator (const cp_declarator
*declarator
,
9244 cp_decl_specifier_seq
*declspecs
,
9245 enum decl_context decl_context
,
9249 tree type
= NULL_TREE
;
9251 int explicit_intN
= 0;
9252 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9253 int explicit_int
= 0;
9254 int explicit_char
= 0;
9255 int defaulted_int
= 0;
9257 tree typedef_decl
= NULL_TREE
;
9258 const char *name
= NULL
;
9259 tree typedef_type
= NULL_TREE
;
9260 /* True if this declarator is a function definition. */
9261 bool funcdef_flag
= false;
9262 cp_declarator_kind innermost_code
= cdk_error
;
9265 /* See the code below that used this. */
9266 tree decl_attr
= NULL_TREE
;
9269 /* Keep track of what sort of function is being processed
9270 so that we can warn about default return values, or explicit
9271 return values which do not match prescribed defaults. */
9272 special_function_kind sfk
= sfk_none
;
9274 tree dname
= NULL_TREE
;
9275 tree ctor_return_type
= NULL_TREE
;
9276 enum overload_flags flags
= NO_SPECIAL
;
9277 /* cv-qualifiers that apply to the declarator, for a declaration of
9278 a member function. */
9279 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
9280 /* virt-specifiers that apply to the declarator, for a declaration of
9281 a member function. */
9282 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
9283 /* ref-qualifier that applies to the declarator, for a declaration of
9284 a member function. */
9285 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
9286 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
9287 int type_quals
= TYPE_UNQUALIFIED
;
9288 tree raises
= NULL_TREE
;
9289 int template_count
= 0;
9290 tree returned_attrs
= NULL_TREE
;
9291 tree parms
= NULL_TREE
;
9292 const cp_declarator
*id_declarator
;
9293 /* The unqualified name of the declarator; either an
9294 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
9295 tree unqualified_id
;
9296 /* The class type, if any, in which this entity is located,
9297 or NULL_TREE if none. Note that this value may be different from
9298 the current class type; for example if an attempt is made to declare
9299 "A::f" inside "B", this value will be "A". */
9300 tree ctype
= current_class_type
;
9301 /* The NAMESPACE_DECL for the namespace in which this entity is
9302 located. If an unqualified name is used to declare the entity,
9303 this value will be NULL_TREE, even if the entity is located at
9305 tree in_namespace
= NULL_TREE
;
9306 cp_storage_class storage_class
;
9307 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
9308 bool type_was_error_mark_node
= false;
9309 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
9310 bool template_type_arg
= false;
9311 bool template_parm_flag
= false;
9312 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
9313 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
9314 bool late_return_type_p
= false;
9315 bool array_parameter_p
= false;
9316 source_location saved_loc
= input_location
;
9318 tree reqs
= NULL_TREE
;
9320 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
9321 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
9322 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
9323 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
9324 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
9325 explicit_intN
= declspecs
->explicit_intN_p
;
9326 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
9328 // Was concept_p specified? Note that ds_concept
9329 // implies ds_constexpr!
9330 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
9334 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9335 type_quals
|= TYPE_QUAL_CONST
;
9336 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9337 type_quals
|= TYPE_QUAL_VOLATILE
;
9338 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9339 type_quals
|= TYPE_QUAL_RESTRICT
;
9341 if (decl_context
== FUNCDEF
)
9342 funcdef_flag
= true, decl_context
= NORMAL
;
9343 else if (decl_context
== MEMFUNCDEF
)
9344 funcdef_flag
= true, decl_context
= FIELD
;
9345 else if (decl_context
== BITFIELD
)
9346 bitfield
= 1, decl_context
= FIELD
;
9347 else if (decl_context
== TEMPLATE_TYPE_ARG
)
9348 template_type_arg
= true, decl_context
= TYPENAME
;
9349 else if (decl_context
== TPARM
)
9350 template_parm_flag
= true, decl_context
= PARM
;
9352 if (initialized
> 1)
9353 funcdef_flag
= true;
9355 /* Look inside a declarator for the name being declared
9356 and get it as a string, for an error message. */
9357 for (id_declarator
= declarator
;
9359 id_declarator
= id_declarator
->declarator
)
9361 if (id_declarator
->kind
!= cdk_id
)
9362 innermost_code
= id_declarator
->kind
;
9364 switch (id_declarator
->kind
)
9367 if (id_declarator
->declarator
9368 && id_declarator
->declarator
->kind
== cdk_id
)
9370 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
9371 if (sfk
== sfk_destructor
)
9378 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
9379 tree decl
= id_declarator
->u
.id
.unqualified_name
;
9382 if (qualifying_scope
)
9384 if (at_function_scope_p ())
9388 A declarator-id shall not be qualified except
9391 None of the cases are permitted in block
9393 if (qualifying_scope
== global_namespace
)
9394 error ("invalid use of qualified-name %<::%D%>",
9396 else if (TYPE_P (qualifying_scope
))
9397 error ("invalid use of qualified-name %<%T::%D%>",
9398 qualifying_scope
, decl
);
9400 error ("invalid use of qualified-name %<%D::%D%>",
9401 qualifying_scope
, decl
);
9402 return error_mark_node
;
9404 else if (TYPE_P (qualifying_scope
))
9406 ctype
= qualifying_scope
;
9407 if (!MAYBE_CLASS_TYPE_P (ctype
))
9409 error ("%q#T is not a class or a namespace", ctype
);
9412 else if (innermost_code
!= cdk_function
9413 && current_class_type
9414 && !uniquely_derived_from_p (ctype
,
9415 current_class_type
))
9417 error ("invalid use of qualified-name %<%T::%D%>",
9418 qualifying_scope
, decl
);
9419 return error_mark_node
;
9422 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
9423 in_namespace
= qualifying_scope
;
9425 switch (TREE_CODE (decl
))
9431 if (innermost_code
!= cdk_function
)
9433 error ("declaration of %qD as non-function", decl
);
9434 return error_mark_node
;
9436 else if (!qualifying_scope
9437 && !(current_class_type
&& at_class_scope_p ()))
9439 error ("declaration of %qD as non-member", decl
);
9440 return error_mark_node
;
9443 type
= TREE_OPERAND (decl
, 0);
9445 type
= constructor_name (type
);
9446 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
9451 case TEMPLATE_ID_EXPR
:
9453 tree fns
= TREE_OPERAND (decl
, 0);
9456 if (!identifier_p (dname
))
9458 if (variable_template_p (dname
))
9459 dname
= DECL_NAME (dname
);
9462 gcc_assert (is_overloaded_fn (dname
));
9463 dname
= DECL_NAME (get_first_fn (dname
));
9469 case IDENTIFIER_NODE
:
9470 if (identifier_p (decl
))
9473 if (C_IS_RESERVED_WORD (dname
))
9475 error ("declarator-id missing; using reserved word %qD",
9477 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9479 else if (!IDENTIFIER_TYPENAME_P (dname
))
9480 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9483 gcc_assert (flags
== NO_SPECIAL
);
9484 flags
= TYPENAME_FLAG
;
9485 ctor_return_type
= TREE_TYPE (dname
);
9486 sfk
= sfk_conversion
;
9487 if (is_typename_at_global_scope (dname
))
9488 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9490 name
= "<invalid operator>";
9507 return error_mark_node
;
9512 if (id_declarator
->kind
== cdk_id
)
9518 The declarator in a function-definition shall have the form
9519 D1 ( parameter-declaration-clause) ... */
9520 if (funcdef_flag
&& innermost_code
!= cdk_function
)
9522 error ("function definition does not declare parameters");
9523 return error_mark_node
;
9526 if (flags
== TYPENAME_FLAG
9527 && innermost_code
!= cdk_function
9528 && ! (ctype
&& !declspecs
->any_specifiers_p
))
9530 error ("declaration of %qD as non-function", dname
);
9531 return error_mark_node
;
9535 && identifier_p (dname
)
9536 && UDLIT_OPER_P (dname
)
9537 && innermost_code
!= cdk_function
)
9539 error ("declaration of %qD as non-function", dname
);
9540 return error_mark_node
;
9543 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9547 error ("declaration of %qD as %<typedef%>", dname
);
9548 return error_mark_node
;
9550 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9552 error ("declaration of %qD as parameter", dname
);
9553 return error_mark_node
;
9557 /* Anything declared one level down from the top level
9558 must be one of the parameters of a function
9559 (because the body is at least two levels down). */
9561 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9562 by not allowing C++ class definitions to specify their parameters
9563 with xdecls (must be spec.d in the parmlist).
9565 Since we now wait to push a class scope until we are sure that
9566 we are in a legitimate method context, we must set oldcname
9567 explicitly (since current_class_name is not yet alive).
9569 We also want to avoid calling this a PARM if it is in a namespace. */
9571 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9573 cp_binding_level
*b
= current_binding_level
;
9574 current_binding_level
= b
->level_chain
;
9575 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9576 decl_context
= PARM
;
9577 current_binding_level
= b
;
9581 name
= decl_context
== PARM
? "parameter" : "type name";
9583 if (concept_p
&& typedef_p
)
9585 error ("%<concept%> cannot appear in a typedef declaration");
9586 return error_mark_node
;
9589 if (constexpr_p
&& typedef_p
)
9591 error ("%<constexpr%> cannot appear in a typedef declaration");
9592 return error_mark_node
;
9595 /* If there were multiple types specified in the decl-specifier-seq,
9596 issue an error message. */
9597 if (declspecs
->multiple_types_p
)
9599 error ("two or more data types in declaration of %qs", name
);
9600 return error_mark_node
;
9603 if (declspecs
->conflicting_specifiers_p
)
9605 error ("conflicting specifiers in declaration of %qs", name
);
9606 return error_mark_node
;
9609 /* Extract the basic type from the decl-specifier-seq. */
9610 type
= declspecs
->type
;
9611 if (type
== error_mark_node
)
9614 type_was_error_mark_node
= true;
9616 /* If the entire declaration is itself tagged as deprecated then
9617 suppress reports of deprecated items. */
9618 if (type
&& TREE_DEPRECATED (type
)
9619 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9620 warn_deprecated_use (type
, NULL_TREE
);
9621 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9623 typedef_decl
= type
;
9624 type
= TREE_TYPE (typedef_decl
);
9625 if (TREE_DEPRECATED (type
)
9626 && DECL_ARTIFICIAL (typedef_decl
)
9627 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9628 warn_deprecated_use (type
, NULL_TREE
);
9630 /* No type at all: default to `int', and set DEFAULTED_INT
9631 because it was not a user-defined typedef. */
9632 if (type
== NULL_TREE
)
9634 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
9636 /* These imply 'int'. */
9637 type
= integer_type_node
;
9640 /* If we just have "complex", it is equivalent to "complex double". */
9641 else if (!longlong
&& !explicit_intN
9642 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9644 type
= double_type_node
;
9645 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
9646 "ISO C++ does not support plain %<complex%> meaning "
9647 "%<double complex%>");
9651 explicit_int
= declspecs
->explicit_int_p
;
9652 explicit_char
= declspecs
->explicit_char_p
;
9655 /* See the code below that used this. */
9657 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9659 typedef_type
= type
;
9662 if (sfk
!= sfk_conversion
)
9663 ctor_return_type
= ctype
;
9665 if (sfk
!= sfk_none
)
9667 type
= check_special_function_return_type (sfk
, type
,
9670 declspecs
->locations
);
9671 type_quals
= TYPE_UNQUALIFIED
;
9673 else if (type
== NULL_TREE
)
9679 /* We handle `main' specially here, because 'main () { }' is so
9680 common. With no options, it is allowed. With -Wreturn-type,
9681 it is a warning. It is only an error with -pedantic-errors. */
9682 is_main
= (funcdef_flag
9683 && dname
&& identifier_p (dname
)
9684 && MAIN_NAME_P (dname
)
9685 && ctype
== NULL_TREE
9686 && in_namespace
== NULL_TREE
9687 && current_namespace
== global_namespace
);
9689 if (type_was_error_mark_node
)
9690 /* We've already issued an error, don't complain more. */;
9691 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9692 /* Allow it, sigh. */;
9694 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9696 pedwarn (input_location
, OPT_Wpedantic
,
9697 "ISO C++ forbids declaration of %qs with no type", name
);
9699 warning (OPT_Wreturn_type
,
9700 "ISO C++ forbids declaration of %qs with no type", name
);
9702 if (type_was_error_mark_node
&& template_parm_flag
)
9703 /* FIXME we should be able to propagate the error_mark_node as is
9704 for other contexts too. */
9705 type
= error_mark_node
;
9707 type
= integer_type_node
;
9714 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
9716 error ("%<__int%d%> is not supported by this target",
9717 int_n_data
[declspecs
->int_n_idx
].bitsize
);
9718 explicit_intN
= false;
9720 else if (pedantic
&& ! in_system_header_at (input_location
))
9721 pedwarn (input_location
, OPT_Wpedantic
,
9722 "ISO C++ does not support %<__int%d%> for %qs",
9723 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
9726 /* Now process the modifiers that were specified
9727 and check for invalid combinations. */
9729 /* Long double is a special combination. */
9730 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9733 type
= cp_build_qualified_type (long_double_type_node
,
9734 cp_type_quals (type
));
9737 /* Check all other uses of type modifiers. */
9739 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9743 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9744 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9745 else if (signed_p
&& unsigned_p
)
9746 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9747 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9748 error ("%<long long%> invalid for %qs", name
);
9749 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9750 error ("%<long%> invalid for %qs", name
);
9751 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9752 error ("%<short%> invalid for %qs", name
);
9753 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9754 error ("%<long%> or %<short%> invalid for %qs", name
);
9755 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
9756 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9757 else if ((long_p
|| short_p
) && explicit_char
)
9758 error ("%<long%> or %<short%> specified with char for %qs", name
);
9759 else if (long_p
&& short_p
)
9760 error ("%<long%> and %<short%> specified together for %qs", name
);
9761 else if (type
== char16_type_node
|| type
== char32_type_node
)
9763 if (signed_p
|| unsigned_p
)
9764 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9765 else if (short_p
|| long_p
)
9766 error ("%<short%> or %<long%> invalid for %qs", name
);
9771 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
9773 pedwarn (input_location
, OPT_Wpedantic
,
9774 "long, short, signed or unsigned used invalidly for %qs",
9776 if (flag_pedantic_errors
)
9781 /* Discard the type modifiers if they are invalid. */
9792 /* Decide whether an integer type is signed or not.
9793 Optionally treat bitfields as signed by default. */
9797 It is implementation-defined whether a plain (neither
9798 explicitly signed or unsigned) char, short, int, or long
9799 bit-field is signed or unsigned.
9801 Naturally, we extend this to long long as well. Note that
9802 this does not include wchar_t. */
9803 || (bitfield
&& !flag_signed_bitfields
9805 /* A typedef for plain `int' without `signed' can be
9806 controlled just like plain `int', but a typedef for
9807 `signed int' cannot be so controlled. */
9809 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9810 && TREE_CODE (type
) == INTEGER_TYPE
9811 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9814 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
9816 type
= long_long_unsigned_type_node
;
9818 type
= long_unsigned_type_node
;
9820 type
= short_unsigned_type_node
;
9821 else if (type
== char_type_node
)
9822 type
= unsigned_char_type_node
;
9823 else if (typedef_decl
)
9824 type
= unsigned_type_for (type
);
9826 type
= unsigned_type_node
;
9828 else if (signed_p
&& type
== char_type_node
)
9829 type
= signed_char_type_node
;
9830 else if (explicit_intN
)
9831 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
9833 type
= long_long_integer_type_node
;
9835 type
= long_integer_type_node
;
9837 type
= short_integer_type_node
;
9839 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9841 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9842 error ("complex invalid for %qs", name
);
9843 /* If a modifier is specified, the resulting complex is the complex
9844 form of TYPE. E.g, "complex short" is "complex short int". */
9845 else if (type
== integer_type_node
)
9846 type
= complex_integer_type_node
;
9847 else if (type
== float_type_node
)
9848 type
= complex_float_type_node
;
9849 else if (type
== double_type_node
)
9850 type
= complex_double_type_node
;
9851 else if (type
== long_double_type_node
)
9852 type
= complex_long_double_type_node
;
9854 type
= build_complex_type (type
);
9857 /* If we're using the injected-class-name to form a compound type or a
9858 declaration, replace it with the underlying class so we don't get
9859 redundant typedefs in the debug output. But if we are returning the
9860 type unchanged, leave it alone so that it's available to
9861 maybe_get_template_decl_from_type_decl. */
9862 if (CLASS_TYPE_P (type
)
9863 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9864 && type
== TREE_TYPE (TYPE_NAME (type
))
9865 && (declarator
|| type_quals
))
9866 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9868 type_quals
|= cp_type_quals (type
);
9869 type
= cp_build_qualified_type_real
9870 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
9871 || declspecs
->decltype_p
)
9872 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9873 /* We might have ignored or rejected some of the qualifiers. */
9874 type_quals
= cp_type_quals (type
);
9877 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9878 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9879 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9881 storage_class
= declspecs
->storage_class
;
9882 if (storage_class
== sc_static
)
9883 staticp
= 1 + (decl_context
== FIELD
);
9889 error ("member %qD cannot be declared both %<virtual%> "
9890 "and %<static%>", dname
);
9891 storage_class
= sc_none
;
9895 error ("member %qD cannot be declared both %<virtual%> "
9896 "and %<constexpr%>", dname
);
9898 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9900 /* Issue errors about use of storage classes for parameters. */
9901 if (decl_context
== PARM
)
9905 error ("typedef declaration invalid in parameter declaration");
9906 return error_mark_node
;
9908 else if (template_parm_flag
&& storage_class
!= sc_none
)
9910 error ("storage class specified for template parameter %qs", name
);
9911 return error_mark_node
;
9913 else if (storage_class
== sc_static
9914 || storage_class
== sc_extern
9916 error ("storage class specifiers invalid in parameter declarations");
9918 /* Function parameters cannot be concept. */
9920 error ("a parameter cannot be declared %<concept%>");
9921 /* Function parameters cannot be constexpr. If we saw one, moan
9922 and pretend it wasn't there. */
9923 else if (constexpr_p
)
9925 error ("a parameter cannot be declared %<constexpr%>");
9930 /* Give error if `virtual' is used outside of class declaration. */
9932 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9934 error_at (declspecs
->locations
[ds_virtual
],
9935 "%<virtual%> outside class declaration");
9939 /* Static anonymous unions are dealt with here. */
9940 if (staticp
&& decl_context
== TYPENAME
9942 && ANON_AGGR_TYPE_P (declspecs
->type
))
9943 decl_context
= FIELD
;
9945 /* Warn about storage classes that are invalid for certain
9946 kinds of declarations (parameters, typenames, etc.). */
9949 && storage_class
!= sc_extern
9950 && storage_class
!= sc_static
)
9953 error ("multiple storage classes in declaration of %qs", name
);
9956 if (decl_context
!= NORMAL
9957 && ((storage_class
!= sc_none
9958 && storage_class
!= sc_mutable
)
9961 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9962 && (storage_class
== sc_register
9963 || storage_class
== sc_auto
))
9967 else if (decl_context
== FIELD
9968 /* C++ allows static class elements. */
9969 && storage_class
== sc_static
)
9970 /* C++ also allows inlines and signed and unsigned elements,
9971 but in those cases we don't come in here. */
9975 if (decl_context
== FIELD
)
9976 error ("storage class specified for %qs", name
);
9979 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9980 error ("storage class specified for parameter %qs", name
);
9982 error ("storage class specified for typename");
9984 if (storage_class
== sc_register
9985 || storage_class
== sc_auto
9986 || storage_class
== sc_extern
9988 storage_class
= sc_none
;
9991 else if (storage_class
== sc_extern
&& funcdef_flag
9992 && ! toplevel_bindings_p ())
9993 error ("nested function %qs declared %<extern%>", name
);
9994 else if (toplevel_bindings_p ())
9996 if (storage_class
== sc_auto
)
9997 error ("top-level declaration of %qs specifies %<auto%>", name
);
10000 && storage_class
!= sc_extern
10001 && storage_class
!= sc_static
)
10003 if (declspecs
->gnu_thread_keyword_p
)
10004 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
10005 "declared %<__thread%>", name
);
10007 /* When thread_local is applied to a variable of block scope the
10008 storage-class-specifier static is implied if it does not appear
10010 storage_class
= declspecs
->storage_class
= sc_static
;
10014 if (storage_class
&& friendp
)
10016 error ("storage class specifiers invalid in friend function declarations");
10017 storage_class
= sc_none
;
10021 if (!id_declarator
)
10022 unqualified_id
= NULL_TREE
;
10025 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
10026 switch (TREE_CODE (unqualified_id
))
10029 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
10030 if (TYPE_P (unqualified_id
))
10031 unqualified_id
= constructor_name (unqualified_id
);
10034 case IDENTIFIER_NODE
:
10035 case TEMPLATE_ID_EXPR
:
10039 gcc_unreachable ();
10043 if (declspecs
->std_attributes
)
10045 /* Apply the c++11 attributes to the type preceding them. */
10046 input_location
= declspecs
->locations
[ds_std_attribute
];
10047 decl_attributes (&type
, declspecs
->std_attributes
, 0);
10048 input_location
= saved_loc
;
10051 /* Determine the type of the entity declared by recurring on the
10053 for (; declarator
; declarator
= declarator
->declarator
)
10055 const cp_declarator
*inner_declarator
;
10058 if (type
== error_mark_node
)
10059 return error_mark_node
;
10061 attrs
= declarator
->attributes
;
10067 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
10068 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
10069 if (declarator
->kind
== cdk_function
)
10070 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
10071 if (declarator
->kind
== cdk_array
)
10072 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
10073 returned_attrs
= decl_attributes (&type
,
10074 chainon (returned_attrs
, attrs
),
10078 if (declarator
->kind
== cdk_id
)
10081 inner_declarator
= declarator
->declarator
;
10083 switch (declarator
->kind
)
10086 type
= create_array_type_for_decl (dname
, type
,
10087 declarator
->u
.array
.bounds
);
10088 if (!valid_array_size_p (input_location
, type
, dname
))
10089 type
= error_mark_node
;
10091 if (declarator
->std_attributes
)
10094 The optional attribute-specifier-seq appertains to the
10096 returned_attrs
= chainon (returned_attrs
,
10097 declarator
->std_attributes
);
10105 /* Declaring a function type.
10106 Make sure we have a valid type for the function to return. */
10108 if (type_quals
!= TYPE_UNQUALIFIED
)
10110 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
10111 warning (OPT_Wignored_qualifiers
,
10112 "type qualifiers ignored on function return type");
10113 /* We now know that the TYPE_QUALS don't apply to the
10114 decl, but to its return type. */
10115 type_quals
= TYPE_UNQUALIFIED
;
10117 errmsg
= targetm
.invalid_return_type (type
);
10121 type
= integer_type_node
;
10124 /* Error about some types functions can't return. */
10126 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10128 error ("%qs declared as function returning a function", name
);
10129 return error_mark_node
;
10131 if (TREE_CODE (type
) == ARRAY_TYPE
)
10133 error ("%qs declared as function returning an array", name
);
10134 return error_mark_node
;
10137 input_location
= declspecs
->locations
[ds_type_spec
];
10138 abstract_virtuals_error (ACU_RETURN
, type
);
10139 input_location
= saved_loc
;
10141 /* Pick up type qualifiers which should be applied to `this'. */
10142 memfn_quals
= declarator
->u
.function
.qualifiers
;
10143 /* Pick up virt-specifiers. */
10144 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
10145 /* And ref-qualifier, too */
10146 rqual
= declarator
->u
.function
.ref_qualifier
;
10147 /* And tx-qualifier. */
10148 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
10149 /* Pick up the exception specifications. */
10150 raises
= declarator
->u
.function
.exception_specification
;
10151 /* If the exception-specification is ill-formed, let's pretend
10152 there wasn't one. */
10153 if (raises
== error_mark_node
)
10154 raises
= NULL_TREE
;
10157 error_at (location_of (reqs
), "requires-clause on return type");
10158 reqs
= declarator
->u
.function
.requires_clause
;
10160 /* Say it's a definition only for the CALL_EXPR
10161 closest to the identifier. */
10162 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
10164 /* Handle a late-specified return type. */
10167 if (type_uses_auto (type
))
10169 if (!declarator
->u
.function
.late_return_type
)
10171 if (current_class_type
10172 && LAMBDA_TYPE_P (current_class_type
))
10173 /* OK for C++11 lambdas. */;
10174 else if (cxx_dialect
< cxx14
)
10176 error ("%qs function uses "
10177 "%<auto%> type specifier without trailing "
10178 "return type", name
);
10179 inform (input_location
, "deduced return type "
10180 "only available with -std=c++14 or "
10185 error ("virtual function cannot "
10186 "have deduced return type");
10190 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
10192 error ("%qs function with trailing return type has"
10193 " %qT as its type rather than plain %<auto%>",
10195 return error_mark_node
;
10198 else if (declarator
->u
.function
.late_return_type
10199 && sfk
!= sfk_conversion
)
10201 if (cxx_dialect
< cxx11
)
10202 /* Not using maybe_warn_cpp0x because this should
10203 always be an error. */
10204 error ("trailing return type only available with "
10205 "-std=c++11 or -std=gnu++11");
10207 error ("%qs function with trailing return type not "
10208 "declared with %<auto%> type specifier", name
);
10209 return error_mark_node
;
10212 type
= splice_late_return_type
10213 (type
, declarator
->u
.function
.late_return_type
);
10214 if (type
== error_mark_node
)
10215 return error_mark_node
;
10217 if (declarator
->u
.function
.late_return_type
)
10218 late_return_type_p
= true;
10220 if (ctype
== NULL_TREE
10221 && decl_context
== FIELD
10224 ctype
= current_class_type
;
10226 if (ctype
&& (sfk
== sfk_constructor
10227 || sfk
== sfk_destructor
))
10229 /* We are within a class's scope. If our declarator name
10230 is the same as the class name, and we are defining
10231 a function, then it is a constructor/destructor, and
10232 therefore returns a void type. */
10234 /* ISO C++ 12.4/2. A destructor may not be declared
10235 const or volatile. A destructor may not be static.
10236 A destructor may not be declared with ref-qualifier.
10238 ISO C++ 12.1. A constructor may not be declared
10239 const or volatile. A constructor may not be
10240 virtual. A constructor may not be static.
10241 A constructor may not be declared with ref-qualifier. */
10243 error ((flags
== DTOR_FLAG
)
10244 ? G_("destructor cannot be static member function")
10245 : G_("constructor cannot be static member function"));
10248 error ((flags
== DTOR_FLAG
)
10249 ? G_("destructors may not be cv-qualified")
10250 : G_("constructors may not be cv-qualified"));
10251 memfn_quals
= TYPE_UNQUALIFIED
;
10256 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
10257 error ((flags
== DTOR_FLAG
)
10258 ? "destructors may not be ref-qualified"
10259 : "constructors may not be ref-qualified");
10260 rqual
= REF_QUAL_NONE
;
10263 if (decl_context
== FIELD
10264 && !member_function_or_else (ctype
,
10265 current_class_type
,
10267 return error_mark_node
;
10269 if (flags
!= DTOR_FLAG
)
10271 /* It's a constructor. */
10272 if (explicitp
== 1)
10276 permerror (input_location
,
10277 "constructors cannot be declared %<virtual%>");
10280 if (decl_context
== FIELD
10281 && sfk
!= sfk_constructor
)
10282 return error_mark_node
;
10284 if (decl_context
== FIELD
)
10291 /* Cannot be both friend and virtual. */
10292 error ("virtual functions cannot be friends");
10295 if (decl_context
== NORMAL
)
10296 error ("friend declaration not in class definition");
10297 if (current_function_decl
&& funcdef_flag
)
10298 error ("can%'t define friend function %qs in a local "
10299 "class definition",
10302 else if (ctype
&& sfk
== sfk_conversion
)
10304 if (explicitp
== 1)
10306 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
10309 if (late_return_type_p
)
10310 error ("a conversion function cannot have a trailing return type");
10313 arg_types
= grokparms (declarator
->u
.function
.parameters
,
10316 if (inner_declarator
10317 && inner_declarator
->kind
== cdk_id
10318 && inner_declarator
->u
.id
.sfk
== sfk_destructor
10319 && arg_types
!= void_list_node
)
10321 error ("destructors may not have parameters");
10322 arg_types
= void_list_node
;
10326 type
= build_function_type (type
, arg_types
);
10328 tree attrs
= declarator
->std_attributes
;
10331 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
10332 /* transaction_safe applies to the type, but
10333 transaction_safe_dynamic applies to the function. */
10334 if (is_attribute_p ("transaction_safe", tx_qual
))
10335 attrs
= chainon (attrs
, att
);
10337 returned_attrs
= chainon (returned_attrs
, att
);
10342 The optional attribute-specifier-seq appertains to
10343 the function type. */
10344 decl_attributes (&type
, attrs
, 0);
10349 case cdk_reference
:
10351 /* Filter out pointers-to-references and references-to-references.
10352 We can get these if a TYPE_DECL is used. */
10354 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10356 if (declarator
->kind
!= cdk_reference
)
10358 error ("cannot declare pointer to %q#T", type
);
10359 type
= TREE_TYPE (type
);
10362 /* In C++0x, we allow reference to reference declarations
10363 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
10364 and template type arguments [14.3.1/4 temp.arg.type]. The
10365 check for direct reference to reference declarations, which
10366 are still forbidden, occurs below. Reasoning behind the change
10367 can be found in DR106, DR540, and the rvalue reference
10369 else if (cxx_dialect
== cxx98
)
10371 error ("cannot declare reference to %q#T", type
);
10372 type
= TREE_TYPE (type
);
10375 else if (VOID_TYPE_P (type
))
10377 if (declarator
->kind
== cdk_reference
)
10378 error ("cannot declare reference to %q#T", type
);
10379 else if (declarator
->kind
== cdk_ptrmem
)
10380 error ("cannot declare pointer to %q#T member", type
);
10383 /* We now know that the TYPE_QUALS don't apply to the decl,
10384 but to the target of the pointer. */
10385 type_quals
= TYPE_UNQUALIFIED
;
10387 /* This code used to handle METHOD_TYPE, but I don't think it's
10388 possible to get it here anymore. */
10389 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
10390 if (declarator
->kind
== cdk_ptrmem
10391 && TREE_CODE (type
) == FUNCTION_TYPE
)
10393 memfn_quals
|= type_memfn_quals (type
);
10394 type
= build_memfn_type (type
,
10395 declarator
->u
.pointer
.class_type
,
10398 if (type
== error_mark_node
)
10399 return error_mark_node
;
10401 rqual
= REF_QUAL_NONE
;
10402 memfn_quals
= TYPE_UNQUALIFIED
;
10405 if (TREE_CODE (type
) == FUNCTION_TYPE
10406 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
10407 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
10408 error (declarator
->kind
== cdk_reference
10409 ? G_("cannot declare reference to qualified function type %qT")
10410 : G_("cannot declare pointer to qualified function type %qT"),
10413 /* When the pointed-to type involves components of variable size,
10414 care must be taken to ensure that the size evaluation code is
10415 emitted early enough to dominate all the possible later uses
10416 and late enough for the variables on which it depends to have
10419 This is expected to happen automatically when the pointed-to
10420 type has a name/declaration of it's own, but special attention
10421 is required if the type is anonymous.
10423 We handle the NORMAL and FIELD contexts here by inserting a
10424 dummy statement that just evaluates the size at a safe point
10425 and ensures it is not deferred until e.g. within a deeper
10426 conditional context (c++/43555).
10428 We expect nothing to be needed here for PARM or TYPENAME.
10429 Evaluating the size at this point for TYPENAME would
10430 actually be incorrect, as we might be in the middle of an
10431 expression with side effects on the pointed-to type size
10432 "arguments" prior to the pointer declaration point and the
10433 size evaluation could end up prior to the side effects. */
10435 if (!TYPE_NAME (type
)
10436 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
10437 && at_function_scope_p ()
10438 && variably_modified_type_p (type
, NULL_TREE
))
10439 /* Force evaluation of the SAVE_EXPR. */
10440 finish_expr_stmt (TYPE_SIZE (type
));
10442 if (declarator
->kind
== cdk_reference
)
10444 /* In C++0x, the type we are creating a reference to might be
10445 a typedef which is itself a reference type. In that case,
10446 we follow the reference collapsing rules in
10447 [7.1.3/8 dcl.typedef] to create the final reference type:
10449 "If a typedef TD names a type that is a reference to a type
10450 T, an attempt to create the type 'lvalue reference to cv TD'
10451 creates the type 'lvalue reference to T,' while an attempt
10452 to create the type "rvalue reference to cv TD' creates the
10455 if (VOID_TYPE_P (type
))
10456 /* We already gave an error. */;
10457 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10459 if (declarator
->u
.reference
.rvalue_ref
)
10460 /* Leave type alone. */;
10462 type
= cp_build_reference_type (TREE_TYPE (type
), false);
10465 type
= cp_build_reference_type
10466 (type
, declarator
->u
.reference
.rvalue_ref
);
10468 /* In C++0x, we need this check for direct reference to
10469 reference declarations, which are forbidden by
10470 [8.3.2/5 dcl.ref]. Reference to reference declarations
10471 are only allowed indirectly through typedefs and template
10472 type arguments. Example:
10474 void foo(int & &); // invalid ref-to-ref decl
10476 typedef int & int_ref;
10477 void foo(int_ref &); // valid ref-to-ref decl
10479 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
10480 error ("cannot declare reference to %q#T, which is not "
10481 "a typedef or a template type argument", type
);
10483 else if (TREE_CODE (type
) == METHOD_TYPE
)
10484 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10485 else if (declarator
->kind
== cdk_ptrmem
)
10487 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
10488 != NAMESPACE_DECL
);
10489 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
10490 /* We will already have complained. */
10491 type
= error_mark_node
;
10493 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
10497 type
= build_pointer_type (type
);
10499 /* Process a list of type modifier keywords (such as
10500 const or volatile) that were given inside the `*' or `&'. */
10502 if (declarator
->u
.pointer
.qualifiers
)
10505 = cp_build_qualified_type (type
,
10506 declarator
->u
.pointer
.qualifiers
);
10507 type_quals
= cp_type_quals (type
);
10510 /* Apply C++11 attributes to the pointer, and not to the
10511 type pointed to. This is unlike what is done for GNU
10512 attributes above. It is to comply with [dcl.ptr]/1:
10514 [the optional attribute-specifier-seq (7.6.1) appertains
10515 to the pointer and not to the object pointed to]. */
10516 if (declarator
->std_attributes
)
10517 decl_attributes (&type
, declarator
->std_attributes
,
10527 gcc_unreachable ();
10531 /* A `constexpr' specifier used in an object declaration declares
10532 the object as `const'. */
10533 if (constexpr_p
&& innermost_code
!= cdk_function
)
10535 /* DR1688 says that a `constexpr' specifier in combination with
10536 `volatile' is valid. */
10538 if (TREE_CODE (type
) != REFERENCE_TYPE
)
10540 type_quals
|= TYPE_QUAL_CONST
;
10541 type
= cp_build_qualified_type (type
, type_quals
);
10545 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
10546 && TREE_CODE (type
) != FUNCTION_TYPE
10547 && TREE_CODE (type
) != METHOD_TYPE
10548 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
10550 error ("template-id %qD used as a declarator",
10552 unqualified_id
= dname
;
10555 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10556 qualified with a class-name, turn it into a METHOD_TYPE, unless
10557 we know that the function is static. We take advantage of this
10558 opportunity to do other processing that pertains to entities
10559 explicitly declared to be class members. Note that if DECLARATOR
10560 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10561 would not have exited the loop above. */
10563 && declarator
->u
.id
.qualifying_scope
10564 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
10566 ctype
= declarator
->u
.id
.qualifying_scope
;
10567 ctype
= TYPE_MAIN_VARIANT (ctype
);
10568 template_count
= num_template_headers_for_class (ctype
);
10570 if (ctype
== current_class_type
)
10574 permerror (input_location
, "member functions are implicitly friends of their class");
10578 permerror (declarator
->id_loc
,
10579 "extra qualification %<%T::%> on member %qs",
10582 else if (/* If the qualifying type is already complete, then we
10583 can skip the following checks. */
10584 !COMPLETE_TYPE_P (ctype
)
10585 && (/* If the function is being defined, then
10586 qualifying type must certainly be complete. */
10588 /* A friend declaration of "T::f" is OK, even if
10589 "T" is a template parameter. But, if this
10590 function is not a friend, the qualifying type
10591 must be a class. */
10592 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10593 /* For a declaration, the type need not be
10594 complete, if either it is dependent (since there
10595 is no meaningful definition of complete in that
10596 case) or the qualifying class is currently being
10598 || !(dependent_type_p (ctype
)
10599 || currently_open_class (ctype
)))
10600 /* Check that the qualifying type is complete. */
10601 && !complete_type_or_else (ctype
, NULL_TREE
))
10602 return error_mark_node
;
10603 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10605 if (current_class_type
10606 && (!friendp
|| funcdef_flag
))
10608 error (funcdef_flag
10609 ? G_("cannot define member function %<%T::%s%> "
10611 : G_("cannot declare member function %<%T::%s%> "
10613 ctype
, name
, current_class_type
);
10614 return error_mark_node
;
10617 else if (typedef_p
&& current_class_type
)
10619 error ("cannot declare member %<%T::%s%> within %qT",
10620 ctype
, name
, current_class_type
);
10621 return error_mark_node
;
10625 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10626 ctype
= current_class_type
;
10628 /* Now TYPE has the actual type. */
10630 if (returned_attrs
)
10633 *attrlist
= chainon (returned_attrs
, *attrlist
);
10635 attrlist
= &returned_attrs
;
10639 && declarator
->kind
== cdk_id
10640 && declarator
->std_attributes
)
10641 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10642 a declarator-id appertains to the entity that is declared. */
10643 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10645 /* Handle parameter packs. */
10646 if (parameter_pack_p
)
10648 if (decl_context
== PARM
)
10649 /* Turn the type into a pack expansion.*/
10650 type
= make_pack_expansion (type
);
10652 error ("non-parameter %qs cannot be a parameter pack", name
);
10655 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10656 && !processing_template_decl
10657 && variably_modified_type_p (type
, NULL_TREE
))
10659 if (decl_context
== FIELD
)
10660 error ("data member may not have variably modified type %qT", type
);
10662 error ("parameter may not have variably modified type %qT", type
);
10663 type
= error_mark_node
;
10666 if (explicitp
== 1 || (explicitp
&& friendp
))
10668 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10669 in the declaration of a constructor or conversion function within
10670 a class definition. */
10671 if (!current_class_type
)
10672 error_at (declspecs
->locations
[ds_explicit
],
10673 "%<explicit%> outside class declaration");
10675 error_at (declspecs
->locations
[ds_explicit
],
10676 "%<explicit%> in friend declaration");
10678 error_at (declspecs
->locations
[ds_explicit
],
10679 "only declarations of constructors and conversion operators "
10680 "can be %<explicit%>");
10684 if (storage_class
== sc_mutable
)
10686 if (decl_context
!= FIELD
|| friendp
)
10688 error ("non-member %qs cannot be declared %<mutable%>", name
);
10689 storage_class
= sc_none
;
10691 else if (decl_context
== TYPENAME
|| typedef_p
)
10693 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10694 storage_class
= sc_none
;
10696 else if (TREE_CODE (type
) == FUNCTION_TYPE
10697 || TREE_CODE (type
) == METHOD_TYPE
)
10699 error ("function %qs cannot be declared %<mutable%>", name
);
10700 storage_class
= sc_none
;
10704 error ("static %qs cannot be declared %<mutable%>", name
);
10705 storage_class
= sc_none
;
10707 else if (type_quals
& TYPE_QUAL_CONST
)
10709 error ("const %qs cannot be declared %<mutable%>", name
);
10710 storage_class
= sc_none
;
10712 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10714 permerror (input_location
, "reference %qs cannot be declared "
10715 "%<mutable%>", name
);
10716 storage_class
= sc_none
;
10720 /* If this is declaring a typedef name, return a TYPE_DECL. */
10721 if (typedef_p
&& decl_context
!= TYPENAME
)
10725 /* Note that the grammar rejects storage classes
10726 in typenames, fields or parameters. */
10727 if (current_lang_name
== lang_name_java
)
10728 TYPE_FOR_JAVA (type
) = 1;
10730 /* This declaration:
10732 typedef void f(int) const;
10734 declares a function type which is not a member of any
10735 particular class, but which is cv-qualified; for
10736 example "f S::*" declares a pointer to a const-qualified
10737 member function of S. We record the cv-qualification in the
10739 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10741 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10743 /* We have now dealt with these qualifiers. */
10744 memfn_quals
= TYPE_UNQUALIFIED
;
10745 rqual
= REF_QUAL_NONE
;
10748 if (type_uses_auto (type
))
10750 error ("typedef declared %<auto%>");
10751 type
= error_mark_node
;
10755 error_at (location_of (reqs
), "requires-clause on typedef");
10757 if (decl_context
== FIELD
)
10758 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10760 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10761 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10762 error_at (DECL_SOURCE_LOCATION (decl
),
10763 "typedef name may not be a nested-name-specifier");
10764 TREE_TYPE (decl
) = error_mark_node
;
10767 if (decl_context
!= FIELD
)
10769 if (!current_function_decl
)
10770 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10771 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10772 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10773 (current_function_decl
)))
10774 /* The TYPE_DECL is "abstract" because there will be
10775 clones of this constructor/destructor, and there will
10776 be copies of this TYPE_DECL generated in those
10777 clones. The decloning optimization (for space) may
10778 revert this subsequently if it determines that
10779 the clones should share a common implementation. */
10780 DECL_ABSTRACT_P (decl
) = true;
10782 else if (current_class_type
10783 && constructor_name_p (unqualified_id
, current_class_type
))
10784 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10785 "as enclosing class",
10788 /* If the user declares "typedef struct {...} foo" then the
10789 struct will have an anonymous name. Fill that name in now.
10790 Nothing can refer to it, so nothing needs know about the name
10792 if (type
!= error_mark_node
10794 && TYPE_NAME (type
)
10795 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10796 && TYPE_ANONYMOUS_P (type
)
10797 && declspecs
->type_definition_p
10798 && attributes_naming_typedef_ok (*attrlist
)
10799 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10803 /* Replace the anonymous name with the real name everywhere. */
10804 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10806 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
10807 /* We do not rename the debug info representing the
10808 anonymous tagged type because the standard says in
10809 [dcl.typedef] that the naming applies only for
10810 linkage purposes. */
10811 /*debug_hooks->set_name (t, decl);*/
10812 TYPE_NAME (t
) = decl
;
10815 if (TYPE_LANG_SPECIFIC (type
))
10816 TYPE_WAS_ANONYMOUS (type
) = 1;
10818 /* If this is a typedef within a template class, the nested
10819 type is a (non-primary) template. The name for the
10820 template needs updating as well. */
10821 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10822 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10823 = TYPE_IDENTIFIER (type
);
10825 /* Adjust linkage now that we aren't anonymous anymore. */
10826 reset_type_linkage (type
);
10828 /* FIXME remangle member functions; member functions of a
10829 type with external linkage have external linkage. */
10833 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10834 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10836 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10837 memfn_quals
!= TYPE_UNQUALIFIED
,
10838 inlinep
, friendp
, raises
!= NULL_TREE
);
10840 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10841 /* Acknowledge that this was written:
10842 `using analias = atype;'. */
10843 TYPE_DECL_ALIAS_P (decl
) = 1;
10848 /* Detect the case of an array type of unspecified size
10849 which came, as such, direct from a typedef name.
10850 We must copy the type, so that the array's domain can be
10851 individually set by the object's initializer. */
10853 if (type
&& typedef_type
10854 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10855 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10856 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10858 /* Detect where we're using a typedef of function type to declare a
10859 function. PARMS will not be set, so we must create it now. */
10861 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10863 tree decls
= NULL_TREE
;
10866 for (args
= TYPE_ARG_TYPES (type
);
10867 args
&& args
!= void_list_node
;
10868 args
= TREE_CHAIN (args
))
10870 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10872 DECL_CHAIN (decl
) = decls
;
10876 parms
= nreverse (decls
);
10878 if (decl_context
!= TYPENAME
)
10880 /* The qualifiers on the function type become the qualifiers on
10881 the non-static member function. */
10882 memfn_quals
|= type_memfn_quals (type
);
10883 rqual
= type_memfn_rqual (type
);
10884 type_quals
= TYPE_UNQUALIFIED
;
10888 /* If this is a type name (such as, in a cast or sizeof),
10889 compute the type and return it now. */
10891 if (decl_context
== TYPENAME
)
10893 /* Note that here we don't care about type_quals. */
10895 /* Special case: "friend class foo" looks like a TYPENAME context. */
10900 error ("%<inline%> specified for friend class declaration");
10906 /* Don't allow friend declaration without a class-key. */
10907 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10908 permerror (input_location
, "template parameters cannot be friends");
10909 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10910 permerror (input_location
, "friend declaration requires class-key, "
10911 "i.e. %<friend class %T::%D%>",
10912 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10914 permerror (input_location
, "friend declaration requires class-key, "
10915 "i.e. %<friend %#T%>",
10919 /* Only try to do this stuff if we didn't already give up. */
10920 if (type
!= integer_type_node
)
10922 /* A friendly class? */
10923 if (current_class_type
)
10924 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10925 /*complain=*/true);
10927 error ("trying to make class %qT a friend of global scope",
10930 type
= void_type_node
;
10933 else if (memfn_quals
|| rqual
)
10935 if (ctype
== NULL_TREE
10936 && TREE_CODE (type
) == METHOD_TYPE
)
10937 ctype
= TYPE_METHOD_BASETYPE (type
);
10940 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10941 /* Core issue #547: need to allow this in template type args.
10942 Allow it in general in C++11 for alias-declarations. */
10943 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10944 && TREE_CODE (type
) == FUNCTION_TYPE
)
10945 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10947 error ("invalid qualifiers on non-member function type");
10951 error_at (location_of (reqs
), "requires-clause on type-id");
10955 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10956 && decl_context
!= CATCHPARM
10957 && TREE_CODE (type
) != UNION_TYPE
10960 error ("abstract declarator %qT used as declaration", type
);
10961 return error_mark_node
;
10964 /* Only functions may be declared using an operator-function-id. */
10966 && IDENTIFIER_OPNAME_P (unqualified_id
)
10967 && TREE_CODE (type
) != FUNCTION_TYPE
10968 && TREE_CODE (type
) != METHOD_TYPE
)
10970 error ("declaration of %qD as non-function", unqualified_id
);
10971 return error_mark_node
;
10975 && TREE_CODE (type
) != FUNCTION_TYPE
10976 && TREE_CODE (type
) != METHOD_TYPE
)
10977 error_at (location_of (reqs
),
10978 "requires-clause on declaration of non-function type %qT",
10981 /* We don't check parameter types here because we can emit a better
10982 error message later. */
10983 if (decl_context
!= PARM
)
10985 type
= check_var_type (unqualified_id
, type
);
10986 if (type
== error_mark_node
)
10987 return error_mark_node
;
10990 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10991 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10993 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10995 if (ctype
|| in_namespace
)
10996 error ("cannot use %<::%> in parameter declaration");
10998 if (type_uses_auto (type
))
11000 if (cxx_dialect
>= cxx14
)
11001 error ("%<auto%> parameter not permitted in this context");
11003 error ("parameter declared %<auto%>");
11004 type
= error_mark_node
;
11007 /* A parameter declared as an array of T is really a pointer to T.
11008 One declared as a function is really a pointer to a function.
11009 One declared as a member is really a pointer to member. */
11011 if (TREE_CODE (type
) == ARRAY_TYPE
)
11013 /* Transfer const-ness of array into that of type pointed to. */
11014 type
= build_pointer_type (TREE_TYPE (type
));
11015 type_quals
= TYPE_UNQUALIFIED
;
11016 array_parameter_p
= true;
11018 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
11019 type
= build_pointer_type (type
);
11022 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
11023 && !NEW_DELETE_OPNAME_P (unqualified_id
))
11025 cp_cv_quals real_quals
= memfn_quals
;
11026 if (cxx_dialect
< cxx14
&& constexpr_p
11027 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
11028 real_quals
|= TYPE_QUAL_CONST
;
11029 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
11033 tree decl
= NULL_TREE
;
11035 if (decl_context
== PARM
)
11037 decl
= cp_build_parm_decl (unqualified_id
, type
);
11038 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
11040 bad_specifiers (decl
, BSP_PARM
, virtualp
,
11041 memfn_quals
!= TYPE_UNQUALIFIED
,
11042 inlinep
, friendp
, raises
!= NULL_TREE
);
11044 else if (decl_context
== FIELD
)
11046 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
11047 && type_uses_auto (type
))
11049 error ("non-static data member declared %<auto%>");
11050 type
= error_mark_node
;
11053 /* The C99 flexible array extension. */
11054 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
11055 && TYPE_DOMAIN (type
) == NULL_TREE
)
11058 && (TREE_CODE (ctype
) == UNION_TYPE
11059 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
11061 error ("flexible array member in union");
11062 type
= error_mark_node
;
11066 /* Flexible array member has a null domain. */
11067 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
11071 if (type
== error_mark_node
)
11073 /* Happens when declaring arrays of sizes which
11074 are error_mark_node, for example. */
11077 else if (in_namespace
&& !friendp
)
11079 /* Something like struct S { int N::j; }; */
11080 error ("invalid use of %<::%>");
11081 return error_mark_node
;
11083 else if (TREE_CODE (type
) == FUNCTION_TYPE
11084 || TREE_CODE (type
) == METHOD_TYPE
)
11087 tree function_context
;
11091 /* This should never happen in pure C++ (the check
11092 could be an assert). It could happen in
11093 Objective-C++ if someone writes invalid code that
11094 uses a function declaration for an instance
11095 variable or property (instance variables and
11096 properties are parsed as FIELD_DECLs, but they are
11097 part of an Objective-C class, not a C++ class).
11098 That code is invalid and is caught by this
11102 error ("declaration of function %qD in invalid context",
11104 return error_mark_node
;
11107 /* ``A union may [ ... ] not [ have ] virtual functions.''
11109 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11111 error ("function %qD declared %<virtual%> inside a union",
11113 return error_mark_node
;
11116 if (NEW_DELETE_OPNAME_P (unqualified_id
))
11120 error ("%qD cannot be declared %<virtual%>, since it "
11121 "is always static",
11128 /* Check that the name used for a destructor makes sense. */
11129 if (sfk
== sfk_destructor
)
11131 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
11135 gcc_assert (friendp
);
11136 error ("expected qualified name in friend declaration "
11137 "for destructor %qD", uqname
);
11138 return error_mark_node
;
11141 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
11143 error ("declaration of %qD as member of %qT",
11145 return error_mark_node
;
11149 error ("a destructor cannot be %<concept%>");
11150 return error_mark_node
;
11154 error ("a destructor cannot be %<constexpr%>");
11155 return error_mark_node
;
11158 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
11160 error ("expected qualified name in friend declaration "
11161 "for constructor %qD",
11162 id_declarator
->u
.id
.unqualified_name
);
11163 return error_mark_node
;
11165 if (sfk
== sfk_constructor
)
11168 error ("a constructor cannot be %<concept%>");
11169 return error_mark_node
;
11173 error ("a concept cannot be a member function");
11177 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11179 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
11180 if (variable_template_p (tmpl
))
11182 error ("specialization of variable template %qD "
11183 "declared as function", tmpl
);
11184 inform (DECL_SOURCE_LOCATION (tmpl
),
11185 "variable template declared here");
11186 return error_mark_node
;
11190 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11191 function_context
= (ctype
!= NULL_TREE
) ?
11192 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11193 publicp
= (! friendp
|| ! staticp
)
11194 && function_context
== NULL_TREE
;
11196 if (late_return_type_p
)
11197 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11199 decl
= grokfndecl (ctype
, type
,
11200 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
11201 ? unqualified_id
: dname
,
11205 virtualp
, flags
, memfn_quals
, rqual
, raises
,
11206 friendp
? -1 : 0, friendp
, publicp
,
11207 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11208 initialized
== SD_DELETED
, sfk
,
11209 funcdef_flag
, template_count
, in_namespace
,
11210 attrlist
, declarator
->id_loc
);
11211 decl
= set_virt_specifiers (decl
, virt_specifiers
);
11212 if (decl
== NULL_TREE
)
11213 return error_mark_node
;
11215 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11216 /* The decl and setting of decl_attr is also turned off. */
11217 decl
= build_decl_attribute_variant (decl
, decl_attr
);
11220 /* [class.conv.ctor]
11222 A constructor declared without the function-specifier
11223 explicit that can be called with a single parameter
11224 specifies a conversion from the type of its first
11225 parameter to the type of its class. Such a constructor
11226 is called a converting constructor. */
11227 if (explicitp
== 2)
11228 DECL_NONCONVERTING_P (decl
) = 1;
11230 else if (!staticp
&& !dependent_type_p (type
)
11231 && !COMPLETE_TYPE_P (complete_type (type
))
11232 && (TREE_CODE (type
) != ARRAY_TYPE
11233 || !COMPLETE_TYPE_P (TREE_TYPE (type
))
11234 || initialized
== 0))
11236 if (TREE_CODE (type
) != ARRAY_TYPE
11237 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
11239 if (unqualified_id
)
11241 error ("field %qD has incomplete type %qT",
11242 unqualified_id
, type
);
11243 cxx_incomplete_type_inform (strip_array_types (type
));
11246 error ("name %qT has incomplete type", type
);
11248 type
= error_mark_node
;
11256 error ("%qE is neither function nor member function; "
11257 "cannot be declared friend", unqualified_id
);
11265 /* Friends are treated specially. */
11266 if (ctype
== current_class_type
)
11267 ; /* We already issued a permerror. */
11268 else if (decl
&& DECL_NAME (decl
))
11270 if (template_class_depth (current_class_type
) == 0)
11272 decl
= check_explicit_specialization
11273 (unqualified_id
, decl
, template_count
,
11274 2 * funcdef_flag
+ 4);
11275 if (decl
== error_mark_node
)
11276 return error_mark_node
;
11279 decl
= do_friend (ctype
, unqualified_id
, decl
,
11285 return error_mark_node
;
11288 /* Structure field. It may not be a function, except for C++. */
11290 if (decl
== NULL_TREE
)
11294 /* C++ allows static class members. All other work
11295 for this is done by grokfield. */
11296 decl
= build_lang_decl_loc (declarator
11297 ? declarator
->id_loc
11299 VAR_DECL
, unqualified_id
, type
);
11300 set_linkage_for_static_data_member (decl
);
11301 /* Even if there is an in-class initialization, DECL
11302 is considered undefined until an out-of-class
11303 definition is provided. */
11304 DECL_EXTERNAL (decl
) = 1;
11308 CP_DECL_THREAD_LOCAL_P (decl
) = true;
11309 if (!processing_template_decl
)
11310 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
11311 if (declspecs
->gnu_thread_keyword_p
)
11312 SET_DECL_GNU_TLS_P (decl
);
11315 error ("static data member %qE declared %<concept%>",
11317 else if (constexpr_p
&& !initialized
)
11319 error ("constexpr static data member %qD must have an "
11320 "initializer", decl
);
11321 constexpr_p
= false;
11327 error ("non-static data member %qE declared %<concept%>",
11329 else if (constexpr_p
)
11331 error ("non-static data member %qE declared %<constexpr%>",
11333 constexpr_p
= false;
11335 decl
= build_decl (input_location
,
11336 FIELD_DECL
, unqualified_id
, type
);
11337 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11338 if (bitfield
&& !unqualified_id
)
11339 TREE_NO_WARNING (decl
) = 1;
11341 if (storage_class
== sc_mutable
)
11343 DECL_MUTABLE_P (decl
) = 1;
11344 storage_class
= sc_none
;
11349 /* An attempt is being made to initialize a non-static
11350 member. This is new in C++11. */
11351 maybe_warn_cpp0x (CPP0X_NSDMI
);
11353 /* If this has been parsed with static storage class, but
11354 errors forced staticp to be cleared, ensure NSDMI is
11356 if (declspecs
->storage_class
== sc_static
)
11357 DECL_INITIAL (decl
) = error_mark_node
;
11361 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
11362 memfn_quals
!= TYPE_UNQUALIFIED
,
11363 inlinep
, friendp
, raises
!= NULL_TREE
);
11366 else if (TREE_CODE (type
) == FUNCTION_TYPE
11367 || TREE_CODE (type
) == METHOD_TYPE
)
11369 tree original_name
;
11372 if (!unqualified_id
)
11373 return error_mark_node
;
11375 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11376 original_name
= dname
;
11378 original_name
= unqualified_id
;
11380 if (storage_class
== sc_auto
)
11381 error ("storage class %<auto%> invalid for function %qs", name
);
11382 else if (storage_class
== sc_register
)
11383 error ("storage class %<register%> invalid for function %qs", name
);
11386 if (declspecs
->gnu_thread_keyword_p
)
11387 error ("storage class %<__thread%> invalid for function %qs",
11390 error ("storage class %<thread_local%> invalid for function %qs",
11394 if (virt_specifiers
)
11395 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
11396 /* Function declaration not at top level.
11397 Storage classes other than `extern' are not allowed
11398 and `extern' makes no difference. */
11399 if (! toplevel_bindings_p ()
11400 && (storage_class
== sc_static
11401 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
11404 if (storage_class
== sc_static
)
11405 pedwarn (input_location
, OPT_Wpedantic
,
11406 "%<static%> specified invalid for function %qs "
11407 "declared out of global scope", name
);
11409 pedwarn (input_location
, OPT_Wpedantic
,
11410 "%<inline%> specifier invalid for function %qs "
11411 "declared out of global scope", name
);
11414 if (ctype
== NULL_TREE
)
11418 error ("virtual non-class function %qs", name
);
11421 else if (sfk
== sfk_constructor
11422 || sfk
== sfk_destructor
)
11424 error (funcdef_flag
11425 ? G_("%qs defined in a non-class scope")
11426 : G_("%qs declared in a non-class scope"), name
);
11431 /* Record whether the function is public. */
11432 publicp
= (ctype
!= NULL_TREE
11433 || storage_class
!= sc_static
);
11435 if (late_return_type_p
)
11436 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11438 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
11439 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
11442 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11443 initialized
== SD_DELETED
,
11446 template_count
, in_namespace
, attrlist
,
11447 declarator
->id_loc
);
11448 if (decl
== NULL_TREE
)
11449 return error_mark_node
;
11453 int invalid_static
= 0;
11455 /* Don't allow a static member function in a class, and forbid
11456 declaring main to be static. */
11457 if (TREE_CODE (type
) == METHOD_TYPE
)
11459 permerror (input_location
, "cannot declare member function %qD to have "
11460 "static linkage", decl
);
11461 invalid_static
= 1;
11463 else if (current_function_decl
)
11465 /* FIXME need arm citation */
11466 error ("cannot declare static function inside another function");
11467 invalid_static
= 1;
11470 if (invalid_static
)
11473 storage_class
= sc_none
;
11479 /* It's a variable. */
11481 /* An uninitialized decl with `extern' is a reference. */
11482 decl
= grokvardecl (type
, dname
, unqualified_id
,
11485 ((type_quals
& TYPE_QUAL_CONST
) != 0) | (2 * concept_p
),
11487 ctype
? ctype
: in_namespace
);
11488 if (decl
== NULL_TREE
)
11489 return error_mark_node
;
11491 bad_specifiers (decl
, BSP_VAR
, virtualp
,
11492 memfn_quals
!= TYPE_UNQUALIFIED
,
11493 inlinep
, friendp
, raises
!= NULL_TREE
);
11497 DECL_CONTEXT (decl
) = ctype
;
11500 permerror (input_location
, "%<static%> may not be used when defining "
11501 "(as opposed to declaring) a static data member");
11503 storage_class
= sc_none
;
11505 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
11507 error ("static member %qD declared %<register%>", decl
);
11508 storage_class
= sc_none
;
11510 if (storage_class
== sc_extern
&& pedantic
)
11512 pedwarn (input_location
, OPT_Wpedantic
,
11513 "cannot explicitly declare member %q#D to have "
11514 "extern linkage", decl
);
11515 storage_class
= sc_none
;
11518 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
11520 error ("declaration of constexpr variable %qD is not a definition",
11522 constexpr_p
= false;
11526 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
11528 if (toplevel_bindings_p ())
11530 /* It's common practice (and completely valid) to have a const
11531 be initialized and declared extern. */
11532 if (!(type_quals
& TYPE_QUAL_CONST
))
11533 warning (0, "%qs initialized and declared %<extern%>", name
);
11537 error ("%qs has both %<extern%> and initializer", name
);
11538 return error_mark_node
;
11542 /* Record `register' declaration for warnings on &
11543 and in case doing stupid register allocation. */
11545 if (storage_class
== sc_register
)
11546 DECL_REGISTER (decl
) = 1;
11547 else if (storage_class
== sc_extern
)
11548 DECL_THIS_EXTERN (decl
) = 1;
11549 else if (storage_class
== sc_static
)
11550 DECL_THIS_STATIC (decl
) = 1;
11552 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11553 if (constexpr_p
&& VAR_P (decl
))
11554 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
11556 /* Record constancy and volatility on the DECL itself . There's
11557 no need to do this when processing a template; we'll do this
11558 for the instantiated declaration based on the type of DECL. */
11559 if (!processing_template_decl
)
11560 cp_apply_type_quals_to_decl (type_quals
, decl
);
11566 /* Subroutine of start_function. Ensure that each of the parameter
11567 types (as listed in PARMS) is complete, as is required for a
11568 function definition. */
11571 require_complete_types_for_parms (tree parms
)
11573 for (; parms
; parms
= DECL_CHAIN (parms
))
11575 if (dependent_type_p (TREE_TYPE (parms
)))
11577 if (!VOID_TYPE_P (TREE_TYPE (parms
))
11578 && complete_type_or_else (TREE_TYPE (parms
), parms
))
11580 relayout_decl (parms
);
11581 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
11584 /* grokparms or complete_type_or_else will have already issued
11586 TREE_TYPE (parms
) = error_mark_node
;
11590 /* Returns nonzero if T is a local variable. */
11593 local_variable_p (const_tree t
)
11596 /* A VAR_DECL with a context that is a _TYPE is a static data
11598 && !TYPE_P (CP_DECL_CONTEXT (t
))
11599 /* Any other non-local variable must be at namespace scope. */
11600 && !DECL_NAMESPACE_SCOPE_P (t
))
11601 || (TREE_CODE (t
) == PARM_DECL
))
11607 /* Like local_variable_p, but suitable for use as a tree-walking
11611 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
11614 if (local_variable_p (*tp
)
11615 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
11617 else if (TYPE_P (*tp
))
11618 *walk_subtrees
= 0;
11623 /* Check that ARG, which is a default-argument expression for a
11624 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11625 something goes wrong. DECL may also be a _TYPE node, rather than a
11626 DECL, if there is no DECL available. */
11629 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
11634 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11635 /* We get a DEFAULT_ARG when looking at an in-class declaration
11636 with a default argument. Ignore the argument for now; we'll
11637 deal with it after the class is complete. */
11646 decl_type
= TREE_TYPE (decl
);
11648 if (arg
== error_mark_node
11649 || decl
== error_mark_node
11650 || TREE_TYPE (arg
) == error_mark_node
11651 || decl_type
== error_mark_node
)
11652 /* Something already went wrong. There's no need to check
11654 return error_mark_node
;
11656 /* [dcl.fct.default]
11658 A default argument expression is implicitly converted to the
11660 ++cp_unevaluated_operand
;
11661 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
11663 --cp_unevaluated_operand
;
11665 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
11667 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
11668 && null_ptr_cst_p (arg
))
11669 return nullptr_node
;
11671 /* [dcl.fct.default]
11673 Local variables shall not be used in default argument
11676 The keyword `this' shall not be used in a default argument of a
11677 member function. */
11678 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11681 if (complain
& tf_warning_or_error
)
11683 if (DECL_NAME (var
) == this_identifier
)
11684 permerror (input_location
, "default argument %qE uses %qD",
11687 error ("default argument %qE uses local variable %qD", arg
, var
);
11689 return error_mark_node
;
11696 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11699 type_is_deprecated (tree type
)
11701 enum tree_code code
;
11702 if (TREE_DEPRECATED (type
))
11704 if (TYPE_NAME (type
))
11706 if (TREE_DEPRECATED (TYPE_NAME (type
)))
11712 /* Do warn about using typedefs to a deprecated class. */
11713 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11714 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11716 code
= TREE_CODE (type
);
11718 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11719 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11720 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11721 return type_is_deprecated (TREE_TYPE (type
));
11723 if (TYPE_PTRMEMFUNC_P (type
))
11724 return type_is_deprecated
11725 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11730 /* Decode the list of parameter types for a function type.
11731 Given the list of things declared inside the parens,
11732 return a list of types.
11734 If this parameter does not end with an ellipsis, we append
11737 *PARMS is set to the chain of PARM_DECLs created. */
11740 grokparms (tree parmlist
, tree
*parms
)
11742 tree result
= NULL_TREE
;
11743 tree decls
= NULL_TREE
;
11747 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11749 tree type
= NULL_TREE
;
11750 tree init
= TREE_PURPOSE (parm
);
11751 tree decl
= TREE_VALUE (parm
);
11752 const char *errmsg
;
11754 if (parm
== void_list_node
)
11757 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11760 type
= TREE_TYPE (decl
);
11761 if (VOID_TYPE_P (type
))
11763 if (same_type_p (type
, void_type_node
)
11765 && !DECL_NAME (decl
) && !result
11766 && TREE_CHAIN (parm
) == void_list_node
)
11767 /* DR 577: A parameter list consisting of a single
11768 unnamed parameter of non-dependent type 'void'. */
11770 else if (cv_qualified_p (type
))
11771 error_at (DECL_SOURCE_LOCATION (decl
),
11772 "invalid use of cv-qualified type %qT in "
11773 "parameter declaration", type
);
11775 error_at (DECL_SOURCE_LOCATION (decl
),
11776 "invalid use of type %<void%> in parameter "
11778 /* It's not a good idea to actually create parameters of
11779 type `void'; other parts of the compiler assume that a
11780 void type terminates the parameter list. */
11781 type
= error_mark_node
;
11782 TREE_TYPE (decl
) = error_mark_node
;
11785 if (type
!= error_mark_node
11786 && TYPE_FOR_JAVA (type
)
11787 && MAYBE_CLASS_TYPE_P (type
))
11789 error ("parameter %qD has Java class type", decl
);
11790 type
= error_mark_node
;
11791 TREE_TYPE (decl
) = error_mark_node
;
11795 if (type
!= error_mark_node
11796 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11799 type
= error_mark_node
;
11800 TREE_TYPE (decl
) = error_mark_node
;
11803 if (type
!= error_mark_node
)
11805 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11807 tree deptype
= type_is_deprecated (type
);
11809 warn_deprecated_use (deptype
, NULL_TREE
);
11812 /* Top-level qualifiers on the parameters are
11813 ignored for function types. */
11814 type
= cp_build_qualified_type (type
, 0);
11815 if (TREE_CODE (type
) == METHOD_TYPE
)
11817 error ("parameter %qD invalidly declared method type", decl
);
11818 type
= build_pointer_type (type
);
11819 TREE_TYPE (decl
) = type
;
11821 else if (abstract_virtuals_error (decl
, type
))
11822 any_error
= 1; /* Seems like a good idea. */
11823 else if (POINTER_TYPE_P (type
))
11825 /* [dcl.fct]/6, parameter types cannot contain pointers
11826 (references) to arrays of unknown bound. */
11827 tree t
= TREE_TYPE (type
);
11828 int ptr
= TYPE_PTR_P (type
);
11832 if (TYPE_PTR_P (t
))
11834 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11836 else if (!TYPE_DOMAIN (t
))
11840 if (TREE_CODE (t
) == ARRAY_TYPE
)
11842 ? G_("parameter %qD includes pointer to array of "
11843 "unknown bound %qT")
11844 : G_("parameter %qD includes reference to array of "
11845 "unknown bound %qT"),
11851 else if (init
&& !processing_template_decl
)
11852 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11855 DECL_CHAIN (decl
) = decls
;
11857 result
= tree_cons (init
, type
, result
);
11859 decls
= nreverse (decls
);
11860 result
= nreverse (result
);
11862 result
= chainon (result
, void_list_node
);
11869 /* D is a constructor or overloaded `operator='.
11871 Let T be the class in which D is declared. Then, this function
11874 -1 if D's is an ill-formed constructor or copy assignment operator
11875 whose first parameter is of type `T'.
11876 0 if D is not a copy constructor or copy assignment
11878 1 if D is a copy constructor or copy assignment operator whose
11879 first parameter is a reference to non-const qualified T.
11880 2 if D is a copy constructor or copy assignment operator whose
11881 first parameter is a reference to const qualified T.
11883 This function can be used as a predicate. Positive values indicate
11884 a copy constructor and nonzero values indicate a copy assignment
11888 copy_fn_p (const_tree d
)
11894 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11896 if (TREE_CODE (d
) == TEMPLATE_DECL
11897 || (DECL_TEMPLATE_INFO (d
)
11898 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11899 /* Instantiations of template member functions are never copy
11900 functions. Note that member functions of templated classes are
11901 represented as template functions internally, and we must
11902 accept those as copy functions. */
11905 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11909 arg_type
= TREE_VALUE (args
);
11910 if (arg_type
== error_mark_node
)
11913 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11915 /* Pass by value copy assignment operator. */
11918 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11919 && !TYPE_REF_IS_RVALUE (arg_type
)
11920 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11922 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11928 args
= TREE_CHAIN (args
);
11930 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11931 /* There are more non-optional args. */
11937 /* D is a constructor or overloaded `operator='.
11939 Let T be the class in which D is declared. Then, this function
11940 returns true when D is a move constructor or move assignment
11941 operator, false otherwise. */
11944 move_fn_p (const_tree d
)
11946 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11948 if (cxx_dialect
== cxx98
)
11949 /* There are no move constructors if we are in C++98 mode. */
11952 if (TREE_CODE (d
) == TEMPLATE_DECL
11953 || (DECL_TEMPLATE_INFO (d
)
11954 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11955 /* Instantiations of template member functions are never move
11956 functions. Note that member functions of templated classes are
11957 represented as template functions internally, and we must
11958 accept those as move functions. */
11961 return move_signature_fn_p (d
);
11964 /* D is a constructor or overloaded `operator='.
11966 Then, this function returns true when D has the same signature as a move
11967 constructor or move assignment operator (because either it is such a
11968 ctor/op= or it is a template specialization with the same signature),
11969 false otherwise. */
11972 move_signature_fn_p (const_tree d
)
11976 bool result
= false;
11978 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11982 arg_type
= TREE_VALUE (args
);
11983 if (arg_type
== error_mark_node
)
11986 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11987 && TYPE_REF_IS_RVALUE (arg_type
)
11988 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11992 args
= TREE_CHAIN (args
);
11994 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11995 /* There are more non-optional args. */
12001 /* Remember any special properties of member function DECL. */
12004 grok_special_member_properties (tree decl
)
12008 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
12011 class_type
= DECL_CONTEXT (decl
);
12012 if (DECL_CONSTRUCTOR_P (decl
))
12014 int ctor
= copy_fn_p (decl
);
12016 if (!DECL_ARTIFICIAL (decl
))
12017 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
12023 A non-template constructor for class X is a copy
12024 constructor if its first parameter is of type X&, const
12025 X&, volatile X& or const volatile X&, and either there
12026 are no other parameters or else all other parameters have
12027 default arguments. */
12028 TYPE_HAS_COPY_CTOR (class_type
) = 1;
12029 if (user_provided_p (decl
))
12030 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
12032 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
12034 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
12035 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
12036 else if (move_fn_p (decl
) && user_provided_p (decl
))
12037 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
12038 else if (is_list_ctor (decl
))
12039 TYPE_HAS_LIST_CTOR (class_type
) = 1;
12041 if (DECL_DECLARED_CONSTEXPR_P (decl
)
12042 && !copy_fn_p (decl
) && !move_fn_p (decl
))
12043 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
12045 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
12049 A non-template assignment operator for class X is a copy
12050 assignment operator if its parameter is of type X, X&, const
12051 X&, volatile X& or const volatile X&. */
12053 int assop
= copy_fn_p (decl
);
12057 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
12058 if (user_provided_p (decl
))
12059 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
12061 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
12063 else if (move_fn_p (decl
) && user_provided_p (decl
))
12064 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
12066 /* Destructors are handled in check_methods. */
12069 /* Check a constructor DECL has the correct form. Complains
12070 if the class has a constructor of the form X(X). */
12073 grok_ctor_properties (const_tree ctype
, const_tree decl
)
12075 int ctor_parm
= copy_fn_p (decl
);
12081 A declaration of a constructor for a class X is ill-formed if
12082 its first parameter is of type (optionally cv-qualified) X
12083 and either there are no other parameters or else all other
12084 parameters have default arguments.
12086 We *don't* complain about member template instantiations that
12087 have this form, though; they can occur as we try to decide
12088 what constructor to use during overload resolution. Since
12089 overload resolution will never prefer such a constructor to
12090 the non-template copy constructor (which is either explicitly
12091 or implicitly defined), there's no need to worry about their
12092 existence. Theoretically, they should never even be
12093 instantiated, but that's hard to forestall. */
12094 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
12102 /* An operator with this code is unary, but can also be binary. */
12105 ambi_op_p (enum tree_code code
)
12107 return (code
== INDIRECT_REF
12108 || code
== ADDR_EXPR
12109 || code
== UNARY_PLUS_EXPR
12110 || code
== NEGATE_EXPR
12111 || code
== PREINCREMENT_EXPR
12112 || code
== PREDECREMENT_EXPR
);
12115 /* An operator with this name can only be unary. */
12118 unary_op_p (enum tree_code code
)
12120 return (code
== TRUTH_NOT_EXPR
12121 || code
== BIT_NOT_EXPR
12122 || code
== COMPONENT_REF
12123 || code
== TYPE_EXPR
);
12126 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
12127 errors are issued for invalid declarations. */
12130 grok_op_properties (tree decl
, bool complain
)
12132 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12134 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
12135 tree name
= DECL_NAME (decl
);
12136 enum tree_code operator_code
;
12141 /* Count the number of arguments and check for ellipsis. */
12142 for (argtype
= argtypes
, arity
= 0;
12143 argtype
&& argtype
!= void_list_node
;
12144 argtype
= TREE_CHAIN (argtype
))
12146 ellipsis_p
= !argtype
;
12148 class_type
= DECL_CONTEXT (decl
);
12149 if (class_type
&& !CLASS_TYPE_P (class_type
))
12150 class_type
= NULL_TREE
;
12152 if (DECL_CONV_FN_P (decl
))
12153 operator_code
= TYPE_EXPR
;
12157 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12158 if (ansi_opname (CODE) == name) \
12160 operator_code = (CODE); \
12163 else if (ansi_assopname (CODE) == name) \
12165 operator_code = (CODE); \
12166 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12170 #include "operators.def"
12171 #undef DEF_OPERATOR
12173 gcc_unreachable ();
12176 gcc_assert (operator_code
!= MAX_TREE_CODES
);
12177 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12180 switch (operator_code
)
12183 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
12187 TYPE_GETS_DELETE (class_type
) |= 1;
12191 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
12194 case VEC_DELETE_EXPR
:
12195 TYPE_GETS_DELETE (class_type
) |= 2;
12202 /* [basic.std.dynamic.allocation]/1:
12204 A program is ill-formed if an allocation function is declared
12205 in a namespace scope other than global scope or declared static
12208 The same also holds true for deallocation functions. */
12209 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
12210 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12212 if (DECL_NAMESPACE_SCOPE_P (decl
))
12214 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
12216 error ("%qD may not be declared within a namespace", decl
);
12219 else if (!TREE_PUBLIC (decl
))
12221 error ("%qD may not be declared as static", decl
);
12227 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12229 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12230 DECL_IS_OPERATOR_NEW (decl
) = 1;
12232 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12233 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12236 /* An operator function must either be a non-static member function
12237 or have at least one parameter of a class, a reference to a class,
12238 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12239 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12241 if (operator_code
== TYPE_EXPR
12242 || operator_code
== CALL_EXPR
12243 || operator_code
== COMPONENT_REF
12244 || operator_code
== ARRAY_REF
12245 || operator_code
== NOP_EXPR
)
12247 error ("%qD must be a nonstatic member function", decl
);
12254 if (DECL_STATIC_FUNCTION_P (decl
))
12256 error ("%qD must be either a non-static member "
12257 "function or a non-member function", decl
);
12261 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
12263 tree arg
= non_reference (TREE_VALUE (p
));
12264 if (arg
== error_mark_node
)
12267 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
12268 because these checks are performed even on
12269 template functions. */
12270 if (MAYBE_CLASS_TYPE_P (arg
)
12271 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
12275 if (!p
|| p
== void_list_node
)
12278 error ("%qD must have an argument of class or "
12279 "enumerated type", decl
);
12285 /* There are no restrictions on the arguments to an overloaded
12287 if (operator_code
== CALL_EXPR
)
12290 /* Warn about conversion operators that will never be used. */
12291 if (IDENTIFIER_TYPENAME_P (name
)
12292 && ! DECL_TEMPLATE_INFO (decl
)
12294 /* Warn only declaring the function; there is no need to
12295 warn again about out-of-class definitions. */
12296 && class_type
== current_class_type
)
12298 tree t
= TREE_TYPE (name
);
12299 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12302 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12304 if (VOID_TYPE_P (t
))
12305 warning (OPT_Wconversion
,
12307 ? G_("conversion to a reference to void "
12308 "will never use a type conversion operator")
12309 : G_("conversion to void "
12310 "will never use a type conversion operator"));
12311 else if (class_type
)
12313 if (t
== class_type
)
12314 warning (OPT_Wconversion
,
12316 ? G_("conversion to a reference to the same type "
12317 "will never use a type conversion operator")
12318 : G_("conversion to the same type "
12319 "will never use a type conversion operator"));
12320 /* Don't force t to be complete here. */
12321 else if (MAYBE_CLASS_TYPE_P (t
)
12322 && COMPLETE_TYPE_P (t
)
12323 && DERIVED_FROM_P (t
, class_type
))
12324 warning (OPT_Wconversion
,
12326 ? G_("conversion to a reference to a base class "
12327 "will never use a type conversion operator")
12328 : G_("conversion to a base class "
12329 "will never use a type conversion operator"));
12334 if (operator_code
== COND_EXPR
)
12337 error ("ISO C++ prohibits overloading operator ?:");
12340 else if (ellipsis_p
)
12342 error ("%qD must not have variable number of arguments", decl
);
12345 else if (ambi_op_p (operator_code
))
12348 /* We pick the one-argument operator codes by default, so
12349 we don't have to change anything. */
12351 else if (arity
== 2)
12353 /* If we thought this was a unary operator, we now know
12354 it to be a binary operator. */
12355 switch (operator_code
)
12358 operator_code
= MULT_EXPR
;
12362 operator_code
= BIT_AND_EXPR
;
12365 case UNARY_PLUS_EXPR
:
12366 operator_code
= PLUS_EXPR
;
12370 operator_code
= MINUS_EXPR
;
12373 case PREINCREMENT_EXPR
:
12374 operator_code
= POSTINCREMENT_EXPR
;
12377 case PREDECREMENT_EXPR
:
12378 operator_code
= POSTDECREMENT_EXPR
;
12382 gcc_unreachable ();
12385 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12387 if ((operator_code
== POSTINCREMENT_EXPR
12388 || operator_code
== POSTDECREMENT_EXPR
)
12389 && ! processing_template_decl
12390 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12393 error ("postfix %qD must take %<int%> as its argument",
12396 error ("postfix %qD must take %<int%> as its second "
12404 error ("%qD must take either zero or one argument", decl
);
12406 error ("%qD must take either one or two arguments", decl
);
12410 /* More Effective C++ rule 6. */
12412 && (operator_code
== POSTINCREMENT_EXPR
12413 || operator_code
== POSTDECREMENT_EXPR
12414 || operator_code
== PREINCREMENT_EXPR
12415 || operator_code
== PREDECREMENT_EXPR
))
12417 tree arg
= TREE_VALUE (argtypes
);
12418 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12419 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12420 arg
= TREE_TYPE (arg
);
12421 arg
= TYPE_MAIN_VARIANT (arg
);
12422 if (operator_code
== PREINCREMENT_EXPR
12423 || operator_code
== PREDECREMENT_EXPR
)
12425 if (TREE_CODE (ret
) != REFERENCE_TYPE
12426 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12428 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
12429 build_reference_type (arg
));
12433 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12434 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
12438 else if (unary_op_p (operator_code
))
12443 error ("%qD must take %<void%>", decl
);
12445 error ("%qD must take exactly one argument", decl
);
12449 else /* if (binary_op_p (operator_code)) */
12454 error ("%qD must take exactly one argument", decl
);
12456 error ("%qD must take exactly two arguments", decl
);
12460 /* More Effective C++ rule 7. */
12462 && (operator_code
== TRUTH_ANDIF_EXPR
12463 || operator_code
== TRUTH_ORIF_EXPR
12464 || operator_code
== COMPOUND_EXPR
))
12465 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
12469 /* Effective C++ rule 23. */
12472 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
12473 && (operator_code
== PLUS_EXPR
12474 || operator_code
== MINUS_EXPR
12475 || operator_code
== TRUNC_DIV_EXPR
12476 || operator_code
== MULT_EXPR
12477 || operator_code
== TRUNC_MOD_EXPR
)
12478 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12479 warning (OPT_Weffc__
, "%qD should return by value", decl
);
12481 /* [over.oper]/8 */
12482 for (; argtypes
&& argtypes
!= void_list_node
;
12483 argtypes
= TREE_CHAIN (argtypes
))
12484 if (TREE_PURPOSE (argtypes
))
12486 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12487 if (operator_code
== POSTINCREMENT_EXPR
12488 || operator_code
== POSTDECREMENT_EXPR
)
12490 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
12495 error ("%qD cannot have default arguments", decl
);
12503 /* Return a string giving the keyword associate with CODE. */
12505 static const char *
12506 tag_name (enum tag_types code
)
12518 case typename_type
:
12521 gcc_unreachable ();
12525 /* Name lookup in an elaborated-type-specifier (after the keyword
12526 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12527 elaborated-type-specifier is invalid, issue a diagnostic and return
12528 error_mark_node; otherwise, return the *_TYPE to which it referred.
12529 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12532 check_elaborated_type_specifier (enum tag_types tag_code
,
12534 bool allow_template_p
)
12540 struct S { struct S *p; };
12542 name lookup will find the TYPE_DECL for the implicit "S::S"
12543 typedef. Adjust for that here. */
12544 if (DECL_SELF_REFERENCE_P (decl
))
12545 decl
= TYPE_NAME (TREE_TYPE (decl
));
12547 type
= TREE_TYPE (decl
);
12549 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12550 is false for this case as well. */
12551 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12553 error ("using template type parameter %qT after %qs",
12554 type
, tag_name (tag_code
));
12555 return error_mark_node
;
12557 /* Accept template template parameters. */
12558 else if (allow_template_p
12559 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
12560 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
12564 If the identifier resolves to a typedef-name or the
12565 simple-template-id resolves to an alias template
12566 specialization, the elaborated-type-specifier is ill-formed.
12568 In other words, the only legitimate declaration to use in the
12569 elaborated type specifier is the implicit typedef created when
12570 the type is declared. */
12571 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
12572 && !DECL_SELF_REFERENCE_P (decl
)
12573 && tag_code
!= typename_type
)
12575 if (alias_template_specialization_p (type
))
12576 error ("using alias template specialization %qT after %qs",
12577 type
, tag_name (tag_code
));
12579 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
12580 inform (DECL_SOURCE_LOCATION (decl
),
12581 "%qD has a previous declaration here", decl
);
12582 return error_mark_node
;
12584 else if (TREE_CODE (type
) != RECORD_TYPE
12585 && TREE_CODE (type
) != UNION_TYPE
12586 && tag_code
!= enum_type
12587 && tag_code
!= typename_type
)
12589 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
12590 inform (input_location
, "%q+T has a previous declaration here", type
);
12591 return error_mark_node
;
12593 else if (TREE_CODE (type
) != ENUMERAL_TYPE
12594 && tag_code
== enum_type
)
12596 error ("%qT referred to as enum", type
);
12597 inform (input_location
, "%q+T has a previous declaration here", type
);
12598 return error_mark_node
;
12600 else if (!allow_template_p
12601 && TREE_CODE (type
) == RECORD_TYPE
12602 && CLASSTYPE_IS_TEMPLATE (type
))
12604 /* If a class template appears as elaborated type specifier
12605 without a template header such as:
12607 template <class T> class C {};
12608 void f(class C); // No template header here
12610 then the required template argument is missing. */
12611 error ("template argument required for %<%s %T%>",
12612 tag_name (tag_code
),
12613 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
12614 return error_mark_node
;
12620 /* Lookup NAME in elaborate type specifier in scope according to
12621 SCOPE and issue diagnostics if necessary.
12622 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12623 found, and ERROR_MARK_NODE for type error. */
12626 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
12627 tag_scope scope
, bool template_header_p
)
12631 if (scope
== ts_global
)
12633 /* First try ordinary name lookup, ignoring hidden class name
12634 injected via friend declaration. */
12635 decl
= lookup_name_prefer_type (name
, 2);
12636 decl
= strip_using_decl (decl
);
12637 /* If that fails, the name will be placed in the smallest
12638 non-class, non-function-prototype scope according to 3.3.1/5.
12639 We may already have a hidden name declared as friend in this
12640 scope. So lookup again but not ignoring hidden names.
12641 If we find one, that name will be made visible rather than
12642 creating a new tag. */
12644 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
12647 decl
= lookup_type_scope (name
, scope
);
12650 && (DECL_CLASS_TEMPLATE_P (decl
)
12651 /* If scope is ts_current we're defining a class, so ignore a
12652 template template parameter. */
12653 || (scope
!= ts_current
12654 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
12655 decl
= DECL_TEMPLATE_RESULT (decl
);
12657 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
12659 /* Look for invalid nested type:
12663 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
12665 error ("%qD has the same name as the class in which it is "
12668 return error_mark_node
;
12671 /* Two cases we need to consider when deciding if a class
12672 template is allowed as an elaborated type specifier:
12673 1. It is a self reference to its own class.
12674 2. It comes with a template header.
12678 template <class T> class C {
12679 class C *c1; // DECL_SELF_REFERENCE_P is true
12682 template <class U> class C; // template_header_p is true
12683 template <class T> class C<T>::D {
12684 class C *c2; // DECL_SELF_REFERENCE_P is true
12687 t
= check_elaborated_type_specifier (tag_code
,
12690 | DECL_SELF_REFERENCE_P (decl
));
12691 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
12692 && (!CLASSTYPE_TEMPLATE_INFO (t
)
12693 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
12695 error ("%qT is not a template", t
);
12696 inform (location_of (t
), "previous declaration here");
12697 if (TYPE_CLASS_SCOPE_P (t
)
12698 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
12699 inform (input_location
,
12700 "perhaps you want to explicitly add %<%T::%>",
12702 t
= error_mark_node
;
12707 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12709 error ("reference to %qD is ambiguous", name
);
12710 print_candidates (decl
);
12711 return error_mark_node
;
12717 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12718 Define the tag as a forward-reference if it is not defined.
12720 If a declaration is given, process it here, and report an error if
12721 multiple declarations are not identical.
12723 SCOPE is TS_CURRENT when this is also a definition. Only look in
12724 the current frame for the name (since C++ allows new names in any
12725 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12726 declaration. Only look beginning from the current scope outward up
12727 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12729 TEMPLATE_HEADER_P is true when this declaration is preceded by
12730 a set of template parameters. */
12733 xref_tag_1 (enum tag_types tag_code
, tree name
,
12734 tag_scope orig_scope
, bool template_header_p
)
12736 enum tree_code code
;
12738 tree context
= NULL_TREE
;
12741 gcc_assert (identifier_p (name
));
12747 code
= RECORD_TYPE
;
12753 code
= ENUMERAL_TYPE
;
12756 gcc_unreachable ();
12759 if (orig_scope
== ts_lambda
)
12760 scope
= ts_current
;
12762 scope
= orig_scope
;
12764 /* In case of anonymous name, xref_tag is only called to
12765 make type node and push name. Name lookup is not required. */
12766 if (anon_aggrname_p (name
))
12769 t
= lookup_and_check_tag (tag_code
, name
,
12770 scope
, template_header_p
);
12772 if (t
== error_mark_node
)
12773 return error_mark_node
;
12775 if (scope
!= ts_current
&& t
&& current_class_type
12776 && template_class_depth (current_class_type
)
12777 && template_header_p
)
12779 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12782 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12783 definition of this tag. Since, in addition, we are currently
12784 processing a (member) template declaration of a template
12785 class, we must be very careful; consider:
12792 { template <class V>
12793 friend struct S1; };
12795 Here, the S2::S1 declaration should not be confused with the
12796 outer declaration. In particular, the inner version should
12797 have a template parameter of level 2, not level 1. This
12798 would be particularly important if the member declaration
12801 template <class V = U> friend struct S1;
12803 say, when we should tsubst into `U' when instantiating
12804 S2. On the other hand, when presented with:
12814 we must find the inner binding eventually. We
12815 accomplish this by making sure that the new type we
12816 create to represent this declaration has the right
12818 context
= TYPE_CONTEXT (t
);
12824 /* If no such tag is yet defined, create a forward-reference node
12825 and record it as the "definition".
12826 When a real declaration of this type is found,
12827 the forward-reference will be altered into a real type. */
12828 if (code
== ENUMERAL_TYPE
)
12830 error ("use of enum %q#D without previous declaration", name
);
12831 return error_mark_node
;
12835 t
= make_class_type (code
);
12836 TYPE_CONTEXT (t
) = context
;
12837 if (orig_scope
== ts_lambda
)
12838 /* Remember that we're declaring a lambda to avoid bogus errors
12839 in push_template_decl. */
12840 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12841 t
= pushtag (name
, t
, scope
);
12846 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12848 /* Check that we aren't trying to overload a class with different
12850 tree constr
= NULL_TREE
;
12851 if (current_template_parms
)
12853 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
12854 constr
= build_constraints (reqs
, NULL_TREE
);
12856 if (!redeclare_class_template (t
, current_template_parms
, constr
))
12857 return error_mark_node
;
12859 else if (!processing_template_decl
12860 && CLASS_TYPE_P (t
)
12861 && CLASSTYPE_IS_TEMPLATE (t
))
12863 error ("redeclaration of %qT as a non-template", t
);
12864 error ("previous declaration %q+D", t
);
12865 return error_mark_node
;
12868 /* Make injected friend class visible. */
12869 if (scope
!= ts_within_enclosing_non_class
12870 && hidden_name_p (TYPE_NAME (t
)))
12872 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12873 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12875 if (TYPE_TEMPLATE_INFO (t
))
12877 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12878 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12886 /* Wrapper for xref_tag_1. */
12889 xref_tag (enum tag_types tag_code
, tree name
,
12890 tag_scope scope
, bool template_header_p
)
12894 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12895 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12896 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12902 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12904 enum tag_types tag_kind
;
12906 if (TREE_CODE (old
) == RECORD_TYPE
)
12907 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12909 tag_kind
= union_type
;
12911 if (id
== NULL_TREE
)
12912 id
= TYPE_IDENTIFIER (old
);
12914 return xref_tag (tag_kind
, id
, scope
, false);
12917 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12918 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12919 access_* node, and the TREE_VALUE is the type of the base-class.
12920 Non-NULL TREE_TYPE indicates virtual inheritance.
12922 Returns true if the binfo hierarchy was successfully created,
12923 false if an error was detected. */
12926 xref_basetypes (tree ref
, tree base_list
)
12929 tree binfo
, base_binfo
;
12930 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12931 unsigned max_bases
= 0; /* Maximum direct bases. */
12932 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
12934 tree default_access
;
12935 tree igo_prev
; /* Track Inheritance Graph Order. */
12937 if (ref
== error_mark_node
)
12940 /* The base of a derived class is private by default, all others are
12942 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12943 && CLASSTYPE_DECLARED_CLASS (ref
)
12944 ? access_private_node
: access_public_node
);
12946 /* First, make sure that any templates in base-classes are
12947 instantiated. This ensures that if we call ourselves recursively
12948 we do not get confused about which classes are marked and which
12950 basep
= &base_list
;
12953 tree basetype
= TREE_VALUE (*basep
);
12955 /* The dependent_type_p call below should really be dependent_scope_p
12956 so that we give a hard error about using an incomplete type as a
12957 base, but we allow it with a pedwarn for backward
12959 if (processing_template_decl
12960 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12961 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12962 if (!dependent_type_p (basetype
)
12963 && !complete_type_or_else (basetype
, NULL
))
12964 /* An incomplete type. Remove it from the list. */
12965 *basep
= TREE_CHAIN (*basep
);
12969 if (TREE_TYPE (*basep
))
12971 if (CLASS_TYPE_P (basetype
))
12972 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12973 basep
= &TREE_CHAIN (*basep
);
12976 max_vbases
+= max_dvbases
;
12978 TYPE_MARKED_P (ref
) = 1;
12980 /* The binfo slot should be empty, unless this is an (ill-formed)
12982 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12984 error ("redefinition of %q#T", ref
);
12988 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12990 binfo
= make_tree_binfo (max_bases
);
12992 TYPE_BINFO (ref
) = binfo
;
12993 BINFO_OFFSET (binfo
) = size_zero_node
;
12994 BINFO_TYPE (binfo
) = ref
;
12996 /* Apply base-class info set up to the variants of this type. */
12997 fixup_type_variants (ref
);
13001 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
13002 /* An aggregate cannot have baseclasses. */
13003 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
13005 if (TREE_CODE (ref
) == UNION_TYPE
)
13007 error ("derived union %qT invalid", ref
);
13014 if (TYPE_FOR_JAVA (ref
))
13016 error ("Java class %qT cannot have multiple bases", ref
);
13020 warning (OPT_Wmultiple_inheritance
,
13021 "%qT defined with multiple direct bases", ref
);
13026 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
13028 if (TYPE_FOR_JAVA (ref
))
13030 error ("Java class %qT cannot have virtual bases", ref
);
13033 else if (max_dvbases
)
13034 warning (OPT_Wvirtual_inheritance
,
13035 "%qT defined with direct virtual base", ref
);
13038 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
13040 tree access
= TREE_PURPOSE (base_list
);
13041 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
13042 tree basetype
= TREE_VALUE (base_list
);
13044 if (access
== access_default_node
)
13045 access
= default_access
;
13047 if (PACK_EXPANSION_P (basetype
))
13048 basetype
= PACK_EXPANSION_PATTERN (basetype
);
13049 if (TREE_CODE (basetype
) == TYPE_DECL
)
13050 basetype
= TREE_TYPE (basetype
);
13051 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
13053 error ("base type %qT fails to be a struct or class type",
13058 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
13059 TYPE_FOR_JAVA (ref
) = 1;
13061 base_binfo
= NULL_TREE
;
13062 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
13064 base_binfo
= TYPE_BINFO (basetype
);
13065 /* The original basetype could have been a typedef'd type. */
13066 basetype
= BINFO_TYPE (base_binfo
);
13068 /* Inherit flags from the base. */
13069 TYPE_HAS_NEW_OPERATOR (ref
)
13070 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13071 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13072 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13073 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13074 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
13075 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
13076 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
13077 CLASSTYPE_REPEATED_BASE_P (ref
)
13078 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
13081 /* We must do this test after we've seen through a typedef
13083 if (TYPE_MARKED_P (basetype
))
13085 if (basetype
== ref
)
13086 error ("recursive type %qT undefined", basetype
);
13088 error ("duplicate base type %qT invalid", basetype
);
13092 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
13093 /* Regenerate the pack expansion for the bases. */
13094 basetype
= make_pack_expansion (basetype
);
13096 TYPE_MARKED_P (basetype
) = 1;
13098 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
13099 &igo_prev
, via_virtual
);
13100 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
13101 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
13103 BINFO_BASE_APPEND (binfo
, base_binfo
);
13104 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
13107 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
13108 /* If we didn't get max_vbases vbases, we must have shared at
13109 least one of them, and are therefore diamond shaped. */
13110 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
13112 /* Unmark all the types. */
13113 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
13114 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13115 TYPE_MARKED_P (ref
) = 0;
13117 /* Now see if we have a repeated base type. */
13118 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
13120 for (base_binfo
= binfo
; base_binfo
;
13121 base_binfo
= TREE_CHAIN (base_binfo
))
13123 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13125 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
13128 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
13130 for (base_binfo
= binfo
; base_binfo
;
13131 base_binfo
= TREE_CHAIN (base_binfo
))
13132 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13133 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13142 /* Copies the enum-related properties from type SRC to type DST.
13143 Used with the underlying type of an enum and the enum itself. */
13145 copy_type_enum (tree dst
, tree src
)
13148 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
13150 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
13151 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
13152 TYPE_SIZE (t
) = TYPE_SIZE (src
);
13153 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
13154 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
13155 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
13156 unsigned valign
= TYPE_ALIGN (src
);
13157 if (TYPE_USER_ALIGN (t
))
13158 valign
= MAX (valign
, TYPE_ALIGN (t
));
13160 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
13161 TYPE_ALIGN (t
) = valign
;
13162 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
13166 /* Begin compiling the definition of an enumeration type.
13169 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
13171 UNDERLYING_TYPE is the type that will be used as the storage for
13172 the enumeration type. This should be NULL_TREE if no storage type
13175 ATTRIBUTES are any attributes specified after the enum-key.
13177 SCOPED_ENUM_P is true if this is a scoped enumeration type.
13179 if IS_NEW is not NULL, gets TRUE iff a new type is created.
13181 Returns the type object, as yet incomplete.
13182 Also records info about it so that build_enumerator
13183 may be used to declare the individual values as they are read. */
13186 start_enum (tree name
, tree enumtype
, tree underlying_type
,
13187 tree attributes
, bool scoped_enum_p
, bool *is_new
)
13189 tree prevtype
= NULL_TREE
;
13190 gcc_assert (identifier_p (name
));
13194 /* [C++0x dcl.enum]p5:
13196 If not explicitly specified, the underlying type of a scoped
13197 enumeration type is int. */
13198 if (!underlying_type
&& scoped_enum_p
)
13199 underlying_type
= integer_type_node
;
13201 if (underlying_type
)
13202 underlying_type
= cv_unqualified (underlying_type
);
13204 /* If this is the real definition for a previous forward reference,
13205 fill in the contents in the same object that used to be the
13206 forward reference. */
13208 enumtype
= lookup_and_check_tag (enum_type
, name
,
13209 /*tag_scope=*/ts_current
,
13210 /*template_header_p=*/false);
13212 /* In case of a template_decl, the only check that should be deferred
13213 to instantiation time is the comparison of underlying types. */
13214 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13216 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
13218 error_at (input_location
, "scoped/unscoped mismatch "
13219 "in enum %q#T", enumtype
);
13220 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13221 "previous definition here");
13222 enumtype
= error_mark_node
;
13224 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
13226 error_at (input_location
, "underlying type mismatch "
13227 "in enum %q#T", enumtype
);
13228 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13229 "previous definition here");
13230 enumtype
= error_mark_node
;
13232 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
13233 && !dependent_type_p (underlying_type
)
13234 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
13235 && !same_type_p (underlying_type
,
13236 ENUM_UNDERLYING_TYPE (enumtype
)))
13238 error_at (input_location
, "different underlying type "
13239 "in enum %q#T", enumtype
);
13240 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13241 "previous definition here");
13242 underlying_type
= NULL_TREE
;
13246 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
13247 || processing_template_decl
)
13249 /* In case of error, make a dummy enum to allow parsing to
13251 if (enumtype
== error_mark_node
)
13253 name
= make_anon_name ();
13254 enumtype
= NULL_TREE
;
13257 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
13258 of an opaque enum, or an opaque enum of an already defined
13259 enumeration (C++0x only).
13260 In any other case, it'll be NULL_TREE. */
13266 prevtype
= enumtype
;
13268 /* Do not push the decl more than once, unless we need to
13269 compare underlying types at instantiation time */
13271 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
13272 || (underlying_type
13273 && dependent_type_p (underlying_type
))
13274 || (ENUM_UNDERLYING_TYPE (enumtype
)
13275 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
13277 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
13278 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
13281 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
13284 if (enumtype
== error_mark_node
)
13285 return error_mark_node
;
13287 /* The enum is considered opaque until the opening '{' of the
13288 enumerator list. */
13289 SET_OPAQUE_ENUM_P (enumtype
, true);
13290 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
13293 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
13295 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
13297 if (underlying_type
)
13299 if (ENUM_UNDERLYING_TYPE (enumtype
))
13300 /* We already checked that it matches, don't change it to a different
13301 typedef variant. */;
13302 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
13304 copy_type_enum (enumtype
, underlying_type
);
13305 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13307 else if (dependent_type_p (underlying_type
))
13308 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13310 error ("underlying type %<%T%> of %<%T%> must be an integral type",
13311 underlying_type
, enumtype
);
13314 /* If into a template class, the returned enum is always the first
13315 declaration (opaque or not) seen. This way all the references to
13316 this type will be to the same declaration. The following ones are used
13317 only to check for definition errors. */
13318 if (prevtype
&& processing_template_decl
)
13324 /* After processing and defining all the values of an enumeration type,
13325 install their decls in the enumeration type.
13326 ENUMTYPE is the type object. */
13329 finish_enum_value_list (tree enumtype
)
13332 tree underlying_type
;
13335 tree minnode
, maxnode
;
13338 bool fixed_underlying_type_p
13339 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
13341 /* We built up the VALUES in reverse order. */
13342 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
13344 /* For an enum defined in a template, just set the type of the values;
13345 all further processing is postponed until the template is
13346 instantiated. We need to set the type so that tsubst of a CONST_DECL
13348 if (processing_template_decl
)
13350 for (values
= TYPE_VALUES (enumtype
);
13352 values
= TREE_CHAIN (values
))
13353 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
13357 /* Determine the minimum and maximum values of the enumerators. */
13358 if (TYPE_VALUES (enumtype
))
13360 minnode
= maxnode
= NULL_TREE
;
13362 for (values
= TYPE_VALUES (enumtype
);
13364 values
= TREE_CHAIN (values
))
13366 decl
= TREE_VALUE (values
);
13368 /* [dcl.enum]: Following the closing brace of an enum-specifier,
13369 each enumerator has the type of its enumeration. Prior to the
13370 closing brace, the type of each enumerator is the type of its
13371 initializing value. */
13372 TREE_TYPE (decl
) = enumtype
;
13374 /* Update the minimum and maximum values, if appropriate. */
13375 value
= DECL_INITIAL (decl
);
13376 if (value
== error_mark_node
)
13377 value
= integer_zero_node
;
13378 /* Figure out what the minimum and maximum values of the
13379 enumerators are. */
13381 minnode
= maxnode
= value
;
13382 else if (tree_int_cst_lt (maxnode
, value
))
13384 else if (tree_int_cst_lt (value
, minnode
))
13391 If the enumerator-list is empty, the underlying type is as if
13392 the enumeration had a single enumerator with value 0. */
13393 minnode
= maxnode
= integer_zero_node
;
13395 if (!fixed_underlying_type_p
)
13397 /* Compute the number of bits require to represent all values of the
13398 enumeration. We must do this before the type of MINNODE and
13399 MAXNODE are transformed, since tree_int_cst_min_precision relies
13400 on the TREE_TYPE of the value it is passed. */
13401 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
13402 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
13403 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
13404 int precision
= MAX (lowprec
, highprec
);
13406 bool use_short_enum
;
13408 /* Determine the underlying type of the enumeration.
13412 The underlying type of an enumeration is an integral type that
13413 can represent all the enumerator values defined in the
13414 enumeration. It is implementation-defined which integral type is
13415 used as the underlying type for an enumeration except that the
13416 underlying type shall not be larger than int unless the value of
13417 an enumerator cannot fit in an int or unsigned int.
13419 We use "int" or an "unsigned int" as the underlying type, even if
13420 a smaller integral type would work, unless the user has
13421 explicitly requested that we use the smallest possible type. The
13422 user can request that for all enumerations with a command line
13423 flag, or for just one enumeration with an attribute. */
13425 use_short_enum
= flag_short_enums
13426 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
13428 for (itk
= (use_short_enum
? itk_char
: itk_int
);
13432 underlying_type
= integer_types
[itk
];
13433 if (underlying_type
!= NULL_TREE
13434 && TYPE_PRECISION (underlying_type
) >= precision
13435 && TYPE_SIGN (underlying_type
) == sgn
)
13438 if (itk
== itk_none
)
13442 IF no integral type can represent all the enumerator values, the
13443 enumeration is ill-formed. */
13444 error ("no integral type can represent all of the enumerator values "
13445 "for %qT", enumtype
);
13446 precision
= TYPE_PRECISION (long_long_integer_type_node
);
13447 underlying_type
= integer_types
[itk_unsigned_long_long
];
13452 The value of sizeof() applied to an enumeration type, an object
13453 of an enumeration type, or an enumerator, is the value of sizeof()
13454 applied to the underlying type. */
13455 copy_type_enum (enumtype
, underlying_type
);
13457 /* Compute the minimum and maximum values for the type.
13461 For an enumeration where emin is the smallest enumerator and emax
13462 is the largest, the values of the enumeration are the values of the
13463 underlying type in the range bmin to bmax, where bmin and bmax are,
13464 respectively, the smallest and largest values of the smallest bit-
13465 field that can store emin and emax. */
13467 /* The middle-end currently assumes that types with TYPE_PRECISION
13468 narrower than their underlying type are suitably zero or sign
13469 extended to fill their mode. Similarly, it assumes that the front
13470 end assures that a value of a particular type must be within
13471 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
13473 We used to set these fields based on bmin and bmax, but that led
13474 to invalid assumptions like optimizing away bounds checking. So
13475 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
13476 TYPE_MAX_VALUE to the values for the mode above and only restrict
13477 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
13478 ENUM_UNDERLYING_TYPE (enumtype
)
13479 = build_distinct_type_copy (underlying_type
);
13480 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
13481 set_min_and_max_values_for_integral_type
13482 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
13484 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
13485 if (flag_strict_enums
)
13486 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
13489 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
13491 /* Convert each of the enumerators to the type of the underlying
13492 type of the enumeration. */
13493 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13495 location_t saved_location
;
13497 decl
= TREE_VALUE (values
);
13498 saved_location
= input_location
;
13499 input_location
= DECL_SOURCE_LOCATION (decl
);
13500 if (fixed_underlying_type_p
)
13501 /* If the enumeration type has a fixed underlying type, we
13502 already checked all of the enumerator values. */
13503 value
= DECL_INITIAL (decl
);
13505 value
= perform_implicit_conversion (underlying_type
,
13506 DECL_INITIAL (decl
),
13507 tf_warning_or_error
);
13508 input_location
= saved_location
;
13510 /* Do not clobber shared ints. */
13511 value
= copy_node (value
);
13513 TREE_TYPE (value
) = enumtype
;
13514 DECL_INITIAL (decl
) = value
;
13517 /* Fix up all variant types of this enum type. */
13518 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
13519 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
13521 if (at_class_scope_p ()
13522 && COMPLETE_TYPE_P (current_class_type
)
13523 && UNSCOPED_ENUM_P (enumtype
))
13524 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
13525 current_class_type
);
13527 /* Finish debugging output for this type. */
13528 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13530 /* Each enumerator now has the type of its enumeration. Clear the cache
13531 so that this change in types doesn't confuse us later on. */
13532 clear_cv_and_fold_caches ();
13535 /* Finishes the enum type. This is called only the first time an
13536 enumeration is seen, be it opaque or odinary.
13537 ENUMTYPE is the type object. */
13540 finish_enum (tree enumtype
)
13542 if (processing_template_decl
)
13544 if (at_function_scope_p ())
13545 add_stmt (build_min (TAG_DEFN
, enumtype
));
13549 /* If this is a forward declaration, there should not be any variants,
13550 though we can get a variant in the middle of an enum-specifier with
13551 wacky code like 'enum E { e = sizeof(const E*) };' */
13552 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
13553 && (TYPE_VALUES (enumtype
)
13554 || !TYPE_NEXT_VARIANT (enumtype
)));
13557 /* Build and install a CONST_DECL for an enumeration constant of the
13558 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13559 Apply ATTRIBUTES if available. LOC is the location of NAME.
13560 Assignment of sequential values by default is handled here. */
13563 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
13570 /* scalar_constant_value will pull out this expression, so make sure
13571 it's folded as appropriate. */
13572 if (processing_template_decl
)
13573 value
= fold_non_dependent_expr (value
);
13575 /* If the VALUE was erroneous, pretend it wasn't there; that will
13576 result in the enum being assigned the next value in sequence. */
13577 if (value
== error_mark_node
)
13580 /* Remove no-op casts from the value. */
13582 STRIP_TYPE_NOPS (value
);
13584 if (! processing_template_decl
)
13586 /* Validate and default VALUE. */
13587 if (value
!= NULL_TREE
)
13589 if (!ENUM_UNDERLYING_TYPE (enumtype
))
13591 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
13596 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
13597 (TREE_TYPE (value
)))
13598 value
= perform_implicit_conversion_flags
13599 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
13600 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
13602 if (value
== error_mark_node
)
13605 if (value
!= NULL_TREE
)
13607 value
= cxx_constant_value (value
);
13609 if (TREE_CODE (value
) != INTEGER_CST
13610 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13612 error ("enumerator value for %qD is not an integer constant",
13619 /* Default based on previous value. */
13620 if (value
== NULL_TREE
)
13622 if (TYPE_VALUES (enumtype
))
13627 /* C++03 7.2/4: If no initializer is specified for the first
13628 enumerator, the type is an unspecified integral
13629 type. Otherwise the type is the same as the type of the
13630 initializing value of the preceding enumerator unless the
13631 incremented value is not representable in that type, in
13632 which case the type is an unspecified integral type
13633 sufficient to contain the incremented value. */
13634 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13635 if (error_operand_p (prev_value
))
13636 value
= error_mark_node
;
13639 tree type
= TREE_TYPE (prev_value
);
13640 signop sgn
= TYPE_SIGN (type
);
13641 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
13645 bool pos
= !wi::neg_p (wi
, sgn
);
13646 if (!wi::fits_to_tree_p (wi
, type
))
13649 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
13651 type
= integer_types
[itk
];
13652 if (type
!= NULL_TREE
13653 && (pos
|| !TYPE_UNSIGNED (type
))
13654 && wi::fits_to_tree_p (wi
, type
))
13657 if (type
&& cxx_dialect
< cxx11
13658 && itk
> itk_unsigned_long
)
13659 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
13660 incremented enumerator value is too large for %<unsigned long%>" : "\
13661 incremented enumerator value is too large for %<long%>");
13663 if (type
== NULL_TREE
)
13666 value
= wide_int_to_tree (type
, wi
);
13671 error ("overflow in enumeration values at %qD", name
);
13672 value
= error_mark_node
;
13677 value
= integer_zero_node
;
13680 /* Remove no-op casts from the value. */
13681 STRIP_TYPE_NOPS (value
);
13683 /* If the underlying type of the enum is fixed, check whether
13684 the enumerator values fits in the underlying type. If it
13685 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13686 if (ENUM_UNDERLYING_TYPE (enumtype
)
13688 && TREE_CODE (value
) == INTEGER_CST
)
13690 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
13691 error ("enumerator value %E is outside the range of underlying "
13692 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
13694 /* Convert the value to the appropriate type. */
13695 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
13699 /* C++ associates enums with global, function, or class declarations. */
13700 context
= current_scope ();
13702 /* Build the actual enumeration constant. Note that the enumeration
13703 constants have the underlying type of the enum (if it is fixed)
13704 or the type of their initializer (if the underlying type of the
13705 enum is not fixed):
13709 If the underlying type is fixed, the type of each enumerator
13710 prior to the closing brace is the underlying type; if the
13711 initializing value of an enumerator cannot be represented by
13712 the underlying type, the program is ill-formed. If the
13713 underlying type is not fixed, the type of each enumerator is
13714 the type of its initializing value.
13716 If the underlying type is not fixed, it will be computed by
13717 finish_enum and we will reset the type of this enumerator. Of
13718 course, if we're processing a template, there may be no value. */
13719 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13721 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
13723 DECL_CONTEXT (decl
) = enumtype
;
13724 TREE_CONSTANT (decl
) = 1;
13725 TREE_READONLY (decl
) = 1;
13726 DECL_INITIAL (decl
) = value
;
13729 cplus_decl_attributes (&decl
, attributes
, 0);
13731 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
13732 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13733 on the TYPE_FIELDS list for `S'. (That's so that you can say
13734 things like `S::i' later.) */
13735 finish_member_declaration (decl
);
13739 /* Add this enumeration constant to the list for this type. */
13740 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13743 /* Look for an enumerator with the given NAME within the enumeration
13744 type ENUMTYPE. This routine is used primarily for qualified name
13745 lookup into an enumerator in C++0x, e.g.,
13747 enum class Color { Red, Green, Blue };
13749 Color color = Color::Red;
13751 Returns the value corresponding to the enumerator, or
13752 NULL_TREE if no such enumerator was found. */
13754 lookup_enumerator (tree enumtype
, tree name
)
13757 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13759 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13760 return e
? TREE_VALUE (e
) : NULL_TREE
;
13764 /* We're defining DECL. Make sure that its type is OK. */
13767 check_function_type (tree decl
, tree current_function_parms
)
13769 tree fntype
= TREE_TYPE (decl
);
13770 tree return_type
= complete_type (TREE_TYPE (fntype
));
13772 /* In a function definition, arg types must be complete. */
13773 require_complete_types_for_parms (current_function_parms
);
13775 if (dependent_type_p (return_type
)
13776 || type_uses_auto (return_type
))
13778 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13779 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13781 tree args
= TYPE_ARG_TYPES (fntype
);
13783 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13784 error ("return type %q#T is incomplete", return_type
);
13786 error ("return type has Java class type %q#T", return_type
);
13788 /* Make it return void instead. */
13789 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13790 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13792 TREE_CHAIN (args
));
13794 fntype
= build_function_type (void_type_node
, args
);
13796 = build_exception_variant (fntype
,
13797 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13798 fntype
= (cp_build_type_attribute_variant
13799 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13800 TREE_TYPE (decl
) = fntype
;
13803 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13806 /* True iff FN is an implicitly-defined default constructor. */
13809 implicit_default_ctor_p (tree fn
)
13811 return (DECL_CONSTRUCTOR_P (fn
)
13812 && !user_provided_p (fn
)
13813 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
13816 /* Clobber the contents of *this to let the back end know that the object
13817 storage is dead when we enter the constructor or leave the destructor. */
13820 build_clobber_this ()
13822 /* Clobbering an empty base is pointless, and harmful if its one byte
13823 TYPE_SIZE overlays real data. */
13824 if (is_empty_class (current_class_type
))
13827 /* If we have virtual bases, clobber the whole object, but only if we're in
13828 charge. If we don't have virtual bases, clobber the as-base type so we
13829 don't mess with tail padding. */
13830 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
13832 tree ctype
= current_class_type
;
13834 ctype
= CLASSTYPE_AS_BASE (ctype
);
13836 tree clobber
= build_constructor (ctype
, NULL
);
13837 TREE_THIS_VOLATILE (clobber
) = true;
13839 tree thisref
= current_class_ref
;
13840 if (ctype
!= current_class_type
)
13842 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
13843 thisref
= convert_from_reference (thisref
);
13846 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
13848 exprstmt
= build_if_in_charge (exprstmt
);
13853 /* Create the FUNCTION_DECL for a function definition.
13854 DECLSPECS and DECLARATOR are the parts of the declaration;
13855 they describe the function's name and the type it returns,
13856 but twisted together in a fashion that parallels the syntax of C.
13858 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13859 DECLARATOR is really the DECL for the function we are about to
13860 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13861 indicating that the function is an inline defined in-class.
13863 This function creates a binding context for the function body
13864 as well as setting up the FUNCTION_DECL in current_function_decl.
13866 For C++, we must first check whether that datum makes any sense.
13867 For example, "class A local_a(1,2);" means that variable local_a
13868 is an aggregate of type A, which should have a constructor
13869 applied to it with the argument list [1, 2].
13871 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13872 or may be a BLOCK if the function has been defined previously
13873 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13874 error_mark_node if the function has never been defined, or
13875 a BLOCK if the function has been defined somewhere. */
13878 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13880 tree ctype
= NULL_TREE
;
13883 int doing_friend
= 0;
13884 cp_binding_level
*bl
;
13885 tree current_function_parms
;
13886 struct c_fileinfo
*finfo
13887 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13888 bool honor_interface
;
13890 /* Sanity check. */
13891 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13892 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13894 fntype
= TREE_TYPE (decl1
);
13895 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13896 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13898 /* ISO C++ 11.4/5. A friend function defined in a class is in
13899 the (lexical) scope of the class in which it is defined. */
13900 if (!ctype
&& DECL_FRIEND_P (decl1
))
13902 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13904 /* CTYPE could be null here if we're dealing with a template;
13905 for example, `inline friend float foo()' inside a template
13906 will have no CTYPE set. */
13907 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13913 if (DECL_DECLARED_INLINE_P (decl1
)
13914 && lookup_attribute ("noinline", attrs
))
13915 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
13916 "inline function %qD given attribute noinline", decl1
);
13918 /* Handle gnu_inline attribute. */
13919 if (GNU_INLINE_P (decl1
))
13921 DECL_EXTERNAL (decl1
) = 1;
13922 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13923 DECL_INTERFACE_KNOWN (decl1
) = 1;
13924 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13927 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13928 /* This is a constructor, we must ensure that any default args
13929 introduced by this definition are propagated to the clones
13930 now. The clones are used directly in overload resolution. */
13931 adjust_clone_args (decl1
);
13933 /* Sometimes we don't notice that a function is a static member, and
13934 build a METHOD_TYPE for it. Fix that up now. */
13935 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13936 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13938 /* Set up current_class_type, and enter the scope of the class, if
13941 push_nested_class (ctype
);
13942 else if (DECL_STATIC_FUNCTION_P (decl1
))
13943 push_nested_class (DECL_CONTEXT (decl1
));
13945 /* Now that we have entered the scope of the class, we must restore
13946 the bindings for any template parameters surrounding DECL1, if it
13947 is an inline member template. (Order is important; consider the
13948 case where a template parameter has the same name as a field of
13949 the class.) It is not until after this point that
13950 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13951 if (flags
& SF_INCLASS_INLINE
)
13952 maybe_begin_member_template_processing (decl1
);
13954 /* Effective C++ rule 15. */
13956 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13957 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13958 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13960 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13961 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13962 if (!DECL_INITIAL (decl1
))
13963 DECL_INITIAL (decl1
) = error_mark_node
;
13965 /* This function exists in static storage.
13966 (This does not mean `static' in the C sense!) */
13967 TREE_STATIC (decl1
) = 1;
13969 /* We must call push_template_decl after current_class_type is set
13970 up. (If we are processing inline definitions after exiting a
13971 class scope, current_class_type will be NULL_TREE until set above
13972 by push_nested_class.) */
13973 if (processing_template_decl
)
13975 tree newdecl1
= push_template_decl (decl1
);
13976 if (newdecl1
== error_mark_node
)
13978 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13979 pop_nested_class ();
13985 /* We are now in the scope of the function being defined. */
13986 current_function_decl
= decl1
;
13988 /* Save the parm names or decls from this function's declarator
13989 where store_parm_decls will find them. */
13990 current_function_parms
= DECL_ARGUMENTS (decl1
);
13992 /* Make sure the parameter and return types are reasonable. When
13993 you declare a function, these types can be incomplete, but they
13994 must be complete when you define the function. */
13995 check_function_type (decl1
, current_function_parms
);
13997 /* Build the return declaration for the function. */
13998 restype
= TREE_TYPE (fntype
);
14000 if (DECL_RESULT (decl1
) == NULL_TREE
)
14004 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
14005 DECL_ARTIFICIAL (resdecl
) = 1;
14006 DECL_IGNORED_P (resdecl
) = 1;
14007 DECL_RESULT (decl1
) = resdecl
;
14009 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
14012 /* Let the user know we're compiling this function. */
14013 announce_function (decl1
);
14015 /* Record the decl so that the function name is defined.
14016 If we already have a decl for this name, and it is a FUNCTION_DECL,
14017 use the old decl. */
14018 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
14020 /* A specialization is not used to guide overload resolution. */
14021 if (!DECL_FUNCTION_MEMBER_P (decl1
)
14022 && !(DECL_USE_TEMPLATE (decl1
) &&
14023 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
14025 tree olddecl
= pushdecl (decl1
);
14027 if (olddecl
== error_mark_node
)
14028 /* If something went wrong when registering the declaration,
14029 use DECL1; we have to have a FUNCTION_DECL to use when
14030 parsing the body of the function. */
14034 /* Otherwise, OLDDECL is either a previous declaration
14035 of the same function or DECL1 itself. */
14037 if (warn_missing_declarations
14038 && olddecl
== decl1
14039 && !DECL_MAIN_P (decl1
)
14040 && TREE_PUBLIC (decl1
)
14041 && !DECL_DECLARED_INLINE_P (decl1
))
14045 /* Check whether DECL1 is in an anonymous
14047 for (context
= DECL_CONTEXT (decl1
);
14049 context
= DECL_CONTEXT (context
))
14051 if (TREE_CODE (context
) == NAMESPACE_DECL
14052 && DECL_NAME (context
) == NULL_TREE
)
14056 if (context
== NULL
)
14057 warning_at (DECL_SOURCE_LOCATION (decl1
),
14058 OPT_Wmissing_declarations
,
14059 "no previous declaration for %qD", decl1
);
14067 /* We need to set the DECL_CONTEXT. */
14068 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
14069 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
14071 fntype
= TREE_TYPE (decl1
);
14072 restype
= TREE_TYPE (fntype
);
14074 /* If #pragma weak applies, mark the decl appropriately now.
14075 The pragma only applies to global functions. Because
14076 determining whether or not the #pragma applies involves
14077 computing the mangled name for the declaration, we cannot
14078 apply the pragma until after we have merged this declaration
14079 with any previous declarations; if the original declaration
14080 has a linkage specification, that specification applies to
14081 the definition as well, and may affect the mangled name. */
14082 if (DECL_FILE_SCOPE_P (decl1
))
14083 maybe_apply_pragma_weak (decl1
);
14086 /* Reset this in case the call to pushdecl changed it. */
14087 current_function_decl
= decl1
;
14089 gcc_assert (DECL_INITIAL (decl1
));
14091 /* This function may already have been parsed, in which case just
14092 return; our caller will skip over the body without parsing. */
14093 if (DECL_INITIAL (decl1
) != error_mark_node
)
14096 /* Initialize RTL machinery. We cannot do this until
14097 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
14098 even when processing a template; this is how we get
14099 CFUN set up, and our per-function variables initialized.
14100 FIXME factor out the non-RTL stuff. */
14101 bl
= current_binding_level
;
14102 allocate_struct_function (decl1
, processing_template_decl
);
14104 /* Initialize the language data structures. Whenever we start
14105 a new function, we destroy temporaries in the usual way. */
14106 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
14107 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14108 current_binding_level
= bl
;
14110 if (!processing_template_decl
&& type_uses_auto (restype
))
14112 FNDECL_USED_AUTO (decl1
) = true;
14113 current_function_auto_return_pattern
= restype
;
14116 /* Start the statement-tree, start the tree now. */
14117 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
14119 /* If we are (erroneously) defining a function that we have already
14120 defined before, wipe out what we knew before. */
14121 if (!DECL_PENDING_INLINE_P (decl1
))
14122 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
14124 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
14126 /* We know that this was set up by `grokclassfn'. We do not
14127 wait until `store_parm_decls', since evil parse errors may
14128 never get us to that point. Here we keep the consistency
14129 between `current_class_type' and `current_class_ptr'. */
14130 tree t
= DECL_ARGUMENTS (decl1
);
14132 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
14133 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
14135 cp_function_chain
->x_current_class_ref
14136 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
14137 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
14138 cp_function_chain
->x_current_class_ptr
= t
;
14140 /* Constructors and destructors need to know whether they're "in
14141 charge" of initializing virtual base classes. */
14142 t
= DECL_CHAIN (t
);
14143 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
14145 current_in_charge_parm
= t
;
14146 t
= DECL_CHAIN (t
);
14148 if (DECL_HAS_VTT_PARM_P (decl1
))
14150 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
14151 current_vtt_parm
= t
;
14155 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
14156 /* Implicitly-defined methods (like the
14157 destructor for a class in which no destructor
14158 is explicitly declared) must not be defined
14159 until their definition is needed. So, we
14160 ignore interface specifications for
14161 compiler-generated functions. */
14162 && !DECL_ARTIFICIAL (decl1
));
14164 if (processing_template_decl
)
14165 /* Don't mess with interface flags. */;
14166 else if (DECL_INTERFACE_KNOWN (decl1
))
14168 tree ctx
= decl_function_context (decl1
);
14170 if (DECL_NOT_REALLY_EXTERN (decl1
))
14171 DECL_EXTERNAL (decl1
) = 0;
14173 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
14174 /* This is a function in a local class in an extern inline
14175 or template function. */
14176 comdat_linkage (decl1
);
14178 /* If this function belongs to an interface, it is public.
14179 If it belongs to someone else's interface, it is also external.
14180 This only affects inlines and template instantiations. */
14181 else if (!finfo
->interface_unknown
&& honor_interface
)
14183 if (DECL_DECLARED_INLINE_P (decl1
)
14184 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14186 DECL_EXTERNAL (decl1
)
14187 = (finfo
->interface_only
14188 || (DECL_DECLARED_INLINE_P (decl1
)
14189 && ! flag_implement_inlines
14190 && !DECL_VINDEX (decl1
)));
14192 /* For WIN32 we also want to put these in linkonce sections. */
14193 maybe_make_one_only (decl1
);
14196 DECL_EXTERNAL (decl1
) = 0;
14197 DECL_INTERFACE_KNOWN (decl1
) = 1;
14198 /* If this function is in an interface implemented in this file,
14199 make sure that the back end knows to emit this function
14201 if (!DECL_EXTERNAL (decl1
))
14202 mark_needed (decl1
);
14204 else if (finfo
->interface_unknown
&& finfo
->interface_only
14205 && honor_interface
)
14207 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14208 interface, we will have both finfo->interface_unknown and
14209 finfo->interface_only set. In that case, we don't want to
14210 use the normal heuristics because someone will supply a
14211 #pragma implementation elsewhere, and deducing it here would
14212 produce a conflict. */
14213 comdat_linkage (decl1
);
14214 DECL_EXTERNAL (decl1
) = 0;
14215 DECL_INTERFACE_KNOWN (decl1
) = 1;
14216 DECL_DEFER_OUTPUT (decl1
) = 1;
14220 /* This is a definition, not a reference.
14221 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
14222 if (!GNU_INLINE_P (decl1
))
14223 DECL_EXTERNAL (decl1
) = 0;
14225 if ((DECL_DECLARED_INLINE_P (decl1
)
14226 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14227 && ! DECL_INTERFACE_KNOWN (decl1
))
14228 DECL_DEFER_OUTPUT (decl1
) = 1;
14230 DECL_INTERFACE_KNOWN (decl1
) = 1;
14233 /* Determine the ELF visibility attribute for the function. We must not
14234 do this before calling "pushdecl", as we must allow "duplicate_decls"
14235 to merge any attributes appropriately. We also need to wait until
14237 if (!DECL_CLONED_FUNCTION_P (decl1
))
14238 determine_visibility (decl1
);
14240 if (!processing_template_decl
)
14241 maybe_instantiate_noexcept (decl1
);
14243 begin_scope (sk_function_parms
, decl1
);
14247 if (DECL_DESTRUCTOR_P (decl1
)
14248 || (DECL_CONSTRUCTOR_P (decl1
)
14249 && targetm
.cxx
.cdtor_returns_this ()))
14250 cdtor_label
= create_artificial_label (input_location
);
14252 start_fname_decls ();
14254 store_parm_decls (current_function_parms
);
14256 if (!processing_template_decl
14257 && (flag_lifetime_dse
> 1)
14258 && DECL_CONSTRUCTOR_P (decl1
)
14259 && !DECL_CLONED_FUNCTION_P (decl1
)
14260 /* Clobbering an empty base is harmful if it overlays real data. */
14261 && !is_empty_class (current_class_type
)
14262 /* We can't clobber safely for an implicitly-defined default constructor
14263 because part of the initialization might happen before we enter the
14264 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
14265 && !implicit_default_ctor_p (decl1
))
14266 finish_expr_stmt (build_clobber_this ());
14268 if (!processing_template_decl
14269 && DECL_CONSTRUCTOR_P (decl1
)
14270 && (flag_sanitize
& SANITIZE_VPTR
)
14271 && !DECL_CLONED_FUNCTION_P (decl1
)
14272 && !implicit_default_ctor_p (decl1
))
14273 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
14279 /* Like start_preparsed_function, except that instead of a
14280 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
14282 Returns true on success. If the DECLARATOR is not suitable
14283 for a function, we return false, which tells the parser to
14284 skip the entire function. */
14287 start_function (cp_decl_specifier_seq
*declspecs
,
14288 const cp_declarator
*declarator
,
14293 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
14294 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
14295 if (decl1
== error_mark_node
)
14297 /* If the declarator is not suitable for a function definition,
14298 cause a syntax error. */
14299 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
14301 error ("invalid function declaration");
14305 if (DECL_MAIN_P (decl1
))
14306 /* main must return int. grokfndecl should have corrected it
14307 (and issued a diagnostic) if the user got it wrong. */
14308 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
14309 integer_type_node
));
14311 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
14314 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
14318 use_eh_spec_block (tree fn
)
14320 return (flag_exceptions
&& flag_enforce_eh_specs
14321 && !processing_template_decl
14322 && !type_throw_all_p (TREE_TYPE (fn
))
14323 /* We insert the EH_SPEC_BLOCK only in the original
14324 function; then, it is copied automatically to the
14326 && !DECL_CLONED_FUNCTION_P (fn
)
14327 /* Implicitly-generated constructors and destructors have
14328 exception specifications. However, those specifications
14329 are the union of the possible exceptions specified by the
14330 constructors/destructors for bases and members, so no
14331 unallowed exception will ever reach this function. By
14332 not creating the EH_SPEC_BLOCK we save a little memory,
14333 and we avoid spurious warnings about unreachable
14335 && !DECL_DEFAULTED_FN (fn
));
14338 /* Store the parameter declarations into the current function declaration.
14339 This is called after parsing the parameter declarations, before
14340 digesting the body of the function.
14342 Also install to binding contour return value identifier, if any. */
14345 store_parm_decls (tree current_function_parms
)
14347 tree fndecl
= current_function_decl
;
14350 /* This is a chain of any other decls that came in among the parm
14351 declarations. If a parm is declared with enum {foo, bar} x;
14352 then CONST_DECLs for foo and bar are put here. */
14353 tree nonparms
= NULL_TREE
;
14355 if (current_function_parms
)
14357 /* This case is when the function was defined with an ANSI prototype.
14358 The parms already have decls, so we need not do anything here
14359 except record them as in effect
14360 and complain if any redundant old-style parm decls were written. */
14362 tree specparms
= current_function_parms
;
14365 /* Must clear this because it might contain TYPE_DECLs declared
14367 current_binding_level
->names
= NULL
;
14369 /* If we're doing semantic analysis, then we'll call pushdecl
14370 for each of these. We must do them in reverse order so that
14371 they end in the correct forward order. */
14372 specparms
= nreverse (specparms
);
14374 for (parm
= specparms
; parm
; parm
= next
)
14376 next
= DECL_CHAIN (parm
);
14377 if (TREE_CODE (parm
) == PARM_DECL
)
14379 if (DECL_NAME (parm
) == NULL_TREE
14380 || !VOID_TYPE_P (parm
))
14383 error ("parameter %qD declared void", parm
);
14387 /* If we find an enum constant or a type tag,
14388 put it aside for the moment. */
14389 TREE_CHAIN (parm
) = NULL_TREE
;
14390 nonparms
= chainon (nonparms
, parm
);
14394 /* Get the decls in their original chain order and record in the
14395 function. This is all and only the PARM_DECLs that were
14396 pushed into scope by the loop above. */
14397 DECL_ARGUMENTS (fndecl
) = getdecls ();
14400 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
14402 /* Now store the final chain of decls for the arguments
14403 as the decl-chain of the current lexical scope.
14404 Put the enumerators in as well, at the front so that
14405 DECL_ARGUMENTS is not modified. */
14406 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
14408 if (use_eh_spec_block (current_function_decl
))
14409 current_eh_spec_block
= begin_eh_spec_block ();
14413 /* We have finished doing semantic analysis on DECL, but have not yet
14414 generated RTL for its body. Save away our current state, so that
14415 when we want to generate RTL later we know what to do. */
14418 save_function_data (tree decl
)
14420 struct language_function
*f
;
14422 /* Save the language-specific per-function data so that we can
14423 get it back when we really expand this function. */
14424 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
14427 f
= ggc_alloc
<language_function
> ();
14428 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
14429 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
14431 /* Clear out the bits we don't need. */
14432 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
14433 f
->bindings
= NULL
;
14434 f
->x_local_names
= NULL
;
14435 f
->base
.local_typedefs
= NULL
;
14439 /* Set the return value of the constructor (if present). */
14442 finish_constructor_body (void)
14447 if (targetm
.cxx
.cdtor_returns_this ()
14448 && (! TYPE_FOR_JAVA (current_class_type
)))
14450 /* Any return from a constructor will end up here. */
14451 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14453 val
= DECL_ARGUMENTS (current_function_decl
);
14454 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14455 DECL_RESULT (current_function_decl
), val
);
14456 /* Return the address of the object. */
14457 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14458 add_stmt (exprstmt
);
14462 /* Do all the processing for the beginning of a destructor; set up the
14463 vtable pointers and cleanups for bases and members. */
14466 begin_destructor_body (void)
14468 tree compound_stmt
;
14470 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
14471 issued an error message. We still want to try to process the
14472 body of the function, but initialize_vtbl_ptrs will crash if
14473 TYPE_BINFO is NULL. */
14474 if (COMPLETE_TYPE_P (current_class_type
))
14476 compound_stmt
= begin_compound_stmt (0);
14477 /* Make all virtual function table pointers in non-virtual base
14478 classes point to CURRENT_CLASS_TYPE's virtual function
14480 initialize_vtbl_ptrs (current_class_ptr
);
14481 finish_compound_stmt (compound_stmt
);
14483 if (flag_lifetime_dse
14484 /* Clobbering an empty base is harmful if it overlays real data. */
14485 && !is_empty_class (current_class_type
))
14486 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
14488 /* And insert cleanups for our bases and members so that they
14489 will be properly destroyed if we throw. */
14490 push_base_cleanups ();
14494 /* At the end of every destructor we generate code to delete the object if
14495 necessary. Do that now. */
14498 finish_destructor_body (void)
14502 /* Any return from a destructor will end up here; that way all base
14503 and member cleanups will be run when the function returns. */
14504 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14506 if (targetm
.cxx
.cdtor_returns_this ())
14510 val
= DECL_ARGUMENTS (current_function_decl
);
14511 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14512 DECL_RESULT (current_function_decl
), val
);
14513 /* Return the address of the object. */
14514 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14515 add_stmt (exprstmt
);
14519 /* Do the necessary processing for the beginning of a function body, which
14520 in this case includes member-initializers, but not the catch clauses of
14521 a function-try-block. Currently, this means opening a binding level
14522 for the member-initializers (in a ctor), member cleanups (in a dtor),
14523 and capture proxies (in a lambda operator()). */
14526 begin_function_body (void)
14530 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
14533 if (processing_template_decl
)
14534 /* Do nothing now. */;
14536 /* Always keep the BLOCK node associated with the outermost pair of
14537 curly braces of a function. These are needed for correct
14538 operation of dwarfout.c. */
14539 keep_next_level (true);
14541 stmt
= begin_compound_stmt (BCS_FN_BODY
);
14543 if (processing_template_decl
)
14544 /* Do nothing now. */;
14545 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14546 begin_destructor_body ();
14551 /* Do the processing for the end of a function body. Currently, this means
14552 closing out the cleanups for fully-constructed bases and members, and in
14553 the case of the destructor, deleting the object if desired. Again, this
14554 is only meaningful for [cd]tors, since they are the only functions where
14555 there is a significant distinction between the main body and any
14556 function catch clauses. Handling, say, main() return semantics here
14557 would be wrong, as flowing off the end of a function catch clause for
14558 main() would also need to return 0. */
14561 finish_function_body (tree compstmt
)
14563 if (compstmt
== NULL_TREE
)
14566 /* Close the block. */
14567 finish_compound_stmt (compstmt
);
14569 if (processing_template_decl
)
14570 /* Do nothing now. */;
14571 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
14572 finish_constructor_body ();
14573 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14574 finish_destructor_body ();
14577 /* Given a function, returns the BLOCK corresponding to the outermost level
14578 of curly braces, skipping the artificial block created for constructor
14582 outer_curly_brace_block (tree fndecl
)
14584 tree block
= DECL_INITIAL (fndecl
);
14585 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14587 block
= BLOCK_SUBBLOCKS (block
);
14588 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14590 block
= BLOCK_SUBBLOCKS (block
);
14591 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
14595 /* If FNDECL is a class's key method, add the class to the list of
14596 keyed classes that should be emitted. */
14599 record_key_method_defined (tree fndecl
)
14601 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
14602 && DECL_VIRTUAL_P (fndecl
)
14603 && !processing_template_decl
)
14605 tree fnclass
= DECL_CONTEXT (fndecl
);
14606 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
14607 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
14611 /* Subroutine of finish_function.
14612 Save the body of constexpr functions for possible
14613 future compile time evaluation. */
14616 maybe_save_function_definition (tree fun
)
14618 if (!processing_template_decl
14619 && DECL_DECLARED_CONSTEXPR_P (fun
)
14620 && !cp_function_chain
->invalid_constexpr
14621 && !DECL_CLONED_FUNCTION_P (fun
))
14622 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
14625 /* Finish up a function declaration and compile that function
14626 all the way to assembler language output. The free the storage
14627 for the function definition.
14629 FLAGS is a bitwise or of the following values:
14631 We just finished processing the body of an in-class inline
14632 function definition. (This processing will have taken place
14633 after the class definition is complete.) */
14636 finish_function (int flags
)
14638 tree fndecl
= current_function_decl
;
14639 tree fntype
, ctype
= NULL_TREE
;
14640 int inclass_inline
= (flags
& 2) != 0;
14642 /* When we get some parse errors, we can end up without a
14643 current_function_decl, so cope. */
14644 if (fndecl
== NULL_TREE
)
14645 return error_mark_node
;
14647 if (c_dialect_objc ())
14648 objc_finish_function ();
14650 record_key_method_defined (fndecl
);
14652 fntype
= TREE_TYPE (fndecl
);
14654 /* TREE_READONLY (fndecl) = 1;
14655 This caused &foo to be of type ptr-to-const-function
14656 which then got a warning when stored in a ptr-to-function variable. */
14658 gcc_assert (building_stmt_list_p ());
14659 /* The current function is being defined, so its DECL_INITIAL should
14660 be set, and unless there's a multiple definition, it should be
14661 error_mark_node. */
14662 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
14664 /* For a cloned function, we've already got all the code we need;
14665 there's no need to add any extra bits. */
14666 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14668 /* Make it so that `main' always returns 0 by default. */
14669 if (DECL_MAIN_P (current_function_decl
))
14670 finish_return_stmt (integer_zero_node
);
14672 if (use_eh_spec_block (current_function_decl
))
14673 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14674 (TREE_TYPE (current_function_decl
)),
14675 current_eh_spec_block
);
14678 /* If we're saving up tree structure, tie off the function now. */
14679 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
14681 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
14682 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
14684 finish_fname_decls ();
14686 /* If this function can't throw any exceptions, remember that. */
14687 if (!processing_template_decl
14688 && !cp_function_chain
->can_throw
14689 && !flag_non_call_exceptions
14690 && !decl_replaceable_p (fndecl
))
14691 TREE_NOTHROW (fndecl
) = 1;
14693 /* This must come after expand_function_end because cleanups might
14694 have declarations (from inline functions) that need to go into
14695 this function's blocks. */
14697 /* If the current binding level isn't the outermost binding level
14698 for this function, either there is a bug, or we have experienced
14699 syntax errors and the statement tree is malformed. */
14700 if (current_binding_level
->kind
!= sk_function_parms
)
14702 /* Make sure we have already experienced errors. */
14703 gcc_assert (errorcount
);
14705 /* Throw away the broken statement tree and extra binding
14707 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
14709 while (current_binding_level
->kind
!= sk_function_parms
)
14711 if (current_binding_level
->kind
== sk_class
)
14712 pop_nested_class ();
14714 poplevel (0, 0, 0);
14717 poplevel (1, 0, 1);
14719 /* Statements should always be full-expressions at the outermost set
14720 of curly braces for a function. */
14721 gcc_assert (stmts_are_full_exprs_p ());
14723 /* If there are no return statements in a function with auto return type,
14724 the return type is void. But if the declared type is something like
14725 auto*, this is an error. */
14726 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
14727 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
14729 if (!is_auto (current_function_auto_return_pattern
)
14730 && !current_function_returns_value
&& !current_function_returns_null
)
14732 error ("no return statements in function returning %qT",
14733 current_function_auto_return_pattern
);
14734 inform (input_location
, "only plain %<auto%> return type can be "
14735 "deduced to %<void%>");
14737 apply_deduced_return_type (fndecl
, void_type_node
);
14738 fntype
= TREE_TYPE (fndecl
);
14741 // If this is a concept, check that the definition is reasonable.
14742 if (DECL_DECLARED_CONCEPT_P (fndecl
))
14743 check_function_concept (fndecl
);
14745 /* Save constexpr function body before it gets munged by
14746 the NRV transformation. */
14747 maybe_save_function_definition (fndecl
);
14749 /* Invoke the pre-genericize plugin before we start munging things. */
14750 if (!processing_template_decl
)
14751 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14753 /* Perform delayed folding before NRV transformation. */
14754 if (!processing_template_decl
)
14755 cp_fold_function (fndecl
);
14757 /* Set up the named return value optimization, if we can. Candidate
14758 variables are selected in check_return_expr. */
14759 if (current_function_return_value
)
14761 tree r
= current_function_return_value
;
14764 if (r
!= error_mark_node
14765 /* This is only worth doing for fns that return in memory--and
14766 simpler, since we don't have to worry about promoted modes. */
14767 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
14768 /* Only allow this for variables declared in the outer scope of
14769 the function so we know that their lifetime always ends with a
14770 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14771 we were to do this optimization in tree-ssa. */
14772 && (outer
= outer_curly_brace_block (fndecl
))
14773 && chain_member (r
, BLOCK_VARS (outer
)))
14774 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
14776 current_function_return_value
= NULL_TREE
;
14779 /* Remember that we were in class scope. */
14780 if (current_class_name
)
14781 ctype
= current_class_type
;
14783 /* Must mark the RESULT_DECL as being in this function. */
14784 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14786 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14787 to the FUNCTION_DECL node itself. */
14788 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14790 /* Save away current state, if appropriate. */
14791 if (!processing_template_decl
)
14792 save_function_data (fndecl
);
14794 /* Complain if there's just no return statement. */
14795 if (warn_return_type
14796 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14797 && !dependent_type_p (TREE_TYPE (fntype
))
14798 && !current_function_returns_value
&& !current_function_returns_null
14799 /* Don't complain if we abort or throw. */
14800 && !current_function_returns_abnormally
14801 /* Don't complain if there's an infinite loop. */
14802 && !current_function_infinite_loop
14803 /* Don't complain if we are declared noreturn. */
14804 && !TREE_THIS_VOLATILE (fndecl
)
14805 && !DECL_NAME (DECL_RESULT (fndecl
))
14806 && !TREE_NO_WARNING (fndecl
)
14807 /* Structor return values (if any) are set by the compiler. */
14808 && !DECL_CONSTRUCTOR_P (fndecl
)
14809 && !DECL_DESTRUCTOR_P (fndecl
)
14810 && targetm
.warn_func_return (fndecl
))
14812 warning (OPT_Wreturn_type
,
14813 "no return statement in function returning non-void");
14814 TREE_NO_WARNING (fndecl
) = 1;
14817 /* Store the end of the function, so that we get good line number
14818 info for the epilogue. */
14819 cfun
->function_end_locus
= input_location
;
14821 /* Complain about parameters that are only set, but never otherwise used. */
14822 if (warn_unused_but_set_parameter
14823 && !processing_template_decl
14824 && errorcount
== unused_but_set_errorcount
14825 && !DECL_CLONED_FUNCTION_P (fndecl
))
14829 for (decl
= DECL_ARGUMENTS (fndecl
);
14831 decl
= DECL_CHAIN (decl
))
14832 if (TREE_USED (decl
)
14833 && TREE_CODE (decl
) == PARM_DECL
14834 && !DECL_READ_P (decl
)
14835 && DECL_NAME (decl
)
14836 && !DECL_ARTIFICIAL (decl
)
14837 && !TREE_NO_WARNING (decl
)
14838 && !DECL_IN_SYSTEM_HEADER (decl
)
14839 && TREE_TYPE (decl
) != error_mark_node
14840 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14841 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14842 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14843 warning_at (DECL_SOURCE_LOCATION (decl
),
14844 OPT_Wunused_but_set_parameter
,
14845 "parameter %qD set but not used", decl
);
14846 unused_but_set_errorcount
= errorcount
;
14849 /* Complain about locally defined typedefs that are not used in this
14851 maybe_warn_unused_local_typedefs ();
14853 /* Possibly warn about unused parameters. */
14854 if (warn_unused_parameter
14855 && !processing_template_decl
14856 && !DECL_CLONED_FUNCTION_P (fndecl
))
14857 do_warn_unused_parameter (fndecl
);
14859 /* Genericize before inlining. */
14860 if (!processing_template_decl
)
14862 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14863 cp_genericize (fndecl
);
14864 /* Clear out the bits we don't need. */
14865 f
->x_current_class_ptr
= NULL
;
14866 f
->x_current_class_ref
= NULL
;
14867 f
->x_eh_spec_block
= NULL
;
14868 f
->x_in_charge_parm
= NULL
;
14869 f
->x_vtt_parm
= NULL
;
14870 f
->x_return_value
= NULL
;
14871 f
->bindings
= NULL
;
14872 f
->extern_decl_map
= NULL
;
14873 f
->infinite_loops
= NULL
;
14875 /* Clear out the bits we don't need. */
14876 local_names
= NULL
;
14878 /* We're leaving the context of this function, so zap cfun. It's still in
14879 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14881 current_function_decl
= NULL
;
14883 /* If this is an in-class inline definition, we may have to pop the
14884 bindings for the template parameters that we added in
14885 maybe_begin_member_template_processing when start_function was
14887 if (inclass_inline
)
14888 maybe_end_member_template_processing ();
14890 /* Leave the scope of the class. */
14892 pop_nested_class ();
14897 current_function_decl
= NULL_TREE
;
14899 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
14903 /* Create the FUNCTION_DECL for a function definition.
14904 DECLSPECS and DECLARATOR are the parts of the declaration;
14905 they describe the return type and the name of the function,
14906 but twisted together in a fashion that parallels the syntax of C.
14908 This function creates a binding context for the function body
14909 as well as setting up the FUNCTION_DECL in current_function_decl.
14911 Returns a FUNCTION_DECL on success.
14913 If the DECLARATOR is not suitable for a function (it defines a datum
14914 instead), we return 0, which tells yyparse to report a parse error.
14916 May return void_type_node indicating that this method is actually
14917 a friend. See grokfield for more details.
14919 Came here with a `.pushlevel' .
14921 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14922 CHANGES TO CODE IN `grokfield'. */
14925 grokmethod (cp_decl_specifier_seq
*declspecs
,
14926 const cp_declarator
*declarator
, tree attrlist
)
14928 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14931 if (fndecl
== error_mark_node
)
14932 return error_mark_node
;
14934 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14936 error ("invalid member function declaration");
14937 return error_mark_node
;
14941 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14943 /* Pass friends other than inline friend functions back. */
14944 if (fndecl
== void_type_node
)
14947 if (DECL_IN_AGGR_P (fndecl
))
14949 if (DECL_CLASS_SCOPE_P (fndecl
))
14950 error ("%qD is already defined in class %qT", fndecl
,
14951 DECL_CONTEXT (fndecl
));
14952 return error_mark_node
;
14955 check_template_shadow (fndecl
);
14957 if (TREE_PUBLIC (fndecl
))
14958 DECL_COMDAT (fndecl
) = 1;
14959 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14960 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14962 /* We process method specializations in finish_struct_1. */
14963 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14965 fndecl
= push_template_decl (fndecl
);
14966 if (fndecl
== error_mark_node
)
14970 if (! DECL_FRIEND_P (fndecl
))
14972 if (DECL_CHAIN (fndecl
))
14974 fndecl
= copy_node (fndecl
);
14975 TREE_CHAIN (fndecl
) = NULL_TREE
;
14979 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14981 DECL_IN_AGGR_P (fndecl
) = 1;
14986 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14987 we can lay it out later, when and if its type becomes complete.
14989 Also handle constexpr variables where the initializer involves
14990 an unlowered PTRMEM_CST because the class isn't complete yet. */
14993 maybe_register_incomplete_var (tree var
)
14995 gcc_assert (VAR_P (var
));
14997 /* Keep track of variables with incomplete types. */
14998 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14999 && DECL_EXTERNAL (var
))
15001 tree inner_type
= TREE_TYPE (var
);
15003 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
15004 inner_type
= TREE_TYPE (inner_type
);
15005 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
15007 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
15008 /* RTTI TD entries are created while defining the type_info. */
15009 || (TYPE_LANG_SPECIFIC (inner_type
)
15010 && TYPE_BEING_DEFINED (inner_type
)))
15012 incomplete_var iv
= {var
, inner_type
};
15013 vec_safe_push (incomplete_vars
, iv
);
15015 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
15016 && decl_constant_var_p (var
)
15017 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
15019 /* When the outermost open class is complete we can resolve any
15020 pointers-to-members. */
15021 tree context
= outermost_open_class ();
15022 incomplete_var iv
= {var
, context
};
15023 vec_safe_push (incomplete_vars
, iv
);
15028 /* Called when a class type (given by TYPE) is defined. If there are
15029 any existing VAR_DECLs whose type has been completed by this
15030 declaration, update them now. */
15033 complete_vars (tree type
)
15036 incomplete_var
*iv
;
15038 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
15040 if (same_type_p (type
, iv
->incomplete_type
))
15042 tree var
= iv
->decl
;
15043 tree type
= TREE_TYPE (var
);
15045 if (TYPE_MAIN_VARIANT (strip_array_types (type
))
15046 == iv
->incomplete_type
)
15048 /* Complete the type of the variable. The VAR_DECL itself
15049 will be laid out in expand_expr. */
15050 complete_type (type
);
15051 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
15054 /* Remove this entry from the list. */
15055 incomplete_vars
->unordered_remove (ix
);
15061 /* Check for pending declarations which may have abstract type. */
15062 complete_type_check_abstract (type
);
15065 /* If DECL is of a type which needs a cleanup, build and return an
15066 expression to perform that cleanup here. Return NULL_TREE if no
15067 cleanup need be done. */
15070 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
15076 /* Assume no cleanup is required. */
15077 cleanup
= NULL_TREE
;
15079 if (error_operand_p (decl
))
15082 /* Handle "__attribute__((cleanup))". We run the cleanup function
15083 before the destructor since the destructor is what actually
15084 terminates the lifetime of the object. */
15085 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
15092 /* Get the name specified by the user for the cleanup function. */
15093 id
= TREE_VALUE (TREE_VALUE (attr
));
15094 /* Look up the name to find the cleanup function to call. It is
15095 important to use lookup_name here because that is what is
15096 used in c-common.c:handle_cleanup_attribute when performing
15097 initial checks on the attribute. Note that those checks
15098 include ensuring that the function found is not an overloaded
15099 function, or an object with an overloaded call operator,
15100 etc.; we can rely on the fact that the function found is an
15101 ordinary FUNCTION_DECL. */
15102 fn
= lookup_name (id
);
15103 arg
= build_address (decl
);
15104 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
15105 return error_mark_node
;
15106 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
15107 if (cleanup
== error_mark_node
)
15108 return error_mark_node
;
15110 /* Handle ordinary C++ destructors. */
15111 type
= TREE_TYPE (decl
);
15112 if (type_build_dtor_call (type
))
15114 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
15118 if (TREE_CODE (type
) == ARRAY_TYPE
)
15121 addr
= build_address (decl
);
15123 call
= build_delete (TREE_TYPE (addr
), addr
,
15124 sfk_complete_destructor
, flags
, 0, complain
);
15125 if (call
== error_mark_node
)
15126 cleanup
= error_mark_node
;
15127 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
15128 /* Discard the call. */;
15130 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
15135 /* build_delete sets the location of the destructor call to the
15136 current location, even though the destructor is going to be
15137 called later, at the end of the current scope. This can lead to
15138 a "jumpy" behavior for users of debuggers when they step around
15139 the end of the block. So let's unset the location of the
15140 destructor call instead. */
15141 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
15144 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
15145 /* Treat objects with destructors as used; the destructor may do
15146 something substantive. */
15147 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
15148 return error_mark_node
;
15154 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
15155 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
15156 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
15159 static_fn_type (tree memfntype
)
15164 if (TYPE_PTRMEMFUNC_P (memfntype
))
15165 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
15166 if (POINTER_TYPE_P (memfntype
)
15167 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
15168 memfntype
= TREE_TYPE (memfntype
);
15169 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
15171 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
15172 args
= TYPE_ARG_TYPES (memfntype
);
15173 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
15174 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
15175 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
15176 fntype
= (cp_build_type_attribute_variant
15177 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
15178 fntype
= (build_exception_variant
15179 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
15180 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
15181 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
15185 /* DECL was originally constructed as a non-static member function,
15186 but turned out to be static. Update it accordingly. */
15189 revert_static_member_fn (tree decl
)
15191 tree stype
= static_fn_type (decl
);
15192 cp_cv_quals quals
= type_memfn_quals (stype
);
15193 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
15195 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
15196 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
15198 TREE_TYPE (decl
) = stype
;
15200 if (DECL_ARGUMENTS (decl
))
15201 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
15202 DECL_STATIC_FUNCTION_P (decl
) = 1;
15205 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
15206 one of the language-independent trees. */
15208 enum cp_tree_node_structure_enum
15209 cp_tree_node_structure (union lang_tree_node
* t
)
15211 switch (TREE_CODE (&t
->generic
))
15213 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
15214 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
15215 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
15216 case OVERLOAD
: return TS_CP_OVERLOAD
;
15217 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
15218 case PTRMEM_CST
: return TS_CP_PTRMEM
;
15219 case BASELINK
: return TS_CP_BASELINK
;
15220 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
15221 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
15222 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
15223 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
15224 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
15225 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
15226 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
15227 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
15228 default: return TS_CP_GENERIC
;
15232 /* Build the void_list_node (void_type_node having been created). */
15234 build_void_list_node (void)
15236 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
15241 cp_missing_noreturn_ok_p (tree decl
)
15243 /* A missing noreturn is ok for the `main' function. */
15244 return DECL_MAIN_P (decl
);
15247 /* Return the decl used to identify the COMDAT group into which DECL should
15251 cxx_comdat_group (tree decl
)
15253 /* Virtual tables, construction virtual tables, and virtual table
15254 tables all go in a single COMDAT group, named after the primary
15256 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
15257 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
15258 /* For all other DECLs, the COMDAT group is the mangled name of the
15259 declaration itself. */
15262 while (DECL_THUNK_P (decl
))
15264 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
15265 into the same section as the target function. In that case
15266 we must return target's name. */
15267 tree target
= THUNK_TARGET (decl
);
15268 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
15269 && DECL_SECTION_NAME (target
) != NULL
15270 && DECL_ONE_ONLY (target
))
15280 /* Returns the return type for FN as written by the user, which may include
15281 a placeholder for a deduced return type. */
15284 fndecl_declared_return_type (tree fn
)
15286 fn
= STRIP_TEMPLATE (fn
);
15287 if (FNDECL_USED_AUTO (fn
))
15289 struct language_function
*f
= NULL
;
15290 if (DECL_STRUCT_FUNCTION (fn
))
15291 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
15293 f
= DECL_SAVED_FUNCTION_DATA (fn
);
15294 return f
->x_auto_return_pattern
;
15296 return TREE_TYPE (TREE_TYPE (fn
));
15299 /* Returns true iff DECL was declared with an auto return type and it has
15300 not yet been deduced to a real type. */
15303 undeduced_auto_decl (tree decl
)
15305 if (cxx_dialect
< cxx14
)
15307 return type_uses_auto (TREE_TYPE (decl
));
15310 /* Complain if DECL has an undeduced return type. */
15313 require_deduced_type (tree decl
)
15315 if (undeduced_auto_decl (decl
))
15316 error ("use of %qD before deduction of %<auto%>", decl
);
15319 #include "gt-cp-decl.h"