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 SET_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 SET_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 SET_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 SET_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 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5899 /* Dispatch to specialized routines. */
5900 if (CLASS_TYPE_P (type
))
5901 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5902 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5903 return reshape_init_array (type
, d
, complain
);
5904 else if (VECTOR_TYPE_P (type
))
5905 return reshape_init_vector (type
, d
, complain
);
5910 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5911 brace-enclosed aggregate initializer.
5913 INIT is the CONSTRUCTOR containing the list of initializers describing
5914 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5915 It may not presently match the shape of the TYPE; for example:
5917 struct S { int a; int b; };
5918 struct S a[] = { 1, 2, 3, 4 };
5920 Here INIT will hold a vector of four elements, rather than a
5921 vector of two elements, each itself a vector of two elements. This
5922 routine transforms INIT from the former form into the latter. The
5923 revised CONSTRUCTOR node is returned. */
5926 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5928 vec
<constructor_elt
, va_gc
> *v
;
5932 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5934 v
= CONSTRUCTOR_ELTS (init
);
5936 /* An empty constructor does not need reshaping, and it is always a valid
5938 if (vec_safe_is_empty (v
))
5941 /* Recurse on this CONSTRUCTOR. */
5943 d
.end
= d
.cur
+ v
->length ();
5945 new_init
= reshape_init_r (type
, &d
, true, complain
);
5946 if (new_init
== error_mark_node
)
5947 return error_mark_node
;
5949 /* Make sure all the element of the constructor were used. Otherwise,
5950 issue an error about exceeding initializers. */
5953 if (complain
& tf_error
)
5954 error ("too many initializers for %qT", type
);
5956 return error_mark_node
;
5962 /* Verify array initializer. Returns true if errors have been reported. */
5965 check_array_initializer (tree decl
, tree type
, tree init
)
5967 tree element_type
= TREE_TYPE (type
);
5969 /* The array type itself need not be complete, because the
5970 initializer may tell us how many elements are in the array.
5971 But, the elements of the array must be complete. */
5972 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5975 error ("elements of array %q#D have incomplete type", decl
);
5977 error ("elements of array %q#T have incomplete type", type
);
5980 /* A compound literal can't have variable size. */
5982 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5983 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5985 error ("variable-sized compound literal");
5991 /* Subroutine of check_initializer; args are passed down from that function.
5992 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5995 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5998 gcc_assert (stmts_are_full_exprs_p ());
5999 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
6002 /* Verify INIT (the initializer for DECL), and record the
6003 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6004 grok_reference_init.
6006 If the return value is non-NULL, it is an expression that must be
6007 evaluated dynamically to initialize DECL. */
6010 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
6012 tree type
= TREE_TYPE (decl
);
6013 tree init_code
= NULL
;
6016 /* Things that are going to be initialized need to have complete
6018 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
6020 if (DECL_HAS_VALUE_EXPR_P (decl
))
6022 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6023 it doesn't have storage to be initialized. */
6024 gcc_assert (init
== NULL_TREE
);
6028 if (type
== error_mark_node
)
6029 /* We will have already complained. */
6032 if (TREE_CODE (type
) == ARRAY_TYPE
)
6034 if (check_array_initializer (decl
, type
, init
))
6037 else if (!COMPLETE_TYPE_P (type
))
6039 error ("%q#D has incomplete type", decl
);
6040 TREE_TYPE (decl
) = error_mark_node
;
6044 /* There is no way to make a variable-sized class type in GNU C++. */
6045 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6047 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6049 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
6050 if (SCALAR_TYPE_P (type
))
6054 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6055 init
= build_zero_init (type
, NULL_TREE
, false);
6057 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6059 error ("scalar object %qD requires one element in initializer",
6061 TREE_TYPE (decl
) = error_mark_node
;
6067 if (TREE_CODE (decl
) == CONST_DECL
)
6069 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
6071 DECL_INITIAL (decl
) = init
;
6073 gcc_assert (init
!= NULL_TREE
);
6076 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6078 else if (init
|| type_build_ctor_call (type
)
6079 || TREE_CODE (type
) == REFERENCE_TYPE
)
6081 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6083 init
= grok_reference_init (decl
, type
, init
, flags
);
6084 flags
|= LOOKUP_ALREADY_DIGESTED
;
6087 check_for_uninitialized_const_var (decl
);
6088 /* Do not reshape constructors of vectors (they don't need to be
6090 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6092 if (is_std_init_list (type
))
6094 init
= perform_implicit_conversion (type
, init
,
6095 tf_warning_or_error
);
6096 flags
|= LOOKUP_ALREADY_DIGESTED
;
6098 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6100 /* Don't reshape if the class has constructors. */
6101 if (cxx_dialect
== cxx98
)
6102 error ("in C++98 %qD must be initialized by constructor, "
6106 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6108 error ("opaque vector types cannot be initialized");
6109 init
= error_mark_node
;
6113 init
= reshape_init (type
, init
, tf_warning_or_error
);
6114 flags
|= LOOKUP_NO_NARROWING
;
6117 else if (TREE_CODE (init
) == TREE_LIST
6118 && TREE_TYPE (init
) != unknown_type_node
6119 && !MAYBE_CLASS_TYPE_P (type
))
6121 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6123 /* We get here with code like `int a (2);' */
6124 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6125 tf_warning_or_error
);
6128 /* If DECL has an array type without a specific bound, deduce the
6129 array size from the initializer. */
6130 maybe_deduce_size_from_array_init (decl
, init
);
6131 type
= TREE_TYPE (decl
);
6132 if (type
== error_mark_node
)
6135 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6136 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6137 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6138 && CP_AGGREGATE_TYPE_P (type
)
6139 && (CLASS_TYPE_P (type
)
6140 || !TYPE_NEEDS_CONSTRUCTING (type
)
6141 || type_has_extended_temps (type
))))
6143 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6145 /* A constructor call is a non-trivial initializer even if
6146 it isn't explicitly written. */
6147 if (TREE_SIDE_EFFECTS (init_code
))
6148 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6150 /* If this is a constexpr initializer, expand_default_init will
6151 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6152 case, pull the initializer back out and pass it down into
6153 store_init_value. */
6154 while (TREE_CODE (init_code
) == EXPR_STMT
6155 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6156 init_code
= TREE_OPERAND (init_code
, 0);
6157 if (TREE_CODE (init_code
) == INIT_EXPR
)
6159 init
= TREE_OPERAND (init_code
, 1);
6160 init_code
= NULL_TREE
;
6161 /* Don't call digest_init; it's unnecessary and will complain
6162 about aggregate initialization of non-aggregate classes. */
6163 flags
|= LOOKUP_ALREADY_DIGESTED
;
6165 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6167 /* Declared constexpr, but no suitable initializer; massage
6168 init appropriately so we can pass it into store_init_value
6170 if (CLASS_TYPE_P (type
)
6171 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6173 init
= build_functional_cast (type
, init
, tf_none
);
6174 if (TREE_CODE (init
) == TARGET_EXPR
)
6175 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6177 init_code
= NULL_TREE
;
6183 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6185 /* In aggregate initialization of a variable, each element
6186 initialization is a full-expression because there is no
6187 enclosing expression. */
6188 gcc_assert (stmts_are_full_exprs_p ());
6190 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6192 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6193 && DECL_INITIAL (decl
)
6194 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6195 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6196 warning (0, "array %qD initialized by parenthesized string literal %qE",
6197 decl
, DECL_INITIAL (decl
));
6203 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6204 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6205 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6206 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6209 check_for_uninitialized_const_var (decl
);
6212 if (init
&& init
!= error_mark_node
)
6213 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6217 /* We might have set these in cp_finish_decl. */
6218 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6219 TREE_CONSTANT (decl
) = false;
6222 if (init_code
&& DECL_IN_AGGR_P (decl
))
6224 static int explained
= 0;
6226 if (cxx_dialect
< cxx11
)
6227 error ("initializer invalid for static member with constructor");
6229 error ("non-constant in-class initialization invalid for static "
6230 "member %qD", decl
);
6233 inform (input_location
,
6234 "(an out of class initialization is required)");
6243 /* If DECL is not a local variable, give it RTL. */
6246 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6248 int toplev
= toplevel_bindings_p ();
6251 /* Set the DECL_ASSEMBLER_NAME for the object. */
6254 /* The `register' keyword, when used together with an
6255 asm-specification, indicates that the variable should be
6256 placed in a particular register. */
6257 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6259 set_user_assembler_name (decl
, asmspec
);
6260 DECL_HARD_REGISTER (decl
) = 1;
6264 if (TREE_CODE (decl
) == FUNCTION_DECL
6265 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6266 set_builtin_user_assembler_name (decl
, asmspec
);
6267 set_user_assembler_name (decl
, asmspec
);
6271 /* Handle non-variables up front. */
6274 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6278 /* If we see a class member here, it should be a static data
6280 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6282 gcc_assert (TREE_STATIC (decl
));
6283 /* An in-class declaration of a static data member should be
6284 external; it is only a declaration, and not a definition. */
6285 if (init
== NULL_TREE
)
6286 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
6289 /* We don't create any RTL for local variables. */
6290 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6293 /* We defer emission of local statics until the corresponding
6294 DECL_EXPR is expanded. But with constexpr its function might never
6295 be expanded, so go ahead and tell cgraph about the variable now. */
6296 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6297 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (decl
)))
6298 || DECL_VIRTUAL_P (decl
));
6300 /* Defer template instantiations. */
6301 if (DECL_LANG_SPECIFIC (decl
)
6302 && DECL_IMPLICIT_INSTANTIATION (decl
))
6305 /* If we're not deferring, go ahead and assemble the variable. */
6307 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6310 /* walk_tree helper for wrap_temporary_cleanups, below. */
6313 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6315 /* Stop at types or full-expression boundaries. */
6316 if (TYPE_P (*stmt_p
)
6317 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6323 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6325 tree guard
= (tree
)data
;
6326 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6328 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6329 /* Tell honor_protect_cleanup_actions to handle this as a separate
6331 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6333 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6339 /* We're initializing a local variable which has a cleanup GUARD. If there
6340 are any temporaries used in the initializer INIT of this variable, we
6341 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6342 variable will be cleaned up properly if one of them throws.
6344 Unfortunately, there's no way to express this properly in terms of
6345 nesting, as the regions for the temporaries overlap the region for the
6346 variable itself; if there are two temporaries, the variable needs to be
6347 the first thing destroyed if either of them throws. However, we only
6348 want to run the variable's cleanup if it actually got constructed. So
6349 we need to guard the temporary cleanups with the variable's cleanup if
6350 they are run on the normal path, but not if they are run on the
6351 exceptional path. We implement this by telling
6352 honor_protect_cleanup_actions to strip the variable cleanup from the
6353 exceptional path. */
6356 wrap_temporary_cleanups (tree init
, tree guard
)
6358 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6361 /* Generate code to initialize DECL (a local variable). */
6364 initialize_local_var (tree decl
, tree init
)
6366 tree type
= TREE_TYPE (decl
);
6370 gcc_assert (VAR_P (decl
)
6371 || TREE_CODE (decl
) == RESULT_DECL
);
6372 gcc_assert (!TREE_STATIC (decl
));
6374 if (DECL_SIZE (decl
) == NULL_TREE
)
6376 /* If we used it already as memory, it must stay in memory. */
6377 DECL_INITIAL (decl
) = NULL_TREE
;
6378 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6382 if (type
== error_mark_node
)
6385 /* Compute and store the initial value. */
6386 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6387 if (TREE_USED (type
))
6388 DECL_READ_P (decl
) = 1;
6390 /* Generate a cleanup, if necessary. */
6391 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6393 /* Perform the initialization. */
6396 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6397 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6398 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6400 /* Stick simple initializers in DECL_INITIAL so that
6401 -Wno-init-self works (c++/34772). */
6402 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6403 DECL_INITIAL (decl
) = rinit
;
6405 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6409 warning_at (DECL_SOURCE_LOCATION (decl
),
6411 "reference %qD is initialized with itself", decl
);
6416 int saved_stmts_are_full_exprs_p
;
6418 /* If we're only initializing a single object, guard the
6419 destructors of any temporaries used in its initializer with
6420 its destructor. This isn't right for arrays because each
6421 element initialization is a full-expression. */
6422 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6423 wrap_temporary_cleanups (init
, cleanup
);
6425 gcc_assert (building_stmt_list_p ());
6426 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6427 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6428 finish_expr_stmt (init
);
6429 current_stmt_tree ()->stmts_are_full_exprs_p
=
6430 saved_stmts_are_full_exprs_p
;
6434 /* Set this to 0 so we can tell whether an aggregate which was
6435 initialized was ever used. Don't do this if it has a
6436 destructor, so we don't complain about the 'resource
6437 allocation is initialization' idiom. Now set
6438 attribute((unused)) on types so decls of that type will be
6439 marked used. (see TREE_USED, above.) */
6440 if (TYPE_NEEDS_CONSTRUCTING (type
)
6442 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6443 && DECL_NAME (decl
))
6444 TREE_USED (decl
) = 0;
6445 else if (already_used
)
6446 TREE_USED (decl
) = 1;
6449 finish_decl_cleanup (decl
, cleanup
);
6452 /* DECL is a VAR_DECL for a compiler-generated variable with static
6453 storage duration (like a virtual table) whose initializer is a
6454 compile-time constant. Initialize the variable and provide it to the
6458 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6461 gcc_assert (DECL_ARTIFICIAL (decl
));
6462 init
= build_constructor (TREE_TYPE (decl
), v
);
6463 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6464 DECL_INITIAL (decl
) = init
;
6465 DECL_INITIALIZED_P (decl
) = 1;
6466 determine_visibility (decl
);
6467 layout_var_decl (decl
);
6468 maybe_commonize_var (decl
);
6469 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6472 /* INIT is the initializer for a variable, as represented by the
6473 parser. Returns true iff INIT is type-dependent. */
6476 type_dependent_init_p (tree init
)
6478 if (TREE_CODE (init
) == TREE_LIST
)
6479 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6480 return any_type_dependent_elements_p (init
);
6481 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6482 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6484 vec
<constructor_elt
, va_gc
> *elts
;
6488 elts
= CONSTRUCTOR_ELTS (init
);
6489 nelts
= vec_safe_length (elts
);
6490 for (i
= 0; i
< nelts
; ++i
)
6491 if (type_dependent_init_p ((*elts
)[i
].value
))
6495 /* It must be a simple expression, e.g., int i = 3; */
6496 return type_dependent_expression_p (init
);
6501 /* INIT is the initializer for a variable, as represented by the
6502 parser. Returns true iff INIT is value-dependent. */
6505 value_dependent_init_p (tree init
)
6507 if (TREE_CODE (init
) == TREE_LIST
)
6508 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6509 return any_value_dependent_elements_p (init
);
6510 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6511 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6513 vec
<constructor_elt
, va_gc
> *elts
;
6517 elts
= CONSTRUCTOR_ELTS (init
);
6518 nelts
= vec_safe_length (elts
);
6519 for (i
= 0; i
< nelts
; ++i
)
6520 if (value_dependent_init_p ((*elts
)[i
].value
))
6524 /* It must be a simple expression, e.g., int i = 3; */
6525 return value_dependent_expression_p (init
);
6530 // Returns true if a DECL is VAR_DECL with the concept specifier.
6532 is_concept_var (tree decl
)
6534 return (VAR_P (decl
)
6535 // Not all variables have DECL_LANG_SPECIFIC.
6536 && DECL_LANG_SPECIFIC (decl
)
6537 && DECL_DECLARED_CONCEPT_P (decl
));
6540 /* A helper function to be called via walk_tree. If any label exists
6541 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6544 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6548 if (TREE_CODE (*tp
) == LABEL_DECL
)
6549 cfun
->has_forced_label_in_static
= 1;
6553 /* Finish processing of a declaration;
6554 install its line number and initial value.
6555 If the length of an array type is not known before,
6556 it must be determined now, from the initial value, or it is an error.
6558 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6559 true, then INIT is an integral constant expression.
6561 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6562 if the (init) syntax was used. */
6565 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6566 tree asmspec_tree
, int flags
)
6569 vec
<tree
, va_gc
> *cleanups
= NULL
;
6570 const char *asmspec
= NULL
;
6571 int was_readonly
= 0;
6572 bool var_definition_p
= false;
6575 if (decl
== error_mark_node
)
6580 error ("assignment (not initialization) in declaration");
6584 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6585 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6586 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6588 type
= TREE_TYPE (decl
);
6589 if (type
== error_mark_node
)
6592 /* If a name was specified, get the string. */
6593 if (at_namespace_scope_p ())
6594 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6595 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6596 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6598 if (current_class_type
6599 && CP_DECL_CONTEXT (decl
) == current_class_type
6600 && TYPE_BEING_DEFINED (current_class_type
)
6601 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6602 && (DECL_INITIAL (decl
) || init
))
6603 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6605 if (TREE_CODE (decl
) != FUNCTION_DECL
6606 && (auto_node
= type_uses_auto (type
)))
6609 if (init
== NULL_TREE
)
6611 if (DECL_LANG_SPECIFIC (decl
)
6612 && DECL_TEMPLATE_INSTANTIATION (decl
)
6613 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6615 /* init is null because we're deferring instantiating the
6616 initializer until we need it. Well, we need it now. */
6617 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6621 error ("declaration of %q#D has no initializer", decl
);
6622 TREE_TYPE (decl
) = error_mark_node
;
6626 if (TREE_CODE (d_init
) == TREE_LIST
)
6627 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6628 tf_warning_or_error
);
6629 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
6630 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6632 tf_warning_or_error
,
6634 if (type
== error_mark_node
)
6636 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6639 if (!ensure_literal_type_for_constexpr_object (decl
))
6640 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6643 && DECL_CLASS_SCOPE_P (decl
)
6644 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6645 check_static_variable_definition (decl
, type
);
6647 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6650 if (init
== ridpointers
[(int)RID_DELETE
])
6652 /* FIXME check this is 1st decl. */
6653 DECL_DELETED_FN (decl
) = 1;
6654 DECL_DECLARED_INLINE_P (decl
) = 1;
6655 DECL_INITIAL (decl
) = error_mark_node
;
6656 FOR_EACH_CLONE (clone
, decl
)
6658 DECL_DELETED_FN (clone
) = 1;
6659 DECL_DECLARED_INLINE_P (clone
) = 1;
6660 DECL_INITIAL (clone
) = error_mark_node
;
6664 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6666 if (defaultable_fn_check (decl
))
6667 DECL_DEFAULTED_FN (decl
) = 1;
6669 DECL_INITIAL (decl
) = NULL_TREE
;
6673 if (init
&& VAR_P (decl
))
6675 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6676 /* If DECL is a reference, then we want to know whether init is a
6677 reference constant; init_const_expr_p as passed tells us whether
6678 it's an rvalue constant. */
6679 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6680 init_const_expr_p
= potential_constant_expression (init
);
6681 if (init_const_expr_p
)
6683 /* Set these flags now for templates. We'll update the flags in
6684 store_init_value for instantiations. */
6685 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6686 if (decl_maybe_constant_var_p (decl
))
6687 TREE_CONSTANT (decl
) = 1;
6691 if (processing_template_decl
)
6693 bool type_dependent_p
;
6695 /* Add this declaration to the statement-tree. */
6696 if (at_function_scope_p ())
6697 add_decl_expr (decl
);
6699 type_dependent_p
= dependent_type_p (type
);
6701 if (check_for_bare_parameter_packs (init
))
6704 DECL_INITIAL (decl
) = NULL_TREE
;
6707 /* Generally, initializers in templates are expanded when the
6708 template is instantiated. But, if DECL is a variable constant
6709 then it can be used in future constant expressions, so its value
6710 must be available. */
6712 if (!VAR_P (decl
) || type_dependent_p
)
6713 /* We can't do anything if the decl has dependent type. */;
6715 && init_const_expr_p
6716 && TREE_CODE (type
) != REFERENCE_TYPE
6717 && decl_maybe_constant_var_p (decl
)
6718 && !type_dependent_init_p (init
)
6719 && !value_dependent_init_p (init
))
6721 /* This variable seems to be a non-dependent constant, so process
6722 its initializer. If check_initializer returns non-null the
6723 initialization wasn't constant after all. */
6725 cleanups
= make_tree_vector ();
6726 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6727 if (init_code
== NULL_TREE
)
6729 release_tree_vector (cleanups
);
6731 else if (!init
&& is_concept_var (decl
))
6732 error ("variable concept has no initializer");
6733 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6735 /* Deduce array size even if the initializer is dependent. */
6736 maybe_deduce_size_from_array_init (decl
, init
);
6737 /* And complain about multiple initializers. */
6738 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6739 && !MAYBE_CLASS_TYPE_P (type
))
6740 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6741 tf_warning_or_error
);
6745 DECL_INITIAL (decl
) = init
;
6749 /* Just store non-static data member initializers for later. */
6750 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6751 DECL_INITIAL (decl
) = init
;
6753 /* Take care of TYPE_DECLs up front. */
6754 if (TREE_CODE (decl
) == TYPE_DECL
)
6756 if (type
!= error_mark_node
6757 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6759 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6760 warning (0, "shadowing previous type declaration of %q#D", decl
);
6761 set_identifier_type_value (DECL_NAME (decl
), decl
);
6764 /* If we have installed this as the canonical typedef for this
6765 type, and that type has not been defined yet, delay emitting
6766 the debug information for it, as we will emit it later. */
6767 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6768 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6769 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6771 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6776 /* A reference will be modified here, as it is initialized. */
6777 if (! DECL_EXTERNAL (decl
)
6778 && TREE_READONLY (decl
)
6779 && TREE_CODE (type
) == REFERENCE_TYPE
)
6782 TREE_READONLY (decl
) = 0;
6787 /* If this is a local variable that will need a mangled name,
6788 register it now. We must do this before processing the
6789 initializer for the variable, since the initialization might
6790 require a guard variable, and since the mangled name of the
6791 guard variable will depend on the mangled name of this
6793 if (DECL_FUNCTION_SCOPE_P (decl
)
6794 && TREE_STATIC (decl
)
6795 && !DECL_ARTIFICIAL (decl
))
6797 push_local_name (decl
);
6798 /* Normally has_forced_label_in_static is set during GIMPLE
6799 lowering, but [cd]tors are never actually compiled directly.
6800 We need to set this early so we can deal with the label
6801 address extension. */
6802 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
6803 || DECL_DESTRUCTOR_P (current_function_decl
))
6806 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
6807 add_local_decl (cfun
, decl
);
6809 /* And make sure it's in the symbol table for
6810 c_parse_final_cleanups to find. */
6811 varpool_node::get_create (decl
);
6814 /* Convert the initializer to the type of DECL, if we have not
6815 already initialized DECL. */
6816 if (!DECL_INITIALIZED_P (decl
)
6817 /* If !DECL_EXTERNAL then DECL is being defined. In the
6818 case of a static data member initialized inside the
6819 class-specifier, there can be an initializer even if DECL
6820 is *not* defined. */
6821 && (!DECL_EXTERNAL (decl
) || init
))
6823 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6826 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6827 /* Allow libjava/prims.cc define primitive classes. */
6828 if (init
!= NULL_TREE
6829 || jclass
== NULL_TREE
6830 || TREE_CODE (jclass
) != TYPE_DECL
6831 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6832 || !same_type_ignoring_top_level_qualifiers_p
6833 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6834 error ("Java object %qD not allocated with %<new%>", decl
);
6837 cleanups
= make_tree_vector ();
6838 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6844 The memory occupied by any object of static storage
6845 duration is zero-initialized at program startup before
6846 any other initialization takes place.
6848 We cannot create an appropriate initializer until after
6849 the type of DECL is finalized. If DECL_INITIAL is set,
6850 then the DECL is statically initialized, and any
6851 necessary zero-initialization has already been performed. */
6852 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6853 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6854 /*nelts=*/NULL_TREE
,
6855 /*static_storage_p=*/true);
6856 /* Remember that the initialization for this variable has
6858 DECL_INITIALIZED_P (decl
) = 1;
6859 /* This declaration is the definition of this variable,
6860 unless we are initializing a static data member within
6861 the class specifier. */
6862 if (!DECL_EXTERNAL (decl
))
6863 var_definition_p
= true;
6865 /* If the variable has an array type, lay out the type, even if
6866 there is no initializer. It is valid to index through the
6867 array, and we must get TYPE_ALIGN set correctly on the array
6869 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6872 if (TREE_STATIC (decl
)
6873 && !at_function_scope_p ()
6874 && current_function_decl
== NULL
)
6875 /* So decl is a global variable or a static member of a
6876 non local class. Record the types it uses
6877 so that we can decide later to emit debug info for them. */
6878 record_types_used_by_current_var_decl (decl
);
6880 else if (TREE_CODE (decl
) == FIELD_DECL
6881 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6882 error ("non-static data member %qD has Java class type", decl
);
6884 /* Add this declaration to the statement-tree. This needs to happen
6885 after the call to check_initializer so that the DECL_EXPR for a
6886 reference temp is added before the DECL_EXPR for the reference itself. */
6887 if (DECL_FUNCTION_SCOPE_P (decl
))
6889 /* If we're building a variable sized type, and we might be
6890 reachable other than via the top of the current binding
6891 level, then create a new BIND_EXPR so that we deallocate
6892 the object at the right time. */
6895 && !TREE_CONSTANT (DECL_SIZE (decl
))
6896 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
6899 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6900 TREE_SIDE_EFFECTS (bind
) = 1;
6902 BIND_EXPR_BODY (bind
) = push_stmt_list ();
6904 add_decl_expr (decl
);
6907 /* Let the middle end know about variables and functions -- but not
6908 static data members in uninstantiated class templates. */
6909 if (VAR_OR_FUNCTION_DECL_P (decl
))
6913 layout_var_decl (decl
);
6914 maybe_commonize_var (decl
);
6917 /* This needs to happen after the linkage is set. */
6918 determine_visibility (decl
);
6920 if (var_definition_p
&& TREE_STATIC (decl
))
6922 /* If a TREE_READONLY variable needs initialization
6923 at runtime, it is no longer readonly and we need to
6924 avoid MEM_READONLY_P being set on RTL created for it. */
6927 if (TREE_READONLY (decl
))
6928 TREE_READONLY (decl
) = 0;
6931 else if (was_readonly
)
6932 TREE_READONLY (decl
) = 1;
6934 /* Likewise if it needs destruction. */
6935 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6936 TREE_READONLY (decl
) = 0;
6939 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6941 /* Check for abstractness of the type. Notice that there is no
6942 need to strip array types here since the check for those types
6943 is already done within create_array_type_for_decl. */
6944 abstract_virtuals_error (decl
, type
);
6946 if (TREE_TYPE (decl
) == error_mark_node
)
6947 /* No initialization required. */
6949 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6953 if (init
== ridpointers
[(int)RID_DEFAULT
])
6955 /* An out-of-class default definition is defined at
6956 the point where it is explicitly defaulted. */
6957 if (DECL_DELETED_FN (decl
))
6958 maybe_explain_implicit_delete (decl
);
6959 else if (DECL_INITIAL (decl
) == error_mark_node
)
6960 synthesize_method (decl
);
6963 error ("function %q#D is initialized like a variable", decl
);
6965 /* else no initialization required. */
6967 else if (DECL_EXTERNAL (decl
)
6968 && ! (DECL_LANG_SPECIFIC (decl
)
6969 && DECL_NOT_REALLY_EXTERN (decl
)))
6972 DECL_INITIAL (decl
) = init
;
6974 /* A variable definition. */
6975 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6976 /* Initialize the local variable. */
6977 initialize_local_var (decl
, init
);
6979 /* If a variable is defined, and then a subsequent
6980 definition with external linkage is encountered, we will
6981 get here twice for the same variable. We want to avoid
6982 calling expand_static_init more than once. For variables
6983 that are not static data members, we can call
6984 expand_static_init only when we actually process the
6985 initializer. It is not legal to redeclare a static data
6986 member, so this issue does not arise in that case. */
6987 else if (var_definition_p
&& TREE_STATIC (decl
))
6988 expand_static_init (decl
, init
);
6991 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6992 reference, insert it in the statement-tree now. */
6996 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6997 push_cleanup (decl
, t
, false);
6998 release_tree_vector (cleanups
);
7002 TREE_READONLY (decl
) = 1;
7004 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7007 /* Returns a declaration for a VAR_DECL as if:
7009 extern "C" TYPE NAME;
7011 had been seen. Used to create compiler-generated global
7015 declare_global_var (tree name
, tree type
)
7019 push_to_top_level ();
7020 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7021 TREE_PUBLIC (decl
) = 1;
7022 DECL_EXTERNAL (decl
) = 1;
7023 DECL_ARTIFICIAL (decl
) = 1;
7024 /* If the user has explicitly declared this variable (perhaps
7025 because the code we are compiling is part of a low-level runtime
7026 library), then it is possible that our declaration will be merged
7027 with theirs by pushdecl. */
7028 decl
= pushdecl (decl
);
7029 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7030 pop_from_top_level ();
7035 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7036 if "__cxa_atexit" is not being used) corresponding to the function
7037 to be called when the program exits. */
7040 get_atexit_fn_ptr_type (void)
7044 if (!atexit_fn_ptr_type_node
)
7047 if (flag_use_cxa_atexit
7048 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7049 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7050 arg_type
= ptr_type_node
;
7052 /* The parameter to "atexit" is "void (*)(void)". */
7053 arg_type
= NULL_TREE
;
7055 fn_type
= build_function_type_list (void_type_node
,
7056 arg_type
, NULL_TREE
);
7057 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
7060 return atexit_fn_ptr_type_node
;
7063 /* Returns a pointer to the `atexit' function. Note that if
7064 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7065 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7068 get_atexit_node (void)
7074 bool use_aeabi_atexit
;
7079 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7081 /* The declaration for `__cxa_atexit' is:
7083 int __cxa_atexit (void (*)(void *), void *, void *)
7085 We build up the argument types and then the function type
7087 tree argtype0
, argtype1
, argtype2
;
7089 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
7090 /* First, build the pointer-to-function type for the first
7092 fn_ptr_type
= get_atexit_fn_ptr_type ();
7093 /* Then, build the rest of the argument types. */
7094 argtype2
= ptr_type_node
;
7095 if (use_aeabi_atexit
)
7097 argtype1
= fn_ptr_type
;
7098 argtype0
= ptr_type_node
;
7102 argtype1
= ptr_type_node
;
7103 argtype0
= fn_ptr_type
;
7105 /* And the final __cxa_atexit type. */
7106 fn_type
= build_function_type_list (integer_type_node
,
7107 argtype0
, argtype1
, argtype2
,
7109 if (use_aeabi_atexit
)
7110 name
= "__aeabi_atexit";
7112 name
= "__cxa_atexit";
7116 /* The declaration for `atexit' is:
7118 int atexit (void (*)());
7120 We build up the argument types and then the function type
7122 fn_ptr_type
= get_atexit_fn_ptr_type ();
7123 /* Build the final atexit type. */
7124 fn_type
= build_function_type_list (integer_type_node
,
7125 fn_ptr_type
, NULL_TREE
);
7129 /* Now, build the function declaration. */
7130 push_lang_context (lang_name_c
);
7131 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
7132 mark_used (atexit_fndecl
);
7133 pop_lang_context ();
7134 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7139 /* Like get_atexit_node, but for thread-local cleanups. */
7142 get_thread_atexit_node (void)
7144 /* The declaration for `__cxa_thread_atexit' is:
7146 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
7147 tree fn_type
= build_function_type_list (integer_type_node
,
7148 get_atexit_fn_ptr_type (),
7149 ptr_type_node
, ptr_type_node
,
7152 /* Now, build the function declaration. */
7153 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
7154 ECF_LEAF
| ECF_NOTHROW
);
7155 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7158 /* Returns the __dso_handle VAR_DECL. */
7161 get_dso_handle_node (void)
7163 if (dso_handle_node
)
7164 return dso_handle_node
;
7166 /* Declare the variable. */
7167 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
7170 #ifdef HAVE_GAS_HIDDEN
7171 if (dso_handle_node
!= error_mark_node
)
7173 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
7174 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
7178 return dso_handle_node
;
7181 /* Begin a new function with internal linkage whose job will be simply
7182 to destroy some particular variable. */
7184 static GTY(()) int start_cleanup_cnt
;
7187 start_cleanup_fn (void)
7192 bool use_cxa_atexit
= flag_use_cxa_atexit
7193 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
7195 push_to_top_level ();
7197 /* No need to mangle this. */
7198 push_lang_context (lang_name_c
);
7200 /* Build the name of the function. */
7201 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
7202 /* Build the function declaration. */
7203 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
7204 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
7205 /* It's a function with internal linkage, generated by the
7207 TREE_PUBLIC (fndecl
) = 0;
7208 DECL_ARTIFICIAL (fndecl
) = 1;
7209 /* Make the function `inline' so that it is only emitted if it is
7210 actually needed. It is unlikely that it will be inlined, since
7211 it is only called via a function pointer, but we avoid unnecessary
7212 emissions this way. */
7213 DECL_DECLARED_INLINE_P (fndecl
) = 1;
7214 DECL_INTERFACE_KNOWN (fndecl
) = 1;
7215 /* Build the parameter. */
7220 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
7221 DECL_CONTEXT (parmdecl
) = fndecl
;
7222 TREE_USED (parmdecl
) = 1;
7223 DECL_READ_P (parmdecl
) = 1;
7224 DECL_ARGUMENTS (fndecl
) = parmdecl
;
7228 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
7230 pop_lang_context ();
7232 return current_function_decl
;
7235 /* Finish the cleanup function begun by start_cleanup_fn. */
7238 end_cleanup_fn (void)
7240 expand_or_defer_fn (finish_function (0));
7242 pop_from_top_level ();
7245 /* Generate code to handle the destruction of DECL, an object with
7246 static storage duration. */
7249 register_dtor_fn (tree decl
)
7256 bool ob_parm
, dso_parm
, use_dtor
;
7257 tree arg0
, arg1
, arg2
;
7260 type
= TREE_TYPE (decl
);
7261 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7264 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7265 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7266 destructor to "__cxa_atexit"; we don't have to build a temporary
7267 function to do the cleanup. */
7268 dso_parm
= (flag_use_cxa_atexit
7269 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7270 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7271 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7276 /* Find the destructor. */
7277 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
7278 gcc_assert (idx
>= 0);
7279 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
7280 /* Make sure it is accessible. */
7281 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7282 tf_warning_or_error
);
7286 /* Call build_cleanup before we enter the anonymous function so
7287 that any access checks will be done relative to the current
7288 scope, rather than the scope of the anonymous function. */
7289 build_cleanup (decl
);
7291 /* Now start the function. */
7292 cleanup
= start_cleanup_fn ();
7294 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7295 to the original function, rather than the anonymous one. That
7296 will make the back end think that nested functions are in use,
7297 which causes confusion. */
7298 push_deferring_access_checks (dk_no_check
);
7299 fcall
= build_cleanup (decl
);
7300 pop_deferring_access_checks ();
7302 /* Create the body of the anonymous function. */
7303 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7304 finish_expr_stmt (fcall
);
7305 finish_compound_stmt (compound_stmt
);
7309 /* Call atexit with the cleanup function. */
7310 mark_used (cleanup
);
7311 cleanup
= build_address (cleanup
);
7313 if (CP_DECL_THREAD_LOCAL_P (decl
))
7314 atex_node
= get_thread_atexit_node ();
7316 atex_node
= get_atexit_node ();
7320 /* We must convert CLEANUP to the type that "__cxa_atexit"
7322 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7323 /* "__cxa_atexit" will pass the address of DECL to the
7324 cleanup function. */
7326 addr
= build_address (decl
);
7327 /* The declared type of the parameter to "__cxa_atexit" is
7328 "void *". For plain "T*", we could just let the
7329 machinery in cp_build_function_call convert it -- but if the
7330 type is "cv-qualified T *", then we need to convert it
7331 before passing it in, to avoid spurious errors. */
7332 addr
= build_nop (ptr_type_node
, addr
);
7335 /* Since the cleanup functions we build ignore the address
7336 they're given, there's no reason to pass the actual address
7337 in, and, in general, it's cheaper to pass NULL than any
7339 addr
= null_pointer_node
;
7342 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7343 tf_warning_or_error
);
7345 /* Just pass NULL to the dso handle parm if we don't actually
7346 have a DSO handle on this target. */
7347 arg2
= null_pointer_node
;
7353 if (!CP_DECL_THREAD_LOCAL_P (decl
)
7354 && targetm
.cxx
.use_aeabi_atexit ())
7370 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7371 arg0
, arg1
, arg2
, NULL_TREE
);
7374 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7375 is its initializer. Generate code to handle the construction
7376 and destruction of DECL. */
7379 expand_static_init (tree decl
, tree init
)
7381 gcc_assert (VAR_P (decl
));
7382 gcc_assert (TREE_STATIC (decl
));
7384 /* Some variables require no dynamic initialization. */
7385 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7387 /* Make sure the destructor is callable. */
7388 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7393 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7394 && !DECL_FUNCTION_SCOPE_P (decl
))
7397 error ("non-local variable %qD declared %<__thread%> "
7398 "needs dynamic initialization", decl
);
7400 error ("non-local variable %qD declared %<__thread%> "
7401 "has a non-trivial destructor", decl
);
7402 static bool informed
;
7405 inform (DECL_SOURCE_LOCATION (decl
),
7406 "C++11 %<thread_local%> allows dynamic initialization "
7413 if (DECL_FUNCTION_SCOPE_P (decl
))
7415 /* Emit code to perform this initialization but once. */
7416 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7417 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7418 tree guard
, guard_addr
;
7420 /* We don't need thread-safety code for thread-local vars. */
7421 bool thread_guard
= (flag_threadsafe_statics
7422 && !CP_DECL_THREAD_LOCAL_P (decl
));
7424 /* Emit code to perform this initialization but once. This code
7427 static <type> guard;
7428 if (!__atomic_load (guard.first_byte)) {
7429 if (__cxa_guard_acquire (&guard)) {
7432 // Do initialization.
7433 flag = true; __cxa_guard_release (&guard);
7434 // Register variable for destruction at end of program.
7436 if (!flag) __cxa_guard_abort (&guard);
7440 Note that the `flag' variable is only set to 1 *after* the
7441 initialization is complete. This ensures that an exception,
7442 thrown during the construction, will cause the variable to
7443 reinitialized when we pass through this code again, as per:
7447 If the initialization exits by throwing an exception, the
7448 initialization is not complete, so it will be tried again
7449 the next time control enters the declaration.
7451 This process should be thread-safe, too; multiple threads
7452 should not be able to initialize the variable more than
7455 /* Create the guard variable. */
7456 guard
= get_guard (decl
);
7458 /* Begin the conditional initialization. */
7459 if_stmt
= begin_if_stmt ();
7461 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
7462 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7466 tree vfntype
= NULL_TREE
;
7467 tree acquire_name
, release_name
, abort_name
;
7468 tree acquire_fn
, release_fn
, abort_fn
;
7469 guard_addr
= build_address (guard
);
7471 acquire_name
= get_identifier ("__cxa_guard_acquire");
7472 release_name
= get_identifier ("__cxa_guard_release");
7473 abort_name
= get_identifier ("__cxa_guard_abort");
7474 acquire_fn
= identifier_global_value (acquire_name
);
7475 release_fn
= identifier_global_value (release_name
);
7476 abort_fn
= identifier_global_value (abort_name
);
7478 acquire_fn
= push_library_fn
7479 (acquire_name
, build_function_type_list (integer_type_node
,
7480 TREE_TYPE (guard_addr
),
7482 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7483 if (!release_fn
|| !abort_fn
)
7484 vfntype
= build_function_type_list (void_type_node
,
7485 TREE_TYPE (guard_addr
),
7488 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7489 ECF_NOTHROW
| ECF_LEAF
);
7491 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7492 ECF_NOTHROW
| ECF_LEAF
);
7494 inner_if_stmt
= begin_if_stmt ();
7495 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7498 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7499 begin
= get_target_expr (boolean_false_node
);
7500 flag
= TARGET_EXPR_SLOT (begin
);
7502 TARGET_EXPR_CLEANUP (begin
)
7503 = build3 (COND_EXPR
, void_type_node
, flag
,
7505 build_call_n (abort_fn
, 1, guard_addr
));
7506 CLEANUP_EH_ONLY (begin
) = 1;
7508 /* Do the initialization itself. */
7509 init
= add_stmt_to_compound (begin
, init
);
7510 init
= add_stmt_to_compound
7511 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7512 init
= add_stmt_to_compound
7513 (init
, build_call_n (release_fn
, 1, guard_addr
));
7516 init
= add_stmt_to_compound (init
, set_guard (guard
));
7518 /* Use atexit to register a function for destroying this static
7520 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7522 finish_expr_stmt (init
);
7526 finish_compound_stmt (inner_then_clause
);
7527 finish_then_clause (inner_if_stmt
);
7528 finish_if_stmt (inner_if_stmt
);
7531 finish_compound_stmt (then_clause
);
7532 finish_then_clause (if_stmt
);
7533 finish_if_stmt (if_stmt
);
7535 else if (CP_DECL_THREAD_LOCAL_P (decl
))
7536 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7538 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7542 /* Make TYPE a complete type based on INITIAL_VALUE.
7543 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7544 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7545 3 if the initializer list is empty (in pedantic mode). */
7548 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7551 tree type
, elt_type
;
7553 /* Don't get confused by a CONSTRUCTOR for some other type. */
7554 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
7555 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
7556 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
7561 unsigned HOST_WIDE_INT i
;
7564 /* An array of character type can be initialized from a
7565 brace-enclosed string constant.
7567 FIXME: this code is duplicated from reshape_init. Probably
7568 we should just call reshape_init here? */
7569 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7570 && TREE_CODE (initial_value
) == CONSTRUCTOR
7571 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7573 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7574 tree value
= (*v
)[0].value
;
7576 if (TREE_CODE (value
) == STRING_CST
7577 && v
->length () == 1)
7578 initial_value
= value
;
7581 /* If any of the elements are parameter packs, we can't actually
7582 complete this type now because the array size is dependent. */
7583 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7585 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7588 if (PACK_EXPANSION_P (value
))
7594 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7596 /* We can create the array before the element type is complete, which
7597 means that we didn't have these two bits set in the original type
7598 either. In completing the type, we are expected to propagate these
7599 bits. See also complete_type which does the same thing for arrays
7602 if (TYPE_DOMAIN (type
))
7604 elt_type
= TREE_TYPE (type
);
7605 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7606 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7607 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7613 /* As above, but either give an error or reject zero-size arrays, depending
7617 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7618 bool do_default
, tsubst_flags_t complain
)
7621 bool sfinae
= !(complain
& tf_error
);
7622 /* In SFINAE context we can't be lenient about zero-size arrays. */
7625 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7631 /* Not an error. */;
7632 else if (failure
== 1)
7633 error ("initializer fails to determine size of %qT", *ptype
);
7634 else if (failure
== 2)
7637 error ("array size missing in %qT", *ptype
);
7639 else if (failure
== 3)
7640 error ("zero-size array %qT", *ptype
);
7641 *ptype
= error_mark_node
;
7646 /* Return zero if something is declared to be a member of type
7647 CTYPE when in the context of CUR_TYPE. STRING is the error
7648 message to print in that case. Otherwise, quietly return 1. */
7651 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7653 if (ctype
&& ctype
!= cur_type
)
7655 if (flags
== DTOR_FLAG
)
7656 error ("destructor for alien class %qT cannot be a member", ctype
);
7658 error ("constructor for alien class %qT cannot be a member", ctype
);
7664 /* Subroutine of `grokdeclarator'. */
7666 /* Generate errors possibly applicable for a given set of specifiers.
7667 This is for ARM $7.1.2. */
7670 bad_specifiers (tree object
,
7671 enum bad_spec_place type
,
7682 error ("%qD declared as a %<virtual%> variable", object
);
7684 error ("%qD declared as an %<inline%> variable", object
);
7686 error ("%<const%> and %<volatile%> function specifiers on "
7687 "%qD invalid in variable declaration", object
);
7691 error ("%qD declared as a %<virtual%> parameter", object
);
7693 error ("%qD declared as an %<inline%> parameter", object
);
7695 error ("%<const%> and %<volatile%> function specifiers on "
7696 "%qD invalid in parameter declaration", object
);
7700 error ("%qD declared as a %<virtual%> type", object
);
7702 error ("%qD declared as an %<inline%> type", object
);
7704 error ("%<const%> and %<volatile%> function specifiers on "
7705 "%qD invalid in type declaration", object
);
7709 error ("%qD declared as a %<virtual%> field", object
);
7711 error ("%qD declared as an %<inline%> field", object
);
7713 error ("%<const%> and %<volatile%> function specifiers on "
7714 "%qD invalid in field declaration", object
);
7720 error ("%q+D declared as a friend", object
);
7722 && (TREE_CODE (object
) == TYPE_DECL
7723 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7724 && !TYPE_REFFN_P (TREE_TYPE (object
))
7725 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7726 error ("%q+D declared with an exception specification", object
);
7729 /* DECL is a member function or static data member and is presently
7730 being defined. Check that the definition is taking place in a
7734 check_class_member_definition_namespace (tree decl
)
7736 /* These checks only apply to member functions and static data
7738 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7739 /* We check for problems with specializations in pt.c in
7740 check_specialization_namespace, where we can issue better
7742 if (processing_specialization
)
7744 /* There are no restrictions on the placement of
7745 explicit instantiations. */
7746 if (processing_explicit_instantiation
)
7750 A member function definition that appears outside of the
7751 class definition shall appear in a namespace scope enclosing
7752 the class definition.
7756 The definition for a static data member shall appear in a
7757 namespace scope enclosing the member's class definition. */
7758 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7759 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7760 decl
, DECL_CONTEXT (decl
));
7763 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7764 METHOD_TYPE for a non-static member function; QUALS are the
7765 cv-qualifiers that apply to the function. */
7768 build_this_parm (tree type
, cp_cv_quals quals
)
7773 cp_cv_quals this_quals
;
7775 if (CLASS_TYPE_P (type
))
7778 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7779 this_type
= build_pointer_type (this_type
);
7782 this_type
= type_of_this_parm (type
);
7783 /* The `this' parameter is implicitly `const'; it cannot be
7785 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7786 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7787 parm
= build_artificial_parm (this_identifier
, qual_type
);
7788 cp_apply_type_quals_to_decl (this_quals
, parm
);
7792 /* DECL is a static member function. Complain if it was declared
7793 with function-cv-quals. */
7796 check_static_quals (tree decl
, cp_cv_quals quals
)
7798 if (quals
!= TYPE_UNQUALIFIED
)
7799 error ("static member function %q#D declared with type qualifiers",
7803 // Check that FN takes no arguments and returns bool.
7805 check_concept_fn (tree fn
)
7807 // A constraint is nullary.
7808 if (DECL_ARGUMENTS (fn
))
7809 error ("concept %q#D declared with function parameters", fn
);
7811 // The declared return type of the concept shall be bool, and
7812 // it shall not be deduced from it definition.
7813 tree type
= TREE_TYPE (TREE_TYPE (fn
));
7815 error ("concept %q#D declared with a deduced return type", fn
);
7816 else if (type
!= boolean_type_node
)
7817 error ("concept %q#D with non-%<bool%> return type %qT", fn
, type
);
7820 /* Helper function. Replace the temporary this parameter injected
7821 during cp_finish_omp_declare_simd with the real this parameter. */
7824 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7826 tree this_parm
= (tree
) data
;
7827 if (TREE_CODE (*tp
) == PARM_DECL
7828 && DECL_NAME (*tp
) == this_identifier
7829 && *tp
!= this_parm
)
7831 else if (TYPE_P (*tp
))
7836 /* CTYPE is class type, or null if non-class.
7837 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7839 DECLARATOR is the function's name.
7840 PARMS is a chain of PARM_DECLs for the function.
7841 VIRTUALP is truthvalue of whether the function is virtual or not.
7842 FLAGS are to be passed through to `grokclassfn'.
7843 QUALS are qualifiers indicating whether the function is `const'
7845 RAISES is a list of exceptions that this function can raise.
7846 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7847 not look, and -1 if we should not call `grokclassfn' at all.
7849 SFK is the kind of special function (if any) for the new function.
7851 Returns `NULL_TREE' if something goes wrong, after issuing
7852 applicable error messages. */
7855 grokfndecl (tree ctype
,
7859 tree orig_declarator
,
7862 enum overload_flags flags
,
7864 cp_ref_qualifier rqual
,
7871 special_function_kind sfk
,
7876 location_t location
)
7879 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7882 // Was the concept specifier present?
7883 bool concept_p
= inlinep
& 4;
7885 // Concept declarations must have a corresponding definition.
7886 if (concept_p
&& !funcdef_flag
)
7888 error ("concept %qD has no definition", declarator
);
7893 type
= build_ref_qualified_type (type
, rqual
);
7895 type
= build_exception_variant (type
, raises
);
7897 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7899 /* Set the constraints on the declaration. */
7902 tree tmpl_reqs
= NULL_TREE
;
7903 if (processing_template_decl
> template_class_depth (ctype
))
7904 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
7906 /* Adjust the required expression into a constraint. */
7908 decl_reqs
= make_predicate_constraint (decl_reqs
);
7910 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
7911 set_constraints (decl
, ci
);
7914 /* If we have an explicit location, use it, otherwise use whatever
7915 build_lang_decl used (probably input_location). */
7916 if (location
!= UNKNOWN_LOCATION
)
7917 DECL_SOURCE_LOCATION (decl
) = location
;
7919 if (TREE_CODE (type
) == METHOD_TYPE
)
7922 parm
= build_this_parm (type
, quals
);
7923 DECL_CHAIN (parm
) = parms
;
7926 /* Allocate space to hold the vptr bit if needed. */
7927 SET_DECL_ALIGN (decl
, MINIMUM_METHOD_BOUNDARY
);
7929 DECL_ARGUMENTS (decl
) = parms
;
7930 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7931 DECL_CONTEXT (t
) = decl
;
7932 /* Propagate volatile out from type to decl. */
7933 if (TYPE_VOLATILE (type
))
7934 TREE_THIS_VOLATILE (decl
) = 1;
7936 /* Setup decl according to sfk. */
7939 case sfk_constructor
:
7940 case sfk_copy_constructor
:
7941 case sfk_move_constructor
:
7942 DECL_CONSTRUCTOR_P (decl
) = 1;
7944 case sfk_destructor
:
7945 DECL_DESTRUCTOR_P (decl
) = 1;
7952 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7956 ("defining explicit specialization %qD in friend declaration",
7960 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7961 tree args
= TREE_OPERAND (orig_declarator
, 1);
7963 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7965 /* Something like `template <class T> friend void f<T>()'. */
7966 error ("invalid use of template-id %qD in declaration "
7967 "of primary template",
7973 /* A friend declaration of the form friend void f<>(). Record
7974 the information in the TEMPLATE_ID_EXPR. */
7975 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7977 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7978 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7980 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7981 if (TREE_PURPOSE (t
)
7982 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7984 error ("default arguments are not allowed in declaration "
7985 "of friend template specialization %qD",
7992 error ("%<inline%> is not allowed in declaration of friend "
7993 "template specialization %qD",
8000 /* If this decl has namespace scope, set that up. */
8002 set_decl_namespace (decl
, in_namespace
, friendp
);
8004 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8006 /* `main' and builtins have implicit 'C' linkage. */
8007 if ((MAIN_NAME_P (declarator
)
8008 || (IDENTIFIER_LENGTH (declarator
) > 10
8009 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8010 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8011 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
8012 || (targetcm
.cxx_implicit_extern_c
8013 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
8014 && current_lang_name
== lang_name_cplusplus
8015 && ctype
== NULL_TREE
8016 && DECL_FILE_SCOPE_P (decl
))
8017 SET_DECL_LANGUAGE (decl
, lang_c
);
8019 /* Should probably propagate const out from type to decl I bet (mrs). */
8022 DECL_STATIC_FUNCTION_P (decl
) = 1;
8023 DECL_CONTEXT (decl
) = ctype
;
8027 DECL_DELETED_FN (decl
) = 1;
8031 DECL_CONTEXT (decl
) = ctype
;
8033 check_class_member_definition_namespace (decl
);
8036 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8038 if (PROCESSING_REAL_TEMPLATE_DECL_P())
8039 error ("cannot declare %<::main%> to be a template");
8041 error ("cannot declare %<::main%> to be inline");
8043 error ("cannot declare %<::main%> to be constexpr");
8045 error ("cannot declare %<::main%> to be static");
8050 /* Members of anonymous types and local classes have no linkage; make
8051 them internal. If a typedef is made later, this will be changed. */
8052 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
8053 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8056 if (publicp
&& cxx_dialect
== cxx98
)
8058 /* [basic.link]: A name with no linkage (notably, the name of a class
8059 or enumeration declared in a local scope) shall not be used to
8060 declare an entity with linkage.
8062 DR 757 relaxes this restriction for C++0x. */
8063 no_linkage_error (decl
);
8066 TREE_PUBLIC (decl
) = publicp
;
8069 DECL_INTERFACE_KNOWN (decl
) = 1;
8070 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8073 /* If the declaration was declared inline, mark it as such. */
8076 DECL_DECLARED_INLINE_P (decl
) = 1;
8078 DECL_COMDAT (decl
) = 1;
8081 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
8083 // If the concept declaration specifier was found, check
8084 // that the declaration satisfies the necessary requirements.
8087 DECL_DECLARED_CONCEPT_P (decl
) = true;
8088 check_concept_fn (decl
);
8091 DECL_EXTERNAL (decl
) = 1;
8092 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8095 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
8102 ? G_("static member function %qD cannot have cv-qualifier")
8103 : G_("non-member function %qD cannot have cv-qualifier"),
8105 quals
= TYPE_UNQUALIFIED
;
8111 ? G_("static member function %qD cannot have ref-qualifier")
8112 : G_("non-member function %qD cannot have ref-qualifier"),
8114 rqual
= REF_QUAL_NONE
;
8118 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
8119 && !grok_op_properties (decl
, /*complain=*/true))
8121 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
8123 bool long_long_unsigned_p
;
8125 const char *suffix
= NULL
;
8126 /* [over.literal]/6: Literal operators shall not have C linkage. */
8127 if (DECL_LANGUAGE (decl
) == lang_c
)
8129 error ("literal operator with C linkage");
8133 if (DECL_NAMESPACE_SCOPE_P (decl
))
8135 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
8138 error ("%qD has invalid argument list", decl
);
8142 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
8143 if (long_long_unsigned_p
)
8145 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
8146 warning (0, "integer suffix %<%s%>"
8147 " shadowed by implementation", suffix
);
8149 else if (long_double_p
)
8151 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
8152 warning (0, "floating point suffix %<%s%>"
8153 " shadowed by implementation", suffix
);
8158 error ("%qD must be a non-member function", decl
);
8164 /* Make the init_value nonzero so pushdecl knows this is not
8165 tentative. error_mark_node is replaced later with the BLOCK. */
8166 DECL_INITIAL (decl
) = error_mark_node
;
8168 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8169 TREE_NOTHROW (decl
) = 1;
8171 if (flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
8173 /* Adjust "omp declare simd" attributes. */
8174 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
8178 for (attr
= ods
; attr
;
8179 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
8181 if (TREE_CODE (type
) == METHOD_TYPE
)
8182 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
8183 DECL_ARGUMENTS (decl
), NULL
);
8184 if (TREE_VALUE (attr
) != NULL_TREE
)
8186 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
8187 cl
= c_omp_declare_simd_clauses_to_numbers
8188 (DECL_ARGUMENTS (decl
), cl
);
8190 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
8192 TREE_VALUE (attr
) = NULL_TREE
;
8198 /* Caller will do the rest of this. */
8202 if (ctype
!= NULL_TREE
)
8203 grokclassfn (ctype
, decl
, flags
);
8206 if (cxx_dialect
>= cxx11
8207 && DECL_DESTRUCTOR_P (decl
)
8208 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
8209 && !processing_template_decl
)
8210 deduce_noexcept_on_destructor (decl
);
8212 decl
= check_explicit_specialization (orig_declarator
, decl
,
8215 4 * (friendp
!= 0) +
8217 if (decl
== error_mark_node
)
8220 if (DECL_STATIC_FUNCTION_P (decl
))
8221 check_static_quals (decl
, quals
);
8225 cplus_decl_attributes (&decl
, *attrlist
, 0);
8226 *attrlist
= NULL_TREE
;
8229 /* Check main's type after attributes have been applied. */
8230 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8232 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8235 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8237 error ("%<::main%> must return %<int%>");
8238 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
8239 TREE_TYPE (decl
) = newtype
;
8242 check_main_parameter_types (decl
);
8245 if (ctype
!= NULL_TREE
8246 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8249 tree old_decl
= check_classfn (ctype
, decl
,
8250 (processing_template_decl
8251 > template_class_depth (ctype
))
8252 ? current_template_parms
8255 if (old_decl
== error_mark_node
)
8263 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8264 /* Because grokfndecl is always supposed to return a
8265 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8266 here. We depend on our callers to figure out that its
8267 really a template that's being returned. */
8268 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8270 if (DECL_STATIC_FUNCTION_P (old_decl
)
8271 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8273 /* Remove the `this' parm added by grokclassfn. */
8274 revert_static_member_fn (decl
);
8275 check_static_quals (decl
, quals
);
8277 if (DECL_ARTIFICIAL (old_decl
))
8279 error ("definition of implicitly-declared %qD", old_decl
);
8282 else if (DECL_DEFAULTED_FN (old_decl
))
8284 error ("definition of explicitly-defaulted %q+D", decl
);
8285 error ("%q+#D explicitly defaulted here", old_decl
);
8289 /* Since we've smashed OLD_DECL to its
8290 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8291 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8292 decl
= DECL_TEMPLATE_RESULT (decl
);
8294 /* Attempt to merge the declarations. This can fail, in
8295 the case of some invalid specialization declarations. */
8296 pushed_scope
= push_scope (ctype
);
8297 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8299 pop_scope (pushed_scope
);
8302 error ("no %q#D member function declared in class %qT",
8306 if (ok
== error_mark_node
)
8312 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8315 if (ctype
== NULL_TREE
|| check
)
8319 DECL_VIRTUAL_P (decl
) = 1;
8324 /* decl is a FUNCTION_DECL.
8325 specifiers are the parsed virt-specifiers.
8327 Set flags to reflect the virt-specifiers.
8332 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8334 if (decl
== NULL_TREE
)
8336 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8337 DECL_OVERRIDE_P (decl
) = 1;
8338 if (specifiers
& VIRT_SPEC_FINAL
)
8339 DECL_FINAL_P (decl
) = 1;
8343 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8344 the linkage that DECL will receive in the object file. */
8347 set_linkage_for_static_data_member (tree decl
)
8349 /* A static data member always has static storage duration and
8350 external linkage. Note that static data members are forbidden in
8351 local classes -- the only situation in which a class has
8352 non-external linkage. */
8353 TREE_PUBLIC (decl
) = 1;
8354 TREE_STATIC (decl
) = 1;
8355 /* For non-template classes, static data members are always put
8356 out in exactly those files where they are defined, just as
8357 with ordinary namespace-scope variables. */
8358 if (!processing_template_decl
)
8359 DECL_INTERFACE_KNOWN (decl
) = 1;
8362 /* Create a VAR_DECL named NAME with the indicated TYPE.
8364 If SCOPE is non-NULL, it is the class type or namespace containing
8365 the variable. If SCOPE is NULL, the variable should is created in
8366 the innermost enclosing scope. */
8369 grokvardecl (tree type
,
8371 tree orig_declarator
,
8372 const cp_decl_specifier_seq
*declspecs
,
8379 tree explicit_scope
;
8381 gcc_assert (!name
|| identifier_p (name
));
8383 bool constp
= flags
&1;
8384 bool conceptp
= flags
&2;
8386 /* Compute the scope in which to place the variable, but remember
8387 whether or not that scope was explicitly specified by the user. */
8388 explicit_scope
= scope
;
8391 /* An explicit "extern" specifier indicates a namespace-scope
8393 if (declspecs
->storage_class
== sc_extern
)
8394 scope
= current_decl_namespace ();
8395 else if (!at_function_scope_p ())
8396 scope
= current_scope ();
8400 && (/* If the variable is a namespace-scope variable declared in a
8401 template, we need DECL_LANG_SPECIFIC. */
8402 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8403 /* Similarly for namespace-scope variables with language linkage
8405 || (TREE_CODE (scope
) == NAMESPACE_DECL
8406 && current_lang_name
!= lang_name_cplusplus
)
8407 /* Similarly for static data members. */
8409 /* Similarly for explicit specializations. */
8411 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8412 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8414 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8416 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8417 set_decl_namespace (decl
, explicit_scope
, 0);
8419 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
8421 if (declspecs
->storage_class
== sc_extern
)
8423 DECL_THIS_EXTERN (decl
) = 1;
8424 DECL_EXTERNAL (decl
) = !initialized
;
8427 if (DECL_CLASS_SCOPE_P (decl
))
8429 set_linkage_for_static_data_member (decl
);
8430 /* This function is only called with out-of-class definitions. */
8431 DECL_EXTERNAL (decl
) = 0;
8432 check_class_member_definition_namespace (decl
);
8434 /* At top level, either `static' or no s.c. makes a definition
8435 (perhaps tentative), and absence of `static' makes it public. */
8436 else if (toplevel_bindings_p ())
8438 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
8439 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8440 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8442 /* Not at top level, only `static' makes a static definition. */
8445 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
8446 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8449 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
8451 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
8453 CP_DECL_THREAD_LOCAL_P (decl
) = true;
8454 if (!processing_template_decl
)
8455 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
8457 if (declspecs
->gnu_thread_keyword_p
)
8458 SET_DECL_GNU_TLS_P (decl
);
8461 /* If the type of the decl has no linkage, make sure that we'll
8462 notice that in mark_used. */
8463 if (cxx_dialect
> cxx98
8464 && decl_linkage (decl
) != lk_none
8465 && DECL_LANG_SPECIFIC (decl
) == NULL
8466 && !DECL_EXTERN_C_P (decl
)
8467 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
8468 retrofit_lang_decl (decl
);
8470 if (TREE_PUBLIC (decl
))
8472 /* [basic.link]: A name with no linkage (notably, the name of a class
8473 or enumeration declared in a local scope) shall not be used to
8474 declare an entity with linkage.
8476 DR 757 relaxes this restriction for C++0x. */
8477 if (cxx_dialect
< cxx11
)
8478 no_linkage_error (decl
);
8481 DECL_INTERFACE_KNOWN (decl
) = 1;
8483 if (DECL_NAME (decl
)
8484 && MAIN_NAME_P (DECL_NAME (decl
))
8485 && scope
== global_namespace
)
8486 error ("cannot declare %<::main%> to be a global variable");
8488 /* Check that the variable can be safely declared as a concept.
8489 Note that this also forbids explicit specializations. */
8492 if (!processing_template_decl
)
8494 error ("a non-template variable cannot be %<concept%>");
8498 DECL_DECLARED_CONCEPT_P (decl
) = true;
8499 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
8500 error_at (declspecs
->locations
[ds_type_spec
],
8501 "concept must have type %<bool%>");
8503 else if (flag_concepts
8504 && processing_template_decl
> template_class_depth (scope
))
8506 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8507 tree ci
= build_constraints (reqs
, NULL_TREE
);
8508 set_constraints (decl
, ci
);
8511 // Handle explicit specializations and instantiations of variable templates.
8512 if (orig_declarator
)
8513 decl
= check_explicit_specialization (orig_declarator
, decl
,
8514 template_count
, conceptp
* 8);
8516 return decl
!= error_mark_node
? decl
: NULL_TREE
;
8519 /* Create and return a canonical pointer to member function type, for
8520 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8523 build_ptrmemfunc_type (tree type
)
8528 if (type
== error_mark_node
)
8531 /* Make sure that we always have the unqualified pointer-to-member
8533 if (cp_cv_quals quals
= cp_type_quals (type
))
8535 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8536 return cp_build_qualified_type (unqual
, quals
);
8539 /* If a canonical type already exists for this type, use it. We use
8540 this method instead of type_hash_canon, because it only does a
8541 simple equality check on the list of field members. */
8543 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8546 t
= make_node (RECORD_TYPE
);
8548 /* Let the front end know this is a pointer to member function. */
8549 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8551 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8554 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8556 DECL_CHAIN (field
) = fields
;
8559 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8561 /* Zap out the name so that the back end will give us the debugging
8562 information for this anonymous RECORD_TYPE. */
8563 TYPE_NAME (t
) = NULL_TREE
;
8565 /* Cache this pointer-to-member type so that we can find it again
8567 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8569 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8570 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8571 else if (TYPE_CANONICAL (type
) != type
)
8572 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8577 /* Create and return a pointer to data member type. */
8580 build_ptrmem_type (tree class_type
, tree member_type
)
8582 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8584 cp_cv_quals quals
= type_memfn_quals (member_type
);
8585 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8586 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8587 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8591 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8592 return build_offset_type (class_type
, member_type
);
8596 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8597 Check to see that the definition is valid. Issue appropriate error
8598 messages. Return 1 if the definition is particularly bad, or 0
8602 check_static_variable_definition (tree decl
, tree type
)
8604 /* Can't check yet if we don't know the type. */
8605 if (dependent_type_p (type
))
8607 /* If DECL is declared constexpr, we'll do the appropriate checks
8608 in check_initializer. */
8609 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8611 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8613 if (!COMPLETE_TYPE_P (type
))
8614 error ("in-class initialization of static data member %q#D of "
8615 "incomplete type", decl
);
8616 else if (literal_type_p (type
))
8617 permerror (input_location
,
8618 "%<constexpr%> needed for in-class initialization of "
8619 "static data member %q#D of non-integral type", decl
);
8621 error ("in-class initialization of static data member %q#D of "
8622 "non-literal type", decl
);
8626 /* Motion 10 at San Diego: If a static const integral data member is
8627 initialized with an integral constant expression, the initializer
8628 may appear either in the declaration (within the class), or in
8629 the definition, but not both. If it appears in the class, the
8630 member is a member constant. The file-scope definition is always
8632 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8634 error ("invalid in-class initialization of static data member "
8635 "of non-integral type %qT",
8639 else if (!CP_TYPE_CONST_P (type
))
8640 error ("ISO C++ forbids in-class initialization of non-const "
8641 "static member %qD",
8643 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8644 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8645 "%qD of non-integral type %qT", decl
, type
);
8650 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8651 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8652 expressions out into temporary variables so that walk_tree doesn't
8653 step into them (c++/15764). */
8656 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8658 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
8659 tree expr
= *expr_p
;
8660 if (TREE_CODE (expr
) == SAVE_EXPR
)
8662 tree op
= TREE_OPERAND (expr
, 0);
8663 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8664 if (TREE_SIDE_EFFECTS (op
))
8665 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8668 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8673 /* Entry point for the above. */
8676 stabilize_vla_size (tree size
)
8678 hash_set
<tree
> pset
;
8679 /* Break out any function calls into temporary variables. */
8680 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
8683 /* Reduce a SIZEOF_EXPR to its value. */
8686 fold_sizeof_expr (tree t
)
8689 if (SIZEOF_EXPR_TYPE_P (t
))
8690 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
8691 SIZEOF_EXPR
, false);
8692 else if (TYPE_P (TREE_OPERAND (t
, 0)))
8693 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8696 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8698 if (r
== error_mark_node
)
8703 /* Given the SIZE (i.e., number of elements) in an array, compute
8704 an appropriate index type for the array. If non-NULL, NAME is
8705 the name of the entity being declared. */
8708 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8713 if (error_operand_p (size
))
8714 return error_mark_node
;
8716 if (!type_dependent_expression_p (size
))
8718 tree type
= TREE_TYPE (size
);
8720 mark_rvalue_use (size
);
8722 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8723 && TREE_SIDE_EFFECTS (size
))
8724 /* In C++98, we mark a non-constant array bound with a magic
8725 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8728 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
8730 if (CLASS_TYPE_P (type
)
8731 && CLASSTYPE_LITERAL_P (type
))
8733 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8736 if (!(complain
& tf_error
))
8737 return error_mark_node
;
8739 error ("size of array %qD has non-integral type %qT",
8742 error ("size of array has non-integral type %qT", type
);
8743 size
= integer_one_node
;
8745 if (size
== error_mark_node
)
8746 return error_mark_node
;
8747 type
= TREE_TYPE (size
);
8750 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8751 size
= maybe_constant_value (size
);
8753 if (!TREE_CONSTANT (size
))
8757 if (error_operand_p (size
))
8758 return error_mark_node
;
8760 /* The array bound must be an integer type. */
8761 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8763 if (!(complain
& tf_error
))
8764 return error_mark_node
;
8766 error ("size of array %qD has non-integral type %qT", name
, type
);
8768 error ("size of array has non-integral type %qT", type
);
8769 size
= integer_one_node
;
8770 type
= TREE_TYPE (size
);
8774 /* A type is dependent if it is...an array type constructed from any
8775 dependent type or whose size is specified by a constant expression
8776 that is value-dependent. */
8777 /* We can only call value_dependent_expression_p on integral constant
8778 expressions; treat non-constant expressions as dependent, too. */
8779 if (processing_template_decl
8780 && (type_dependent_expression_p (size
)
8781 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8783 /* We cannot do any checking for a SIZE that isn't known to be
8784 constant. Just build the index type and mark that it requires
8785 structural equality checks. */
8786 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8787 size
, size_one_node
));
8788 TYPE_DEPENDENT_P (itype
) = 1;
8789 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8790 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8794 if (TREE_CODE (size
) != INTEGER_CST
)
8796 tree folded
= cp_fully_fold (size
);
8797 if (TREE_CODE (folded
) == INTEGER_CST
)
8798 pedwarn (location_of (size
), OPT_Wpedantic
,
8799 "size of array is not an integral constant-expression");
8800 /* Use the folded result for VLAs, too; it will have resolved
8805 /* Normally, the array-bound will be a constant. */
8806 if (TREE_CODE (size
) == INTEGER_CST
)
8808 /* Check to see if the array bound overflowed. Make that an
8809 error, no matter how generous we're being. */
8810 constant_expression_error (size
);
8812 /* An array must have a positive number of elements. */
8813 if (tree_int_cst_lt (size
, integer_zero_node
))
8815 if (!(complain
& tf_error
))
8816 return error_mark_node
;
8818 error ("size of array %qD is negative", name
);
8820 error ("size of array is negative");
8821 size
= integer_one_node
;
8823 /* As an extension we allow zero-sized arrays. */
8824 else if (integer_zerop (size
))
8826 if (!(complain
& tf_error
))
8827 /* We must fail if performing argument deduction (as
8828 indicated by the state of complain), so that
8829 another substitution can be found. */
8830 return error_mark_node
;
8831 else if (in_system_header_at (input_location
))
8832 /* Allow them in system headers because glibc uses them. */;
8834 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8836 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8839 else if (TREE_CONSTANT (size
)
8840 /* We don't allow VLAs at non-function scopes, or during
8841 tentative template substitution. */
8842 || !at_function_scope_p ()
8843 || !(complain
& tf_error
))
8845 if (!(complain
& tf_error
))
8846 return error_mark_node
;
8847 /* `(int) &fn' is not a valid array bound. */
8849 error ("size of array %qD is not an integral constant-expression",
8852 error ("size of array is not an integral constant-expression");
8853 size
= integer_one_node
;
8855 else if (pedantic
&& warn_vla
!= 0)
8858 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8860 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8862 else if (warn_vla
> 0)
8866 "variable length array %qD is used", name
);
8869 "variable length array is used");
8872 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8873 /* A variable sized array. */
8874 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8877 HOST_WIDE_INT saved_processing_template_decl
;
8879 /* Compute the index of the largest element in the array. It is
8880 one less than the number of elements in the array. We save
8881 and restore PROCESSING_TEMPLATE_DECL so that computations in
8882 cp_build_binary_op will be appropriately folded. */
8883 saved_processing_template_decl
= processing_template_decl
;
8884 processing_template_decl
= 0;
8885 itype
= cp_build_binary_op (input_location
,
8887 cp_convert (ssizetype
, size
, complain
),
8888 cp_convert (ssizetype
, integer_one_node
,
8891 itype
= maybe_constant_value (itype
);
8892 processing_template_decl
= saved_processing_template_decl
;
8894 if (!TREE_CONSTANT (itype
))
8896 /* A variable sized array. */
8897 itype
= variable_size (itype
);
8899 stabilize_vla_size (itype
);
8901 if (flag_sanitize
& SANITIZE_VLA
8902 && do_ubsan_in_current_function ())
8904 /* We have to add 1 -- in the ubsan routine we generate
8905 LE_EXPR rather than LT_EXPR. */
8906 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8907 build_one_cst (TREE_TYPE (itype
)));
8908 t
= ubsan_instrument_vla (input_location
, t
);
8909 finish_expr_stmt (t
);
8912 /* Make sure that there was no overflow when creating to a signed
8913 index type. (For example, on a 32-bit machine, an array with
8914 size 2^32 - 1 is too big.) */
8915 else if (TREE_CODE (itype
) == INTEGER_CST
8916 && TREE_OVERFLOW (itype
))
8918 if (!(complain
& tf_error
))
8919 return error_mark_node
;
8920 error ("overflow in array dimension");
8921 TREE_OVERFLOW (itype
) = 0;
8925 /* Create and return the appropriate index type. */
8926 itype
= build_index_type (itype
);
8928 /* If the index type were dependent, we would have returned early, so
8929 remember that it isn't. */
8930 TYPE_DEPENDENT_P (itype
) = 0;
8931 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8935 /* Returns the scope (if any) in which the entity declared by
8936 DECLARATOR will be located. If the entity was declared with an
8937 unqualified name, NULL_TREE is returned. */
8940 get_scope_of_declarator (const cp_declarator
*declarator
)
8942 while (declarator
&& declarator
->kind
!= cdk_id
)
8943 declarator
= declarator
->declarator
;
8945 /* If the declarator-id is a SCOPE_REF, the scope in which the
8946 declaration occurs is the first operand. */
8948 && declarator
->u
.id
.qualifying_scope
)
8949 return declarator
->u
.id
.qualifying_scope
;
8951 /* Otherwise, the declarator is not a qualified name; the entity will
8952 be declared in the current scope. */
8956 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8957 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8961 create_array_type_for_decl (tree name
, tree type
, tree size
)
8963 tree itype
= NULL_TREE
;
8965 /* If things have already gone awry, bail now. */
8966 if (type
== error_mark_node
|| size
== error_mark_node
)
8967 return error_mark_node
;
8969 /* 8.3.4/1: If the type of the identifier of D contains the auto
8970 type-specifier, the program is ill-formed. */
8971 if (type_uses_auto (type
))
8973 error ("%qD declared as array of %qT", name
, type
);
8974 return error_mark_node
;
8977 /* If there are some types which cannot be array elements,
8978 issue an error-message and return. */
8979 switch (TREE_CODE (type
))
8983 error ("declaration of %qD as array of void", name
);
8985 error ("creating array of void");
8986 return error_mark_node
;
8990 error ("declaration of %qD as array of functions", name
);
8992 error ("creating array of functions");
8993 return error_mark_node
;
8995 case REFERENCE_TYPE
:
8997 error ("declaration of %qD as array of references", name
);
8999 error ("creating array of references");
9000 return error_mark_node
;
9004 error ("declaration of %qD as array of function members", name
);
9006 error ("creating array of function members");
9007 return error_mark_node
;
9015 The constant expressions that specify the bounds of the arrays
9016 can be omitted only for the first member of the sequence. */
9017 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9020 error ("declaration of %qD as multidimensional array must "
9021 "have bounds for all dimensions except the first",
9024 error ("multidimensional array must have bounds for all "
9025 "dimensions except the first");
9027 return error_mark_node
;
9030 /* Figure out the index type for the array. */
9032 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
9035 T is called the array element type; this type shall not be [...] an
9036 abstract class type. */
9037 abstract_virtuals_error (name
, type
);
9039 return build_cplus_array_type (type
, itype
);
9042 /* Returns the smallest location != UNKNOWN_LOCATION among the
9043 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
9044 and LOCATIONS[ds_restrict]. */
9047 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
9049 location_t loc
= UNKNOWN_LOCATION
;
9051 if (type_quals
& TYPE_QUAL_CONST
)
9052 loc
= locations
[ds_const
];
9054 if ((type_quals
& TYPE_QUAL_VOLATILE
)
9055 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_volatile
] < loc
))
9056 loc
= locations
[ds_volatile
];
9058 if ((type_quals
& TYPE_QUAL_RESTRICT
)
9059 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_restrict
] < loc
))
9060 loc
= locations
[ds_restrict
];
9065 /* Check that it's OK to declare a function with the indicated TYPE
9066 and TYPE_QUALS. SFK indicates the kind of special function (if any)
9067 that this function is. OPTYPE is the type given in a conversion
9068 operator declaration, or the class type for a constructor/destructor.
9069 Returns the actual return type of the function; that may be different
9070 than TYPE if an error occurs, or for certain special functions. */
9073 check_special_function_return_type (special_function_kind sfk
,
9077 const location_t
* locations
)
9081 case sfk_constructor
:
9083 error ("return type specification for constructor invalid");
9084 else if (type_quals
!= TYPE_UNQUALIFIED
)
9085 error_at (smallest_type_quals_location (type_quals
, locations
),
9086 "qualifiers are not allowed on constructor declaration");
9088 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9089 type
= build_pointer_type (optype
);
9091 type
= void_type_node
;
9094 case sfk_destructor
:
9096 error ("return type specification for destructor invalid");
9097 else if (type_quals
!= TYPE_UNQUALIFIED
)
9098 error_at (smallest_type_quals_location (type_quals
, locations
),
9099 "qualifiers are not allowed on destructor declaration");
9101 /* We can't use the proper return type here because we run into
9102 problems with ambiguous bases and covariant returns.
9103 Java classes are left unchanged because (void *) isn't a valid
9104 Java type, and we don't want to change the Java ABI. */
9105 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9106 type
= build_pointer_type (void_type_node
);
9108 type
= void_type_node
;
9111 case sfk_conversion
:
9113 error ("return type specified for %<operator %T%>", optype
);
9114 else if (type_quals
!= TYPE_UNQUALIFIED
)
9115 error_at (smallest_type_quals_location (type_quals
, locations
),
9116 "qualifiers are not allowed on declaration of "
9117 "%<operator %T%>", optype
);
9129 /* A variable or data member (whose unqualified name is IDENTIFIER)
9130 has been declared with the indicated TYPE. If the TYPE is not
9131 acceptable, issue an error message and return a type to use for
9132 error-recovery purposes. */
9135 check_var_type (tree identifier
, tree type
)
9137 if (VOID_TYPE_P (type
))
9140 error ("unnamed variable or field declared void");
9141 else if (identifier_p (identifier
))
9143 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
9144 error ("variable or field %qE declared void", identifier
);
9147 error ("variable or field declared void");
9148 type
= error_mark_node
;
9154 /* Given declspecs and a declarator (abstract or otherwise), determine
9155 the name and type of the object declared and construct a DECL node
9158 DECLSPECS points to the representation of declaration-specifier
9159 sequence that precedes declarator.
9161 DECL_CONTEXT says which syntactic context this declaration is in:
9162 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9163 FUNCDEF for a function definition. Like NORMAL but a few different
9164 error messages in each case. Return value may be zero meaning
9165 this definition is too screwy to try to parse.
9166 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9167 handle member functions (which have FIELD context).
9168 Return value may be zero meaning this definition is too screwy to
9170 PARM for a parameter declaration (either within a function prototype
9171 or before a function body). Make a PARM_DECL, or return void_type_node.
9172 TPARM for a template parameter declaration.
9173 CATCHPARM for a parameter declaration before a catch clause.
9174 TYPENAME if for a typename (in a cast or sizeof).
9175 Don't make a DECL node; just return the ..._TYPE node.
9176 FIELD for a struct or union field; make a FIELD_DECL.
9177 BITFIELD for a field with specified width.
9179 INITIALIZED is as for start_decl.
9181 ATTRLIST is a pointer to the list of attributes, which may be NULL
9182 if there are none; *ATTRLIST may be modified if attributes from inside
9183 the declarator should be applied to the declaration.
9185 When this function is called, scoping variables (such as
9186 CURRENT_CLASS_TYPE) should reflect the scope in which the
9187 declaration occurs, not the scope in which the new declaration will
9188 be placed. For example, on:
9192 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9195 Returns a DECL (if a declarator is present), a TYPE (if there is no
9196 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
9200 grokdeclarator (const cp_declarator
*declarator
,
9201 cp_decl_specifier_seq
*declspecs
,
9202 enum decl_context decl_context
,
9206 tree type
= NULL_TREE
;
9208 int explicit_intN
= 0;
9209 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9210 int explicit_int
= 0;
9211 int explicit_char
= 0;
9212 int defaulted_int
= 0;
9214 tree typedef_decl
= NULL_TREE
;
9215 const char *name
= NULL
;
9216 tree typedef_type
= NULL_TREE
;
9217 /* True if this declarator is a function definition. */
9218 bool funcdef_flag
= false;
9219 cp_declarator_kind innermost_code
= cdk_error
;
9222 /* See the code below that used this. */
9223 tree decl_attr
= NULL_TREE
;
9226 /* Keep track of what sort of function is being processed
9227 so that we can warn about default return values, or explicit
9228 return values which do not match prescribed defaults. */
9229 special_function_kind sfk
= sfk_none
;
9231 tree dname
= NULL_TREE
;
9232 tree ctor_return_type
= NULL_TREE
;
9233 enum overload_flags flags
= NO_SPECIAL
;
9234 /* cv-qualifiers that apply to the declarator, for a declaration of
9235 a member function. */
9236 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
9237 /* virt-specifiers that apply to the declarator, for a declaration of
9238 a member function. */
9239 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
9240 /* ref-qualifier that applies to the declarator, for a declaration of
9241 a member function. */
9242 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
9243 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
9244 int type_quals
= TYPE_UNQUALIFIED
;
9245 tree raises
= NULL_TREE
;
9246 int template_count
= 0;
9247 tree returned_attrs
= NULL_TREE
;
9248 tree parms
= NULL_TREE
;
9249 const cp_declarator
*id_declarator
;
9250 /* The unqualified name of the declarator; either an
9251 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
9252 tree unqualified_id
;
9253 /* The class type, if any, in which this entity is located,
9254 or NULL_TREE if none. Note that this value may be different from
9255 the current class type; for example if an attempt is made to declare
9256 "A::f" inside "B", this value will be "A". */
9257 tree ctype
= current_class_type
;
9258 /* The NAMESPACE_DECL for the namespace in which this entity is
9259 located. If an unqualified name is used to declare the entity,
9260 this value will be NULL_TREE, even if the entity is located at
9262 tree in_namespace
= NULL_TREE
;
9263 cp_storage_class storage_class
;
9264 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
9265 bool type_was_error_mark_node
= false;
9266 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
9267 bool template_type_arg
= false;
9268 bool template_parm_flag
= false;
9269 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
9270 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
9271 bool late_return_type_p
= false;
9272 bool array_parameter_p
= false;
9273 source_location saved_loc
= input_location
;
9275 tree reqs
= NULL_TREE
;
9277 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
9278 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
9279 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
9280 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
9281 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
9282 explicit_intN
= declspecs
->explicit_intN_p
;
9283 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
9285 // Was concept_p specified? Note that ds_concept
9286 // implies ds_constexpr!
9287 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
9291 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9292 type_quals
|= TYPE_QUAL_CONST
;
9293 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9294 type_quals
|= TYPE_QUAL_VOLATILE
;
9295 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9296 type_quals
|= TYPE_QUAL_RESTRICT
;
9298 if (decl_context
== FUNCDEF
)
9299 funcdef_flag
= true, decl_context
= NORMAL
;
9300 else if (decl_context
== MEMFUNCDEF
)
9301 funcdef_flag
= true, decl_context
= FIELD
;
9302 else if (decl_context
== BITFIELD
)
9303 bitfield
= 1, decl_context
= FIELD
;
9304 else if (decl_context
== TEMPLATE_TYPE_ARG
)
9305 template_type_arg
= true, decl_context
= TYPENAME
;
9306 else if (decl_context
== TPARM
)
9307 template_parm_flag
= true, decl_context
= PARM
;
9309 if (initialized
> 1)
9310 funcdef_flag
= true;
9312 /* Look inside a declarator for the name being declared
9313 and get it as a string, for an error message. */
9314 for (id_declarator
= declarator
;
9316 id_declarator
= id_declarator
->declarator
)
9318 if (id_declarator
->kind
!= cdk_id
)
9319 innermost_code
= id_declarator
->kind
;
9321 switch (id_declarator
->kind
)
9324 if (id_declarator
->declarator
9325 && id_declarator
->declarator
->kind
== cdk_id
)
9327 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
9328 if (sfk
== sfk_destructor
)
9335 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
9336 tree decl
= id_declarator
->u
.id
.unqualified_name
;
9339 if (qualifying_scope
)
9341 if (at_function_scope_p ())
9345 A declarator-id shall not be qualified except
9348 None of the cases are permitted in block
9350 if (qualifying_scope
== global_namespace
)
9351 error ("invalid use of qualified-name %<::%D%>",
9353 else if (TYPE_P (qualifying_scope
))
9354 error ("invalid use of qualified-name %<%T::%D%>",
9355 qualifying_scope
, decl
);
9357 error ("invalid use of qualified-name %<%D::%D%>",
9358 qualifying_scope
, decl
);
9359 return error_mark_node
;
9361 else if (TYPE_P (qualifying_scope
))
9363 ctype
= qualifying_scope
;
9364 if (!MAYBE_CLASS_TYPE_P (ctype
))
9366 error ("%q#T is not a class or a namespace", ctype
);
9369 else if (innermost_code
!= cdk_function
9370 && current_class_type
9371 && !uniquely_derived_from_p (ctype
,
9372 current_class_type
))
9374 error ("invalid use of qualified-name %<%T::%D%>",
9375 qualifying_scope
, decl
);
9376 return error_mark_node
;
9379 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
9380 in_namespace
= qualifying_scope
;
9382 switch (TREE_CODE (decl
))
9388 if (innermost_code
!= cdk_function
)
9390 error ("declaration of %qD as non-function", decl
);
9391 return error_mark_node
;
9393 else if (!qualifying_scope
9394 && !(current_class_type
&& at_class_scope_p ()))
9396 error ("declaration of %qD as non-member", decl
);
9397 return error_mark_node
;
9400 type
= TREE_OPERAND (decl
, 0);
9402 type
= constructor_name (type
);
9403 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
9408 case TEMPLATE_ID_EXPR
:
9410 tree fns
= TREE_OPERAND (decl
, 0);
9413 if (!identifier_p (dname
))
9415 if (variable_template_p (dname
))
9416 dname
= DECL_NAME (dname
);
9419 gcc_assert (is_overloaded_fn (dname
));
9420 dname
= DECL_NAME (get_first_fn (dname
));
9426 case IDENTIFIER_NODE
:
9427 if (identifier_p (decl
))
9430 if (C_IS_RESERVED_WORD (dname
))
9432 error ("declarator-id missing; using reserved word %qD",
9434 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9436 else if (!IDENTIFIER_TYPENAME_P (dname
))
9437 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9440 gcc_assert (flags
== NO_SPECIAL
);
9441 flags
= TYPENAME_FLAG
;
9442 ctor_return_type
= TREE_TYPE (dname
);
9443 sfk
= sfk_conversion
;
9444 if (is_typename_at_global_scope (dname
))
9445 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9447 name
= "<invalid operator>";
9464 return error_mark_node
;
9469 if (id_declarator
->kind
== cdk_id
)
9475 The declarator in a function-definition shall have the form
9476 D1 ( parameter-declaration-clause) ... */
9477 if (funcdef_flag
&& innermost_code
!= cdk_function
)
9479 error ("function definition does not declare parameters");
9480 return error_mark_node
;
9483 if (flags
== TYPENAME_FLAG
9484 && innermost_code
!= cdk_function
9485 && ! (ctype
&& !declspecs
->any_specifiers_p
))
9487 error ("declaration of %qD as non-function", dname
);
9488 return error_mark_node
;
9492 && identifier_p (dname
)
9493 && UDLIT_OPER_P (dname
)
9494 && innermost_code
!= cdk_function
)
9496 error ("declaration of %qD as non-function", dname
);
9497 return error_mark_node
;
9500 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9504 error ("declaration of %qD as %<typedef%>", dname
);
9505 return error_mark_node
;
9507 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9509 error ("declaration of %qD as parameter", dname
);
9510 return error_mark_node
;
9514 /* Anything declared one level down from the top level
9515 must be one of the parameters of a function
9516 (because the body is at least two levels down). */
9518 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9519 by not allowing C++ class definitions to specify their parameters
9520 with xdecls (must be spec.d in the parmlist).
9522 Since we now wait to push a class scope until we are sure that
9523 we are in a legitimate method context, we must set oldcname
9524 explicitly (since current_class_name is not yet alive).
9526 We also want to avoid calling this a PARM if it is in a namespace. */
9528 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9530 cp_binding_level
*b
= current_binding_level
;
9531 current_binding_level
= b
->level_chain
;
9532 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9533 decl_context
= PARM
;
9534 current_binding_level
= b
;
9538 name
= decl_context
== PARM
? "parameter" : "type name";
9540 if (concept_p
&& typedef_p
)
9542 error ("%<concept%> cannot appear in a typedef declaration");
9543 return error_mark_node
;
9546 if (constexpr_p
&& typedef_p
)
9548 error ("%<constexpr%> cannot appear in a typedef declaration");
9549 return error_mark_node
;
9552 /* If there were multiple types specified in the decl-specifier-seq,
9553 issue an error message. */
9554 if (declspecs
->multiple_types_p
)
9556 error ("two or more data types in declaration of %qs", name
);
9557 return error_mark_node
;
9560 if (declspecs
->conflicting_specifiers_p
)
9562 error ("conflicting specifiers in declaration of %qs", name
);
9563 return error_mark_node
;
9566 /* Extract the basic type from the decl-specifier-seq. */
9567 type
= declspecs
->type
;
9568 if (type
== error_mark_node
)
9571 type_was_error_mark_node
= true;
9573 /* If the entire declaration is itself tagged as deprecated then
9574 suppress reports of deprecated items. */
9575 if (type
&& TREE_DEPRECATED (type
)
9576 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9577 warn_deprecated_use (type
, NULL_TREE
);
9578 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9580 typedef_decl
= type
;
9581 type
= TREE_TYPE (typedef_decl
);
9582 if (TREE_DEPRECATED (type
)
9583 && DECL_ARTIFICIAL (typedef_decl
)
9584 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9585 warn_deprecated_use (type
, NULL_TREE
);
9587 /* No type at all: default to `int', and set DEFAULTED_INT
9588 because it was not a user-defined typedef. */
9589 if (type
== NULL_TREE
)
9591 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
9593 /* These imply 'int'. */
9594 type
= integer_type_node
;
9597 /* If we just have "complex", it is equivalent to "complex double". */
9598 else if (!longlong
&& !explicit_intN
9599 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9601 type
= double_type_node
;
9602 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
9603 "ISO C++ does not support plain %<complex%> meaning "
9604 "%<double complex%>");
9608 explicit_int
= declspecs
->explicit_int_p
;
9609 explicit_char
= declspecs
->explicit_char_p
;
9612 /* See the code below that used this. */
9614 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9616 typedef_type
= type
;
9619 if (sfk
!= sfk_conversion
)
9620 ctor_return_type
= ctype
;
9622 if (sfk
!= sfk_none
)
9624 type
= check_special_function_return_type (sfk
, type
,
9627 declspecs
->locations
);
9628 type_quals
= TYPE_UNQUALIFIED
;
9630 else if (type
== NULL_TREE
)
9636 /* We handle `main' specially here, because 'main () { }' is so
9637 common. With no options, it is allowed. With -Wreturn-type,
9638 it is a warning. It is only an error with -pedantic-errors. */
9639 is_main
= (funcdef_flag
9640 && dname
&& identifier_p (dname
)
9641 && MAIN_NAME_P (dname
)
9642 && ctype
== NULL_TREE
9643 && in_namespace
== NULL_TREE
9644 && current_namespace
== global_namespace
);
9646 if (type_was_error_mark_node
)
9647 /* We've already issued an error, don't complain more. */;
9648 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9649 /* Allow it, sigh. */;
9651 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9653 pedwarn (input_location
, OPT_Wpedantic
,
9654 "ISO C++ forbids declaration of %qs with no type", name
);
9656 warning (OPT_Wreturn_type
,
9657 "ISO C++ forbids declaration of %qs with no type", name
);
9659 if (type_was_error_mark_node
&& template_parm_flag
)
9660 /* FIXME we should be able to propagate the error_mark_node as is
9661 for other contexts too. */
9662 type
= error_mark_node
;
9664 type
= integer_type_node
;
9671 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
9673 error ("%<__int%d%> is not supported by this target",
9674 int_n_data
[declspecs
->int_n_idx
].bitsize
);
9675 explicit_intN
= false;
9677 else if (pedantic
&& ! in_system_header_at (input_location
))
9678 pedwarn (input_location
, OPT_Wpedantic
,
9679 "ISO C++ does not support %<__int%d%> for %qs",
9680 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
9683 /* Now process the modifiers that were specified
9684 and check for invalid combinations. */
9686 /* Long double is a special combination. */
9687 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9690 type
= cp_build_qualified_type (long_double_type_node
,
9691 cp_type_quals (type
));
9694 /* Check all other uses of type modifiers. */
9696 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9700 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9701 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9702 else if (signed_p
&& unsigned_p
)
9703 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9704 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9705 error ("%<long long%> invalid for %qs", name
);
9706 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9707 error ("%<long%> invalid for %qs", name
);
9708 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9709 error ("%<short%> invalid for %qs", name
);
9710 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9711 error ("%<long%> or %<short%> invalid for %qs", name
);
9712 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
9713 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9714 else if ((long_p
|| short_p
) && explicit_char
)
9715 error ("%<long%> or %<short%> specified with char for %qs", name
);
9716 else if (long_p
&& short_p
)
9717 error ("%<long%> and %<short%> specified together for %qs", name
);
9718 else if (type
== char16_type_node
|| type
== char32_type_node
)
9720 if (signed_p
|| unsigned_p
)
9721 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9722 else if (short_p
|| long_p
)
9723 error ("%<short%> or %<long%> invalid for %qs", name
);
9728 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
9730 pedwarn (input_location
, OPT_Wpedantic
,
9731 "long, short, signed or unsigned used invalidly for %qs",
9733 if (flag_pedantic_errors
)
9738 /* Discard the type modifiers if they are invalid. */
9749 /* Decide whether an integer type is signed or not.
9750 Optionally treat bitfields as signed by default. */
9754 It is implementation-defined whether a plain (neither
9755 explicitly signed or unsigned) char, short, int, or long
9756 bit-field is signed or unsigned.
9758 Naturally, we extend this to long long as well. Note that
9759 this does not include wchar_t. */
9760 || (bitfield
&& !flag_signed_bitfields
9762 /* A typedef for plain `int' without `signed' can be
9763 controlled just like plain `int', but a typedef for
9764 `signed int' cannot be so controlled. */
9766 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9767 && TREE_CODE (type
) == INTEGER_TYPE
9768 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9771 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
9773 type
= long_long_unsigned_type_node
;
9775 type
= long_unsigned_type_node
;
9777 type
= short_unsigned_type_node
;
9778 else if (type
== char_type_node
)
9779 type
= unsigned_char_type_node
;
9780 else if (typedef_decl
)
9781 type
= unsigned_type_for (type
);
9783 type
= unsigned_type_node
;
9785 else if (signed_p
&& type
== char_type_node
)
9786 type
= signed_char_type_node
;
9787 else if (explicit_intN
)
9788 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
9790 type
= long_long_integer_type_node
;
9792 type
= long_integer_type_node
;
9794 type
= short_integer_type_node
;
9796 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9798 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9799 error ("complex invalid for %qs", name
);
9800 /* If a modifier is specified, the resulting complex is the complex
9801 form of TYPE. E.g, "complex short" is "complex short int". */
9802 else if (type
== integer_type_node
)
9803 type
= complex_integer_type_node
;
9804 else if (type
== float_type_node
)
9805 type
= complex_float_type_node
;
9806 else if (type
== double_type_node
)
9807 type
= complex_double_type_node
;
9808 else if (type
== long_double_type_node
)
9809 type
= complex_long_double_type_node
;
9811 type
= build_complex_type (type
);
9814 /* If we're using the injected-class-name to form a compound type or a
9815 declaration, replace it with the underlying class so we don't get
9816 redundant typedefs in the debug output. But if we are returning the
9817 type unchanged, leave it alone so that it's available to
9818 maybe_get_template_decl_from_type_decl. */
9819 if (CLASS_TYPE_P (type
)
9820 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9821 && type
== TREE_TYPE (TYPE_NAME (type
))
9822 && (declarator
|| type_quals
))
9823 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9825 type_quals
|= cp_type_quals (type
);
9826 type
= cp_build_qualified_type_real
9827 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
9828 || declspecs
->decltype_p
)
9829 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9830 /* We might have ignored or rejected some of the qualifiers. */
9831 type_quals
= cp_type_quals (type
);
9834 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9835 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9836 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9838 storage_class
= declspecs
->storage_class
;
9839 if (storage_class
== sc_static
)
9840 staticp
= 1 + (decl_context
== FIELD
);
9846 error ("member %qD cannot be declared both %<virtual%> "
9847 "and %<static%>", dname
);
9848 storage_class
= sc_none
;
9852 error ("member %qD cannot be declared both %<virtual%> "
9853 "and %<constexpr%>", dname
);
9855 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9857 /* Issue errors about use of storage classes for parameters. */
9858 if (decl_context
== PARM
)
9862 error ("typedef declaration invalid in parameter declaration");
9863 return error_mark_node
;
9865 else if (template_parm_flag
&& storage_class
!= sc_none
)
9867 error ("storage class specified for template parameter %qs", name
);
9868 return error_mark_node
;
9870 else if (storage_class
== sc_static
9871 || storage_class
== sc_extern
9873 error ("storage class specifiers invalid in parameter declarations");
9875 /* Function parameters cannot be concept. */
9877 error ("a parameter cannot be declared %<concept%>");
9878 /* Function parameters cannot be constexpr. If we saw one, moan
9879 and pretend it wasn't there. */
9880 else if (constexpr_p
)
9882 error ("a parameter cannot be declared %<constexpr%>");
9887 /* Give error if `virtual' is used outside of class declaration. */
9889 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9891 error_at (declspecs
->locations
[ds_virtual
],
9892 "%<virtual%> outside class declaration");
9896 /* Static anonymous unions are dealt with here. */
9897 if (staticp
&& decl_context
== TYPENAME
9899 && ANON_AGGR_TYPE_P (declspecs
->type
))
9900 decl_context
= FIELD
;
9902 /* Warn about storage classes that are invalid for certain
9903 kinds of declarations (parameters, typenames, etc.). */
9906 && storage_class
!= sc_extern
9907 && storage_class
!= sc_static
)
9910 error ("multiple storage classes in declaration of %qs", name
);
9913 if (decl_context
!= NORMAL
9914 && ((storage_class
!= sc_none
9915 && storage_class
!= sc_mutable
)
9918 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9919 && (storage_class
== sc_register
9920 || storage_class
== sc_auto
))
9924 else if (decl_context
== FIELD
9925 /* C++ allows static class elements. */
9926 && storage_class
== sc_static
)
9927 /* C++ also allows inlines and signed and unsigned elements,
9928 but in those cases we don't come in here. */
9932 if (decl_context
== FIELD
)
9933 error ("storage class specified for %qs", name
);
9936 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9937 error ("storage class specified for parameter %qs", name
);
9939 error ("storage class specified for typename");
9941 if (storage_class
== sc_register
9942 || storage_class
== sc_auto
9943 || storage_class
== sc_extern
9945 storage_class
= sc_none
;
9948 else if (storage_class
== sc_extern
&& funcdef_flag
9949 && ! toplevel_bindings_p ())
9950 error ("nested function %qs declared %<extern%>", name
);
9951 else if (toplevel_bindings_p ())
9953 if (storage_class
== sc_auto
)
9954 error ("top-level declaration of %qs specifies %<auto%>", name
);
9957 && storage_class
!= sc_extern
9958 && storage_class
!= sc_static
)
9960 if (declspecs
->gnu_thread_keyword_p
)
9961 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9962 "declared %<__thread%>", name
);
9964 /* When thread_local is applied to a variable of block scope the
9965 storage-class-specifier static is implied if it does not appear
9967 storage_class
= declspecs
->storage_class
= sc_static
;
9971 if (storage_class
&& friendp
)
9973 error ("storage class specifiers invalid in friend function declarations");
9974 storage_class
= sc_none
;
9979 unqualified_id
= NULL_TREE
;
9982 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9983 switch (TREE_CODE (unqualified_id
))
9986 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9987 if (TYPE_P (unqualified_id
))
9988 unqualified_id
= constructor_name (unqualified_id
);
9991 case IDENTIFIER_NODE
:
9992 case TEMPLATE_ID_EXPR
:
10000 if (declspecs
->std_attributes
)
10002 /* Apply the c++11 attributes to the type preceding them. */
10003 input_location
= declspecs
->locations
[ds_std_attribute
];
10004 decl_attributes (&type
, declspecs
->std_attributes
, 0);
10005 input_location
= saved_loc
;
10008 /* Determine the type of the entity declared by recurring on the
10010 for (; declarator
; declarator
= declarator
->declarator
)
10012 const cp_declarator
*inner_declarator
;
10015 if (type
== error_mark_node
)
10016 return error_mark_node
;
10018 attrs
= declarator
->attributes
;
10024 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
10025 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
10026 if (declarator
->kind
== cdk_function
)
10027 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
10028 if (declarator
->kind
== cdk_array
)
10029 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
10030 returned_attrs
= decl_attributes (&type
,
10031 chainon (returned_attrs
, attrs
),
10035 if (declarator
->kind
== cdk_id
)
10038 inner_declarator
= declarator
->declarator
;
10040 switch (declarator
->kind
)
10043 type
= create_array_type_for_decl (dname
, type
,
10044 declarator
->u
.array
.bounds
);
10045 if (!valid_array_size_p (input_location
, type
, dname
))
10046 type
= error_mark_node
;
10048 if (declarator
->std_attributes
)
10051 The optional attribute-specifier-seq appertains to the
10053 returned_attrs
= chainon (returned_attrs
,
10054 declarator
->std_attributes
);
10062 /* Declaring a function type.
10063 Make sure we have a valid type for the function to return. */
10065 if (type_quals
!= TYPE_UNQUALIFIED
)
10067 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
10068 warning (OPT_Wignored_qualifiers
,
10069 "type qualifiers ignored on function return type");
10070 /* We now know that the TYPE_QUALS don't apply to the
10071 decl, but to its return type. */
10072 type_quals
= TYPE_UNQUALIFIED
;
10074 errmsg
= targetm
.invalid_return_type (type
);
10078 type
= integer_type_node
;
10081 /* Error about some types functions can't return. */
10083 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10085 error ("%qs declared as function returning a function", name
);
10086 return error_mark_node
;
10088 if (TREE_CODE (type
) == ARRAY_TYPE
)
10090 error ("%qs declared as function returning an array", name
);
10091 return error_mark_node
;
10094 input_location
= declspecs
->locations
[ds_type_spec
];
10095 abstract_virtuals_error (ACU_RETURN
, type
);
10096 input_location
= saved_loc
;
10098 /* Pick up type qualifiers which should be applied to `this'. */
10099 memfn_quals
= declarator
->u
.function
.qualifiers
;
10100 /* Pick up virt-specifiers. */
10101 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
10102 /* And ref-qualifier, too */
10103 rqual
= declarator
->u
.function
.ref_qualifier
;
10104 /* And tx-qualifier. */
10105 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
10106 /* Pick up the exception specifications. */
10107 raises
= declarator
->u
.function
.exception_specification
;
10108 /* If the exception-specification is ill-formed, let's pretend
10109 there wasn't one. */
10110 if (raises
== error_mark_node
)
10111 raises
= NULL_TREE
;
10114 error_at (location_of (reqs
), "requires-clause on return type");
10115 reqs
= declarator
->u
.function
.requires_clause
;
10117 /* Say it's a definition only for the CALL_EXPR
10118 closest to the identifier. */
10119 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
10121 /* Handle a late-specified return type. */
10124 if (type_uses_auto (type
))
10126 if (!declarator
->u
.function
.late_return_type
)
10128 if (current_class_type
10129 && LAMBDA_TYPE_P (current_class_type
))
10130 /* OK for C++11 lambdas. */;
10131 else if (cxx_dialect
< cxx14
)
10133 error ("%qs function uses "
10134 "%<auto%> type specifier without trailing "
10135 "return type", name
);
10136 inform (input_location
, "deduced return type "
10137 "only available with -std=c++14 or "
10142 error ("virtual function cannot "
10143 "have deduced return type");
10147 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
10149 error ("%qs function with trailing return type has"
10150 " %qT as its type rather than plain %<auto%>",
10152 return error_mark_node
;
10155 else if (declarator
->u
.function
.late_return_type
10156 && sfk
!= sfk_conversion
)
10158 if (cxx_dialect
< cxx11
)
10159 /* Not using maybe_warn_cpp0x because this should
10160 always be an error. */
10161 error ("trailing return type only available with "
10162 "-std=c++11 or -std=gnu++11");
10164 error ("%qs function with trailing return type not "
10165 "declared with %<auto%> type specifier", name
);
10166 return error_mark_node
;
10169 type
= splice_late_return_type
10170 (type
, declarator
->u
.function
.late_return_type
);
10171 if (type
== error_mark_node
)
10172 return error_mark_node
;
10174 if (declarator
->u
.function
.late_return_type
)
10175 late_return_type_p
= true;
10177 if (ctype
== NULL_TREE
10178 && decl_context
== FIELD
10181 ctype
= current_class_type
;
10183 if (ctype
&& (sfk
== sfk_constructor
10184 || sfk
== sfk_destructor
))
10186 /* We are within a class's scope. If our declarator name
10187 is the same as the class name, and we are defining
10188 a function, then it is a constructor/destructor, and
10189 therefore returns a void type. */
10191 /* ISO C++ 12.4/2. A destructor may not be declared
10192 const or volatile. A destructor may not be static.
10193 A destructor may not be declared with ref-qualifier.
10195 ISO C++ 12.1. A constructor may not be declared
10196 const or volatile. A constructor may not be
10197 virtual. A constructor may not be static.
10198 A constructor may not be declared with ref-qualifier. */
10200 error ((flags
== DTOR_FLAG
)
10201 ? G_("destructor cannot be static member function")
10202 : G_("constructor cannot be static member function"));
10205 error ((flags
== DTOR_FLAG
)
10206 ? G_("destructors may not be cv-qualified")
10207 : G_("constructors may not be cv-qualified"));
10208 memfn_quals
= TYPE_UNQUALIFIED
;
10213 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
10214 error ((flags
== DTOR_FLAG
)
10215 ? "destructors may not be ref-qualified"
10216 : "constructors may not be ref-qualified");
10217 rqual
= REF_QUAL_NONE
;
10220 if (decl_context
== FIELD
10221 && !member_function_or_else (ctype
,
10222 current_class_type
,
10224 return error_mark_node
;
10226 if (flags
!= DTOR_FLAG
)
10228 /* It's a constructor. */
10229 if (explicitp
== 1)
10233 permerror (input_location
,
10234 "constructors cannot be declared %<virtual%>");
10237 if (decl_context
== FIELD
10238 && sfk
!= sfk_constructor
)
10239 return error_mark_node
;
10241 if (decl_context
== FIELD
)
10248 /* Cannot be both friend and virtual. */
10249 error ("virtual functions cannot be friends");
10252 if (decl_context
== NORMAL
)
10253 error ("friend declaration not in class definition");
10254 if (current_function_decl
&& funcdef_flag
)
10255 error ("can%'t define friend function %qs in a local "
10256 "class definition",
10259 else if (ctype
&& sfk
== sfk_conversion
)
10261 if (explicitp
== 1)
10263 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
10266 if (late_return_type_p
)
10267 error ("a conversion function cannot have a trailing return type");
10270 arg_types
= grokparms (declarator
->u
.function
.parameters
,
10273 if (inner_declarator
10274 && inner_declarator
->kind
== cdk_id
10275 && inner_declarator
->u
.id
.sfk
== sfk_destructor
10276 && arg_types
!= void_list_node
)
10278 error ("destructors may not have parameters");
10279 arg_types
= void_list_node
;
10283 type
= build_function_type (type
, arg_types
);
10285 tree attrs
= declarator
->std_attributes
;
10288 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
10289 /* transaction_safe applies to the type, but
10290 transaction_safe_dynamic applies to the function. */
10291 if (is_attribute_p ("transaction_safe", tx_qual
))
10292 attrs
= chainon (attrs
, att
);
10294 returned_attrs
= chainon (returned_attrs
, att
);
10299 The optional attribute-specifier-seq appertains to
10300 the function type. */
10301 decl_attributes (&type
, attrs
, 0);
10306 case cdk_reference
:
10308 /* Filter out pointers-to-references and references-to-references.
10309 We can get these if a TYPE_DECL is used. */
10311 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10313 if (declarator
->kind
!= cdk_reference
)
10315 error ("cannot declare pointer to %q#T", type
);
10316 type
= TREE_TYPE (type
);
10319 /* In C++0x, we allow reference to reference declarations
10320 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
10321 and template type arguments [14.3.1/4 temp.arg.type]. The
10322 check for direct reference to reference declarations, which
10323 are still forbidden, occurs below. Reasoning behind the change
10324 can be found in DR106, DR540, and the rvalue reference
10326 else if (cxx_dialect
== cxx98
)
10328 error ("cannot declare reference to %q#T", type
);
10329 type
= TREE_TYPE (type
);
10332 else if (VOID_TYPE_P (type
))
10334 if (declarator
->kind
== cdk_reference
)
10335 error ("cannot declare reference to %q#T", type
);
10336 else if (declarator
->kind
== cdk_ptrmem
)
10337 error ("cannot declare pointer to %q#T member", type
);
10340 /* We now know that the TYPE_QUALS don't apply to the decl,
10341 but to the target of the pointer. */
10342 type_quals
= TYPE_UNQUALIFIED
;
10344 /* This code used to handle METHOD_TYPE, but I don't think it's
10345 possible to get it here anymore. */
10346 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
10347 if (declarator
->kind
== cdk_ptrmem
10348 && TREE_CODE (type
) == FUNCTION_TYPE
)
10350 memfn_quals
|= type_memfn_quals (type
);
10351 type
= build_memfn_type (type
,
10352 declarator
->u
.pointer
.class_type
,
10355 if (type
== error_mark_node
)
10356 return error_mark_node
;
10358 rqual
= REF_QUAL_NONE
;
10359 memfn_quals
= TYPE_UNQUALIFIED
;
10362 if (TREE_CODE (type
) == FUNCTION_TYPE
10363 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
10364 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
10365 error (declarator
->kind
== cdk_reference
10366 ? G_("cannot declare reference to qualified function type %qT")
10367 : G_("cannot declare pointer to qualified function type %qT"),
10370 /* When the pointed-to type involves components of variable size,
10371 care must be taken to ensure that the size evaluation code is
10372 emitted early enough to dominate all the possible later uses
10373 and late enough for the variables on which it depends to have
10376 This is expected to happen automatically when the pointed-to
10377 type has a name/declaration of it's own, but special attention
10378 is required if the type is anonymous.
10380 We handle the NORMAL and FIELD contexts here by inserting a
10381 dummy statement that just evaluates the size at a safe point
10382 and ensures it is not deferred until e.g. within a deeper
10383 conditional context (c++/43555).
10385 We expect nothing to be needed here for PARM or TYPENAME.
10386 Evaluating the size at this point for TYPENAME would
10387 actually be incorrect, as we might be in the middle of an
10388 expression with side effects on the pointed-to type size
10389 "arguments" prior to the pointer declaration point and the
10390 size evaluation could end up prior to the side effects. */
10392 if (!TYPE_NAME (type
)
10393 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
10394 && at_function_scope_p ()
10395 && variably_modified_type_p (type
, NULL_TREE
))
10396 /* Force evaluation of the SAVE_EXPR. */
10397 finish_expr_stmt (TYPE_SIZE (type
));
10399 if (declarator
->kind
== cdk_reference
)
10401 /* In C++0x, the type we are creating a reference to might be
10402 a typedef which is itself a reference type. In that case,
10403 we follow the reference collapsing rules in
10404 [7.1.3/8 dcl.typedef] to create the final reference type:
10406 "If a typedef TD names a type that is a reference to a type
10407 T, an attempt to create the type 'lvalue reference to cv TD'
10408 creates the type 'lvalue reference to T,' while an attempt
10409 to create the type "rvalue reference to cv TD' creates the
10412 if (VOID_TYPE_P (type
))
10413 /* We already gave an error. */;
10414 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10416 if (declarator
->u
.reference
.rvalue_ref
)
10417 /* Leave type alone. */;
10419 type
= cp_build_reference_type (TREE_TYPE (type
), false);
10422 type
= cp_build_reference_type
10423 (type
, declarator
->u
.reference
.rvalue_ref
);
10425 /* In C++0x, we need this check for direct reference to
10426 reference declarations, which are forbidden by
10427 [8.3.2/5 dcl.ref]. Reference to reference declarations
10428 are only allowed indirectly through typedefs and template
10429 type arguments. Example:
10431 void foo(int & &); // invalid ref-to-ref decl
10433 typedef int & int_ref;
10434 void foo(int_ref &); // valid ref-to-ref decl
10436 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
10437 error ("cannot declare reference to %q#T, which is not "
10438 "a typedef or a template type argument", type
);
10440 else if (TREE_CODE (type
) == METHOD_TYPE
)
10441 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10442 else if (declarator
->kind
== cdk_ptrmem
)
10444 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
10445 != NAMESPACE_DECL
);
10446 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
10447 /* We will already have complained. */
10448 type
= error_mark_node
;
10450 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
10454 type
= build_pointer_type (type
);
10456 /* Process a list of type modifier keywords (such as
10457 const or volatile) that were given inside the `*' or `&'. */
10459 if (declarator
->u
.pointer
.qualifiers
)
10462 = cp_build_qualified_type (type
,
10463 declarator
->u
.pointer
.qualifiers
);
10464 type_quals
= cp_type_quals (type
);
10467 /* Apply C++11 attributes to the pointer, and not to the
10468 type pointed to. This is unlike what is done for GNU
10469 attributes above. It is to comply with [dcl.ptr]/1:
10471 [the optional attribute-specifier-seq (7.6.1) appertains
10472 to the pointer and not to the object pointed to]. */
10473 if (declarator
->std_attributes
)
10474 decl_attributes (&type
, declarator
->std_attributes
,
10484 gcc_unreachable ();
10488 /* A `constexpr' specifier used in an object declaration declares
10489 the object as `const'. */
10490 if (constexpr_p
&& innermost_code
!= cdk_function
)
10492 /* DR1688 says that a `constexpr' specifier in combination with
10493 `volatile' is valid. */
10495 if (TREE_CODE (type
) != REFERENCE_TYPE
)
10497 type_quals
|= TYPE_QUAL_CONST
;
10498 type
= cp_build_qualified_type (type
, type_quals
);
10502 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
10503 && TREE_CODE (type
) != FUNCTION_TYPE
10504 && TREE_CODE (type
) != METHOD_TYPE
10505 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
10507 error ("template-id %qD used as a declarator",
10509 unqualified_id
= dname
;
10512 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10513 qualified with a class-name, turn it into a METHOD_TYPE, unless
10514 we know that the function is static. We take advantage of this
10515 opportunity to do other processing that pertains to entities
10516 explicitly declared to be class members. Note that if DECLARATOR
10517 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10518 would not have exited the loop above. */
10520 && declarator
->u
.id
.qualifying_scope
10521 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
10523 ctype
= declarator
->u
.id
.qualifying_scope
;
10524 ctype
= TYPE_MAIN_VARIANT (ctype
);
10525 template_count
= num_template_headers_for_class (ctype
);
10527 if (ctype
== current_class_type
)
10531 permerror (input_location
, "member functions are implicitly friends of their class");
10535 permerror (declarator
->id_loc
,
10536 "extra qualification %<%T::%> on member %qs",
10539 else if (/* If the qualifying type is already complete, then we
10540 can skip the following checks. */
10541 !COMPLETE_TYPE_P (ctype
)
10542 && (/* If the function is being defined, then
10543 qualifying type must certainly be complete. */
10545 /* A friend declaration of "T::f" is OK, even if
10546 "T" is a template parameter. But, if this
10547 function is not a friend, the qualifying type
10548 must be a class. */
10549 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10550 /* For a declaration, the type need not be
10551 complete, if either it is dependent (since there
10552 is no meaningful definition of complete in that
10553 case) or the qualifying class is currently being
10555 || !(dependent_type_p (ctype
)
10556 || currently_open_class (ctype
)))
10557 /* Check that the qualifying type is complete. */
10558 && !complete_type_or_else (ctype
, NULL_TREE
))
10559 return error_mark_node
;
10560 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10562 if (current_class_type
10563 && (!friendp
|| funcdef_flag
))
10565 error (funcdef_flag
10566 ? G_("cannot define member function %<%T::%s%> "
10568 : G_("cannot declare member function %<%T::%s%> "
10570 ctype
, name
, current_class_type
);
10571 return error_mark_node
;
10574 else if (typedef_p
&& current_class_type
)
10576 error ("cannot declare member %<%T::%s%> within %qT",
10577 ctype
, name
, current_class_type
);
10578 return error_mark_node
;
10582 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10583 ctype
= current_class_type
;
10585 /* Now TYPE has the actual type. */
10587 if (returned_attrs
)
10590 *attrlist
= chainon (returned_attrs
, *attrlist
);
10592 attrlist
= &returned_attrs
;
10596 && declarator
->kind
== cdk_id
10597 && declarator
->std_attributes
)
10598 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10599 a declarator-id appertains to the entity that is declared. */
10600 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10602 /* Handle parameter packs. */
10603 if (parameter_pack_p
)
10605 if (decl_context
== PARM
)
10606 /* Turn the type into a pack expansion.*/
10607 type
= make_pack_expansion (type
);
10609 error ("non-parameter %qs cannot be a parameter pack", name
);
10612 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10613 && !processing_template_decl
10614 && variably_modified_type_p (type
, NULL_TREE
))
10616 if (decl_context
== FIELD
)
10617 error ("data member may not have variably modified type %qT", type
);
10619 error ("parameter may not have variably modified type %qT", type
);
10620 type
= error_mark_node
;
10623 if (explicitp
== 1 || (explicitp
&& friendp
))
10625 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10626 in the declaration of a constructor or conversion function within
10627 a class definition. */
10628 if (!current_class_type
)
10629 error_at (declspecs
->locations
[ds_explicit
],
10630 "%<explicit%> outside class declaration");
10632 error_at (declspecs
->locations
[ds_explicit
],
10633 "%<explicit%> in friend declaration");
10635 error_at (declspecs
->locations
[ds_explicit
],
10636 "only declarations of constructors and conversion operators "
10637 "can be %<explicit%>");
10641 if (storage_class
== sc_mutable
)
10643 if (decl_context
!= FIELD
|| friendp
)
10645 error ("non-member %qs cannot be declared %<mutable%>", name
);
10646 storage_class
= sc_none
;
10648 else if (decl_context
== TYPENAME
|| typedef_p
)
10650 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10651 storage_class
= sc_none
;
10653 else if (TREE_CODE (type
) == FUNCTION_TYPE
10654 || TREE_CODE (type
) == METHOD_TYPE
)
10656 error ("function %qs cannot be declared %<mutable%>", name
);
10657 storage_class
= sc_none
;
10661 error ("static %qs cannot be declared %<mutable%>", name
);
10662 storage_class
= sc_none
;
10664 else if (type_quals
& TYPE_QUAL_CONST
)
10666 error ("const %qs cannot be declared %<mutable%>", name
);
10667 storage_class
= sc_none
;
10669 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10671 permerror (input_location
, "reference %qs cannot be declared "
10672 "%<mutable%>", name
);
10673 storage_class
= sc_none
;
10677 /* If this is declaring a typedef name, return a TYPE_DECL. */
10678 if (typedef_p
&& decl_context
!= TYPENAME
)
10682 /* Note that the grammar rejects storage classes
10683 in typenames, fields or parameters. */
10684 if (current_lang_name
== lang_name_java
)
10685 TYPE_FOR_JAVA (type
) = 1;
10687 /* This declaration:
10689 typedef void f(int) const;
10691 declares a function type which is not a member of any
10692 particular class, but which is cv-qualified; for
10693 example "f S::*" declares a pointer to a const-qualified
10694 member function of S. We record the cv-qualification in the
10696 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10698 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10700 /* We have now dealt with these qualifiers. */
10701 memfn_quals
= TYPE_UNQUALIFIED
;
10702 rqual
= REF_QUAL_NONE
;
10705 if (type_uses_auto (type
))
10707 error ("typedef declared %<auto%>");
10708 type
= error_mark_node
;
10712 error_at (location_of (reqs
), "requires-clause on typedef");
10714 if (decl_context
== FIELD
)
10715 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10717 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10718 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10719 error_at (DECL_SOURCE_LOCATION (decl
),
10720 "typedef name may not be a nested-name-specifier");
10721 TREE_TYPE (decl
) = error_mark_node
;
10724 if (decl_context
!= FIELD
)
10726 if (!current_function_decl
)
10727 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10728 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10729 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10730 (current_function_decl
)))
10731 /* The TYPE_DECL is "abstract" because there will be
10732 clones of this constructor/destructor, and there will
10733 be copies of this TYPE_DECL generated in those
10734 clones. The decloning optimization (for space) may
10735 revert this subsequently if it determines that
10736 the clones should share a common implementation. */
10737 DECL_ABSTRACT_P (decl
) = true;
10739 else if (current_class_type
10740 && constructor_name_p (unqualified_id
, current_class_type
))
10741 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10742 "as enclosing class",
10745 /* If the user declares "typedef struct {...} foo" then the
10746 struct will have an anonymous name. Fill that name in now.
10747 Nothing can refer to it, so nothing needs know about the name
10749 if (type
!= error_mark_node
10751 && TYPE_NAME (type
)
10752 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10753 && TYPE_ANONYMOUS_P (type
)
10754 && declspecs
->type_definition_p
10755 && attributes_naming_typedef_ok (*attrlist
)
10756 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10760 /* Replace the anonymous name with the real name everywhere. */
10761 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10763 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
10764 /* We do not rename the debug info representing the
10765 anonymous tagged type because the standard says in
10766 [dcl.typedef] that the naming applies only for
10767 linkage purposes. */
10768 /*debug_hooks->set_name (t, decl);*/
10769 TYPE_NAME (t
) = decl
;
10772 if (TYPE_LANG_SPECIFIC (type
))
10773 TYPE_WAS_ANONYMOUS (type
) = 1;
10775 /* If this is a typedef within a template class, the nested
10776 type is a (non-primary) template. The name for the
10777 template needs updating as well. */
10778 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10779 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10780 = TYPE_IDENTIFIER (type
);
10782 /* Adjust linkage now that we aren't anonymous anymore. */
10783 reset_type_linkage (type
);
10785 /* FIXME remangle member functions; member functions of a
10786 type with external linkage have external linkage. */
10790 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10791 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10793 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10794 memfn_quals
!= TYPE_UNQUALIFIED
,
10795 inlinep
, friendp
, raises
!= NULL_TREE
);
10797 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10798 /* Acknowledge that this was written:
10799 `using analias = atype;'. */
10800 TYPE_DECL_ALIAS_P (decl
) = 1;
10805 /* Detect the case of an array type of unspecified size
10806 which came, as such, direct from a typedef name.
10807 We must copy the type, so that the array's domain can be
10808 individually set by the object's initializer. */
10810 if (type
&& typedef_type
10811 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10812 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10813 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10815 /* Detect where we're using a typedef of function type to declare a
10816 function. PARMS will not be set, so we must create it now. */
10818 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10820 tree decls
= NULL_TREE
;
10823 for (args
= TYPE_ARG_TYPES (type
);
10824 args
&& args
!= void_list_node
;
10825 args
= TREE_CHAIN (args
))
10827 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10829 DECL_CHAIN (decl
) = decls
;
10833 parms
= nreverse (decls
);
10835 if (decl_context
!= TYPENAME
)
10837 /* The qualifiers on the function type become the qualifiers on
10838 the non-static member function. */
10839 memfn_quals
|= type_memfn_quals (type
);
10840 rqual
= type_memfn_rqual (type
);
10841 type_quals
= TYPE_UNQUALIFIED
;
10845 /* If this is a type name (such as, in a cast or sizeof),
10846 compute the type and return it now. */
10848 if (decl_context
== TYPENAME
)
10850 /* Note that here we don't care about type_quals. */
10852 /* Special case: "friend class foo" looks like a TYPENAME context. */
10857 error ("%<inline%> specified for friend class declaration");
10863 /* Don't allow friend declaration without a class-key. */
10864 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10865 permerror (input_location
, "template parameters cannot be friends");
10866 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10867 permerror (input_location
, "friend declaration requires class-key, "
10868 "i.e. %<friend class %T::%D%>",
10869 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10871 permerror (input_location
, "friend declaration requires class-key, "
10872 "i.e. %<friend %#T%>",
10876 /* Only try to do this stuff if we didn't already give up. */
10877 if (type
!= integer_type_node
)
10879 /* A friendly class? */
10880 if (current_class_type
)
10881 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10882 /*complain=*/true);
10884 error ("trying to make class %qT a friend of global scope",
10887 type
= void_type_node
;
10890 else if (memfn_quals
|| rqual
)
10892 if (ctype
== NULL_TREE
10893 && TREE_CODE (type
) == METHOD_TYPE
)
10894 ctype
= TYPE_METHOD_BASETYPE (type
);
10897 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10898 /* Core issue #547: need to allow this in template type args.
10899 Allow it in general in C++11 for alias-declarations. */
10900 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10901 && TREE_CODE (type
) == FUNCTION_TYPE
)
10902 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10904 error ("invalid qualifiers on non-member function type");
10908 error_at (location_of (reqs
), "requires-clause on type-id");
10912 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10913 && decl_context
!= CATCHPARM
10914 && TREE_CODE (type
) != UNION_TYPE
10917 error ("abstract declarator %qT used as declaration", type
);
10918 return error_mark_node
;
10921 /* Only functions may be declared using an operator-function-id. */
10923 && IDENTIFIER_OPNAME_P (unqualified_id
)
10924 && TREE_CODE (type
) != FUNCTION_TYPE
10925 && TREE_CODE (type
) != METHOD_TYPE
)
10927 error ("declaration of %qD as non-function", unqualified_id
);
10928 return error_mark_node
;
10932 && TREE_CODE (type
) != FUNCTION_TYPE
10933 && TREE_CODE (type
) != METHOD_TYPE
)
10934 error_at (location_of (reqs
),
10935 "requires-clause on declaration of non-function type %qT",
10938 /* We don't check parameter types here because we can emit a better
10939 error message later. */
10940 if (decl_context
!= PARM
)
10942 type
= check_var_type (unqualified_id
, type
);
10943 if (type
== error_mark_node
)
10944 return error_mark_node
;
10947 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10948 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10950 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10952 if (ctype
|| in_namespace
)
10953 error ("cannot use %<::%> in parameter declaration");
10955 if (type_uses_auto (type
))
10957 if (cxx_dialect
>= cxx14
)
10958 error ("%<auto%> parameter not permitted in this context");
10960 error ("parameter declared %<auto%>");
10961 type
= error_mark_node
;
10964 /* A parameter declared as an array of T is really a pointer to T.
10965 One declared as a function is really a pointer to a function.
10966 One declared as a member is really a pointer to member. */
10968 if (TREE_CODE (type
) == ARRAY_TYPE
)
10970 /* Transfer const-ness of array into that of type pointed to. */
10971 type
= build_pointer_type (TREE_TYPE (type
));
10972 type_quals
= TYPE_UNQUALIFIED
;
10973 array_parameter_p
= true;
10975 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10976 type
= build_pointer_type (type
);
10979 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10980 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10982 cp_cv_quals real_quals
= memfn_quals
;
10983 if (cxx_dialect
< cxx14
&& constexpr_p
10984 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10985 real_quals
|= TYPE_QUAL_CONST
;
10986 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10990 tree decl
= NULL_TREE
;
10992 if (decl_context
== PARM
)
10994 decl
= cp_build_parm_decl (unqualified_id
, type
);
10995 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
10997 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10998 memfn_quals
!= TYPE_UNQUALIFIED
,
10999 inlinep
, friendp
, raises
!= NULL_TREE
);
11001 else if (decl_context
== FIELD
)
11003 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
11004 && type_uses_auto (type
))
11006 error ("non-static data member declared %<auto%>");
11007 type
= error_mark_node
;
11010 /* The C99 flexible array extension. */
11011 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
11012 && TYPE_DOMAIN (type
) == NULL_TREE
)
11015 && (TREE_CODE (ctype
) == UNION_TYPE
11016 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
11018 error ("flexible array member in union");
11019 type
= error_mark_node
;
11023 /* Flexible array member has a null domain. */
11024 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
11028 if (type
== error_mark_node
)
11030 /* Happens when declaring arrays of sizes which
11031 are error_mark_node, for example. */
11034 else if (in_namespace
&& !friendp
)
11036 /* Something like struct S { int N::j; }; */
11037 error ("invalid use of %<::%>");
11038 return error_mark_node
;
11040 else if (TREE_CODE (type
) == FUNCTION_TYPE
11041 || TREE_CODE (type
) == METHOD_TYPE
)
11044 tree function_context
;
11048 /* This should never happen in pure C++ (the check
11049 could be an assert). It could happen in
11050 Objective-C++ if someone writes invalid code that
11051 uses a function declaration for an instance
11052 variable or property (instance variables and
11053 properties are parsed as FIELD_DECLs, but they are
11054 part of an Objective-C class, not a C++ class).
11055 That code is invalid and is caught by this
11059 error ("declaration of function %qD in invalid context",
11061 return error_mark_node
;
11064 /* ``A union may [ ... ] not [ have ] virtual functions.''
11066 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11068 error ("function %qD declared %<virtual%> inside a union",
11070 return error_mark_node
;
11073 if (NEW_DELETE_OPNAME_P (unqualified_id
))
11077 error ("%qD cannot be declared %<virtual%>, since it "
11078 "is always static",
11085 /* Check that the name used for a destructor makes sense. */
11086 if (sfk
== sfk_destructor
)
11088 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
11092 gcc_assert (friendp
);
11093 error ("expected qualified name in friend declaration "
11094 "for destructor %qD", uqname
);
11095 return error_mark_node
;
11098 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
11100 error ("declaration of %qD as member of %qT",
11102 return error_mark_node
;
11106 error ("a destructor cannot be %<concept%>");
11107 return error_mark_node
;
11111 error ("a destructor cannot be %<constexpr%>");
11112 return error_mark_node
;
11115 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
11117 error ("expected qualified name in friend declaration "
11118 "for constructor %qD",
11119 id_declarator
->u
.id
.unqualified_name
);
11120 return error_mark_node
;
11122 if (sfk
== sfk_constructor
)
11125 error ("a constructor cannot be %<concept%>");
11126 return error_mark_node
;
11130 error ("a concept cannot be a member function");
11134 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11136 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
11137 if (variable_template_p (tmpl
))
11139 error ("specialization of variable template %qD "
11140 "declared as function", tmpl
);
11141 inform (DECL_SOURCE_LOCATION (tmpl
),
11142 "variable template declared here");
11143 return error_mark_node
;
11147 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11148 function_context
= (ctype
!= NULL_TREE
) ?
11149 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11150 publicp
= (! friendp
|| ! staticp
)
11151 && function_context
== NULL_TREE
;
11153 if (late_return_type_p
)
11154 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11156 decl
= grokfndecl (ctype
, type
,
11157 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
11158 ? unqualified_id
: dname
,
11162 virtualp
, flags
, memfn_quals
, rqual
, raises
,
11163 friendp
? -1 : 0, friendp
, publicp
,
11164 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11165 initialized
== SD_DELETED
, sfk
,
11166 funcdef_flag
, template_count
, in_namespace
,
11167 attrlist
, declarator
->id_loc
);
11168 decl
= set_virt_specifiers (decl
, virt_specifiers
);
11169 if (decl
== NULL_TREE
)
11170 return error_mark_node
;
11172 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11173 /* The decl and setting of decl_attr is also turned off. */
11174 decl
= build_decl_attribute_variant (decl
, decl_attr
);
11177 /* [class.conv.ctor]
11179 A constructor declared without the function-specifier
11180 explicit that can be called with a single parameter
11181 specifies a conversion from the type of its first
11182 parameter to the type of its class. Such a constructor
11183 is called a converting constructor. */
11184 if (explicitp
== 2)
11185 DECL_NONCONVERTING_P (decl
) = 1;
11187 else if (!staticp
&& !dependent_type_p (type
)
11188 && !COMPLETE_TYPE_P (complete_type (type
))
11189 && (TREE_CODE (type
) != ARRAY_TYPE
11190 || !COMPLETE_TYPE_P (TREE_TYPE (type
))
11191 || initialized
== 0))
11193 if (TREE_CODE (type
) != ARRAY_TYPE
11194 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
11196 if (unqualified_id
)
11198 error ("field %qD has incomplete type %qT",
11199 unqualified_id
, type
);
11200 cxx_incomplete_type_inform (strip_array_types (type
));
11203 error ("name %qT has incomplete type", type
);
11205 type
= error_mark_node
;
11213 error ("%qE is neither function nor member function; "
11214 "cannot be declared friend", unqualified_id
);
11222 /* Friends are treated specially. */
11223 if (ctype
== current_class_type
)
11224 ; /* We already issued a permerror. */
11225 else if (decl
&& DECL_NAME (decl
))
11227 if (template_class_depth (current_class_type
) == 0)
11229 decl
= check_explicit_specialization
11230 (unqualified_id
, decl
, template_count
,
11231 2 * funcdef_flag
+ 4);
11232 if (decl
== error_mark_node
)
11233 return error_mark_node
;
11236 decl
= do_friend (ctype
, unqualified_id
, decl
,
11242 return error_mark_node
;
11245 /* Structure field. It may not be a function, except for C++. */
11247 if (decl
== NULL_TREE
)
11251 /* C++ allows static class members. All other work
11252 for this is done by grokfield. */
11253 decl
= build_lang_decl_loc (declarator
11254 ? declarator
->id_loc
11256 VAR_DECL
, unqualified_id
, type
);
11257 set_linkage_for_static_data_member (decl
);
11258 /* Even if there is an in-class initialization, DECL
11259 is considered undefined until an out-of-class
11260 definition is provided. */
11261 DECL_EXTERNAL (decl
) = 1;
11265 CP_DECL_THREAD_LOCAL_P (decl
) = true;
11266 if (!processing_template_decl
)
11267 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
11268 if (declspecs
->gnu_thread_keyword_p
)
11269 SET_DECL_GNU_TLS_P (decl
);
11272 error ("static data member %qE declared %<concept%>",
11274 else if (constexpr_p
&& !initialized
)
11276 error ("constexpr static data member %qD must have an "
11277 "initializer", decl
);
11278 constexpr_p
= false;
11284 error ("non-static data member %qE declared %<concept%>",
11286 else if (constexpr_p
)
11288 error ("non-static data member %qE declared %<constexpr%>",
11290 constexpr_p
= false;
11292 decl
= build_decl (input_location
,
11293 FIELD_DECL
, unqualified_id
, type
);
11294 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11295 if (bitfield
&& !unqualified_id
)
11296 TREE_NO_WARNING (decl
) = 1;
11298 if (storage_class
== sc_mutable
)
11300 DECL_MUTABLE_P (decl
) = 1;
11301 storage_class
= sc_none
;
11306 /* An attempt is being made to initialize a non-static
11307 member. This is new in C++11. */
11308 maybe_warn_cpp0x (CPP0X_NSDMI
);
11310 /* If this has been parsed with static storage class, but
11311 errors forced staticp to be cleared, ensure NSDMI is
11313 if (declspecs
->storage_class
== sc_static
)
11314 DECL_INITIAL (decl
) = error_mark_node
;
11318 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
11319 memfn_quals
!= TYPE_UNQUALIFIED
,
11320 inlinep
, friendp
, raises
!= NULL_TREE
);
11323 else if (TREE_CODE (type
) == FUNCTION_TYPE
11324 || TREE_CODE (type
) == METHOD_TYPE
)
11326 tree original_name
;
11329 if (!unqualified_id
)
11330 return error_mark_node
;
11332 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11333 original_name
= dname
;
11335 original_name
= unqualified_id
;
11337 if (storage_class
== sc_auto
)
11338 error ("storage class %<auto%> invalid for function %qs", name
);
11339 else if (storage_class
== sc_register
)
11340 error ("storage class %<register%> invalid for function %qs", name
);
11343 if (declspecs
->gnu_thread_keyword_p
)
11344 error ("storage class %<__thread%> invalid for function %qs",
11347 error ("storage class %<thread_local%> invalid for function %qs",
11351 if (virt_specifiers
)
11352 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
11353 /* Function declaration not at top level.
11354 Storage classes other than `extern' are not allowed
11355 and `extern' makes no difference. */
11356 if (! toplevel_bindings_p ()
11357 && (storage_class
== sc_static
11358 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
11361 if (storage_class
== sc_static
)
11362 pedwarn (input_location
, OPT_Wpedantic
,
11363 "%<static%> specified invalid for function %qs "
11364 "declared out of global scope", name
);
11366 pedwarn (input_location
, OPT_Wpedantic
,
11367 "%<inline%> specifier invalid for function %qs "
11368 "declared out of global scope", name
);
11371 if (ctype
== NULL_TREE
)
11375 error ("virtual non-class function %qs", name
);
11378 else if (sfk
== sfk_constructor
11379 || sfk
== sfk_destructor
)
11381 error (funcdef_flag
11382 ? G_("%qs defined in a non-class scope")
11383 : G_("%qs declared in a non-class scope"), name
);
11388 /* Record whether the function is public. */
11389 publicp
= (ctype
!= NULL_TREE
11390 || storage_class
!= sc_static
);
11392 if (late_return_type_p
)
11393 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11395 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
11396 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
11399 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11400 initialized
== SD_DELETED
,
11403 template_count
, in_namespace
, attrlist
,
11404 declarator
->id_loc
);
11405 if (decl
== NULL_TREE
)
11406 return error_mark_node
;
11410 int invalid_static
= 0;
11412 /* Don't allow a static member function in a class, and forbid
11413 declaring main to be static. */
11414 if (TREE_CODE (type
) == METHOD_TYPE
)
11416 permerror (input_location
, "cannot declare member function %qD to have "
11417 "static linkage", decl
);
11418 invalid_static
= 1;
11420 else if (current_function_decl
)
11422 /* FIXME need arm citation */
11423 error ("cannot declare static function inside another function");
11424 invalid_static
= 1;
11427 if (invalid_static
)
11430 storage_class
= sc_none
;
11436 /* It's a variable. */
11438 /* An uninitialized decl with `extern' is a reference. */
11439 decl
= grokvardecl (type
, dname
, unqualified_id
,
11442 ((type_quals
& TYPE_QUAL_CONST
) != 0) | (2 * concept_p
),
11444 ctype
? ctype
: in_namespace
);
11445 if (decl
== NULL_TREE
)
11446 return error_mark_node
;
11448 bad_specifiers (decl
, BSP_VAR
, virtualp
,
11449 memfn_quals
!= TYPE_UNQUALIFIED
,
11450 inlinep
, friendp
, raises
!= NULL_TREE
);
11454 DECL_CONTEXT (decl
) = ctype
;
11457 permerror (input_location
, "%<static%> may not be used when defining "
11458 "(as opposed to declaring) a static data member");
11460 storage_class
= sc_none
;
11462 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
11464 error ("static member %qD declared %<register%>", decl
);
11465 storage_class
= sc_none
;
11467 if (storage_class
== sc_extern
&& pedantic
)
11469 pedwarn (input_location
, OPT_Wpedantic
,
11470 "cannot explicitly declare member %q#D to have "
11471 "extern linkage", decl
);
11472 storage_class
= sc_none
;
11475 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
11477 error ("declaration of constexpr variable %qD is not a definition",
11479 constexpr_p
= false;
11483 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
11485 if (toplevel_bindings_p ())
11487 /* It's common practice (and completely valid) to have a const
11488 be initialized and declared extern. */
11489 if (!(type_quals
& TYPE_QUAL_CONST
))
11490 warning (0, "%qs initialized and declared %<extern%>", name
);
11494 error ("%qs has both %<extern%> and initializer", name
);
11495 return error_mark_node
;
11499 /* Record `register' declaration for warnings on &
11500 and in case doing stupid register allocation. */
11502 if (storage_class
== sc_register
)
11503 DECL_REGISTER (decl
) = 1;
11504 else if (storage_class
== sc_extern
)
11505 DECL_THIS_EXTERN (decl
) = 1;
11506 else if (storage_class
== sc_static
)
11507 DECL_THIS_STATIC (decl
) = 1;
11509 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11510 if (constexpr_p
&& VAR_P (decl
))
11511 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
11513 /* Record constancy and volatility on the DECL itself . There's
11514 no need to do this when processing a template; we'll do this
11515 for the instantiated declaration based on the type of DECL. */
11516 if (!processing_template_decl
)
11517 cp_apply_type_quals_to_decl (type_quals
, decl
);
11523 /* Subroutine of start_function. Ensure that each of the parameter
11524 types (as listed in PARMS) is complete, as is required for a
11525 function definition. */
11528 require_complete_types_for_parms (tree parms
)
11530 for (; parms
; parms
= DECL_CHAIN (parms
))
11532 if (dependent_type_p (TREE_TYPE (parms
)))
11534 if (!VOID_TYPE_P (TREE_TYPE (parms
))
11535 && complete_type_or_else (TREE_TYPE (parms
), parms
))
11537 relayout_decl (parms
);
11538 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
11541 /* grokparms or complete_type_or_else will have already issued
11543 TREE_TYPE (parms
) = error_mark_node
;
11547 /* Returns nonzero if T is a local variable. */
11550 local_variable_p (const_tree t
)
11553 /* A VAR_DECL with a context that is a _TYPE is a static data
11555 && !TYPE_P (CP_DECL_CONTEXT (t
))
11556 /* Any other non-local variable must be at namespace scope. */
11557 && !DECL_NAMESPACE_SCOPE_P (t
))
11558 || (TREE_CODE (t
) == PARM_DECL
))
11564 /* Like local_variable_p, but suitable for use as a tree-walking
11568 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
11571 if (local_variable_p (*tp
)
11572 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
11574 else if (TYPE_P (*tp
))
11575 *walk_subtrees
= 0;
11580 /* Check that ARG, which is a default-argument expression for a
11581 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11582 something goes wrong. DECL may also be a _TYPE node, rather than a
11583 DECL, if there is no DECL available. */
11586 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
11591 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11592 /* We get a DEFAULT_ARG when looking at an in-class declaration
11593 with a default argument. Ignore the argument for now; we'll
11594 deal with it after the class is complete. */
11603 decl_type
= TREE_TYPE (decl
);
11605 if (arg
== error_mark_node
11606 || decl
== error_mark_node
11607 || TREE_TYPE (arg
) == error_mark_node
11608 || decl_type
== error_mark_node
)
11609 /* Something already went wrong. There's no need to check
11611 return error_mark_node
;
11613 /* [dcl.fct.default]
11615 A default argument expression is implicitly converted to the
11617 ++cp_unevaluated_operand
;
11618 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
11620 --cp_unevaluated_operand
;
11622 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
11624 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
11625 && null_ptr_cst_p (arg
))
11626 return nullptr_node
;
11628 /* [dcl.fct.default]
11630 Local variables shall not be used in default argument
11633 The keyword `this' shall not be used in a default argument of a
11634 member function. */
11635 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11638 if (complain
& tf_warning_or_error
)
11640 if (DECL_NAME (var
) == this_identifier
)
11641 permerror (input_location
, "default argument %qE uses %qD",
11644 error ("default argument %qE uses local variable %qD", arg
, var
);
11646 return error_mark_node
;
11653 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11656 type_is_deprecated (tree type
)
11658 enum tree_code code
;
11659 if (TREE_DEPRECATED (type
))
11661 if (TYPE_NAME (type
))
11663 if (TREE_DEPRECATED (TYPE_NAME (type
)))
11669 /* Do warn about using typedefs to a deprecated class. */
11670 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11671 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11673 code
= TREE_CODE (type
);
11675 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11676 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11677 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11678 return type_is_deprecated (TREE_TYPE (type
));
11680 if (TYPE_PTRMEMFUNC_P (type
))
11681 return type_is_deprecated
11682 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11687 /* Decode the list of parameter types for a function type.
11688 Given the list of things declared inside the parens,
11689 return a list of types.
11691 If this parameter does not end with an ellipsis, we append
11694 *PARMS is set to the chain of PARM_DECLs created. */
11697 grokparms (tree parmlist
, tree
*parms
)
11699 tree result
= NULL_TREE
;
11700 tree decls
= NULL_TREE
;
11704 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11706 tree type
= NULL_TREE
;
11707 tree init
= TREE_PURPOSE (parm
);
11708 tree decl
= TREE_VALUE (parm
);
11709 const char *errmsg
;
11711 if (parm
== void_list_node
)
11714 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11717 type
= TREE_TYPE (decl
);
11718 if (VOID_TYPE_P (type
))
11720 if (same_type_p (type
, void_type_node
)
11722 && !DECL_NAME (decl
) && !result
11723 && TREE_CHAIN (parm
) == void_list_node
)
11724 /* DR 577: A parameter list consisting of a single
11725 unnamed parameter of non-dependent type 'void'. */
11727 else if (cv_qualified_p (type
))
11728 error_at (DECL_SOURCE_LOCATION (decl
),
11729 "invalid use of cv-qualified type %qT in "
11730 "parameter declaration", type
);
11732 error_at (DECL_SOURCE_LOCATION (decl
),
11733 "invalid use of type %<void%> in parameter "
11735 /* It's not a good idea to actually create parameters of
11736 type `void'; other parts of the compiler assume that a
11737 void type terminates the parameter list. */
11738 type
= error_mark_node
;
11739 TREE_TYPE (decl
) = error_mark_node
;
11742 if (type
!= error_mark_node
11743 && TYPE_FOR_JAVA (type
)
11744 && MAYBE_CLASS_TYPE_P (type
))
11746 error ("parameter %qD has Java class type", decl
);
11747 type
= error_mark_node
;
11748 TREE_TYPE (decl
) = error_mark_node
;
11752 if (type
!= error_mark_node
11753 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11756 type
= error_mark_node
;
11757 TREE_TYPE (decl
) = error_mark_node
;
11760 if (type
!= error_mark_node
)
11762 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11764 tree deptype
= type_is_deprecated (type
);
11766 warn_deprecated_use (deptype
, NULL_TREE
);
11769 /* Top-level qualifiers on the parameters are
11770 ignored for function types. */
11771 type
= cp_build_qualified_type (type
, 0);
11772 if (TREE_CODE (type
) == METHOD_TYPE
)
11774 error ("parameter %qD invalidly declared method type", decl
);
11775 type
= build_pointer_type (type
);
11776 TREE_TYPE (decl
) = type
;
11778 else if (abstract_virtuals_error (decl
, type
))
11779 any_error
= 1; /* Seems like a good idea. */
11780 else if (POINTER_TYPE_P (type
))
11782 /* [dcl.fct]/6, parameter types cannot contain pointers
11783 (references) to arrays of unknown bound. */
11784 tree t
= TREE_TYPE (type
);
11785 int ptr
= TYPE_PTR_P (type
);
11789 if (TYPE_PTR_P (t
))
11791 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11793 else if (!TYPE_DOMAIN (t
))
11797 if (TREE_CODE (t
) == ARRAY_TYPE
)
11799 ? G_("parameter %qD includes pointer to array of "
11800 "unknown bound %qT")
11801 : G_("parameter %qD includes reference to array of "
11802 "unknown bound %qT"),
11808 else if (init
&& !processing_template_decl
)
11809 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11812 DECL_CHAIN (decl
) = decls
;
11814 result
= tree_cons (init
, type
, result
);
11816 decls
= nreverse (decls
);
11817 result
= nreverse (result
);
11819 result
= chainon (result
, void_list_node
);
11826 /* D is a constructor or overloaded `operator='.
11828 Let T be the class in which D is declared. Then, this function
11831 -1 if D's is an ill-formed constructor or copy assignment operator
11832 whose first parameter is of type `T'.
11833 0 if D is not a copy constructor or copy assignment
11835 1 if D is a copy constructor or copy assignment operator whose
11836 first parameter is a reference to non-const qualified T.
11837 2 if D is a copy constructor or copy assignment operator whose
11838 first parameter is a reference to const qualified T.
11840 This function can be used as a predicate. Positive values indicate
11841 a copy constructor and nonzero values indicate a copy assignment
11845 copy_fn_p (const_tree d
)
11851 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11853 if (TREE_CODE (d
) == TEMPLATE_DECL
11854 || (DECL_TEMPLATE_INFO (d
)
11855 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11856 /* Instantiations of template member functions are never copy
11857 functions. Note that member functions of templated classes are
11858 represented as template functions internally, and we must
11859 accept those as copy functions. */
11862 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11866 arg_type
= TREE_VALUE (args
);
11867 if (arg_type
== error_mark_node
)
11870 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11872 /* Pass by value copy assignment operator. */
11875 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11876 && !TYPE_REF_IS_RVALUE (arg_type
)
11877 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11879 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11885 args
= TREE_CHAIN (args
);
11887 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11888 /* There are more non-optional args. */
11894 /* D is a constructor or overloaded `operator='.
11896 Let T be the class in which D is declared. Then, this function
11897 returns true when D is a move constructor or move assignment
11898 operator, false otherwise. */
11901 move_fn_p (const_tree d
)
11903 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11905 if (cxx_dialect
== cxx98
)
11906 /* There are no move constructors if we are in C++98 mode. */
11909 if (TREE_CODE (d
) == TEMPLATE_DECL
11910 || (DECL_TEMPLATE_INFO (d
)
11911 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11912 /* Instantiations of template member functions are never move
11913 functions. Note that member functions of templated classes are
11914 represented as template functions internally, and we must
11915 accept those as move functions. */
11918 return move_signature_fn_p (d
);
11921 /* D is a constructor or overloaded `operator='.
11923 Then, this function returns true when D has the same signature as a move
11924 constructor or move assignment operator (because either it is such a
11925 ctor/op= or it is a template specialization with the same signature),
11926 false otherwise. */
11929 move_signature_fn_p (const_tree d
)
11933 bool result
= false;
11935 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11939 arg_type
= TREE_VALUE (args
);
11940 if (arg_type
== error_mark_node
)
11943 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11944 && TYPE_REF_IS_RVALUE (arg_type
)
11945 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11949 args
= TREE_CHAIN (args
);
11951 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11952 /* There are more non-optional args. */
11958 /* Remember any special properties of member function DECL. */
11961 grok_special_member_properties (tree decl
)
11965 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11968 class_type
= DECL_CONTEXT (decl
);
11969 if (DECL_CONSTRUCTOR_P (decl
))
11971 int ctor
= copy_fn_p (decl
);
11973 if (!DECL_ARTIFICIAL (decl
))
11974 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11980 A non-template constructor for class X is a copy
11981 constructor if its first parameter is of type X&, const
11982 X&, volatile X& or const volatile X&, and either there
11983 are no other parameters or else all other parameters have
11984 default arguments. */
11985 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11986 if (user_provided_p (decl
))
11987 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11989 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11991 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11992 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11993 else if (move_fn_p (decl
) && user_provided_p (decl
))
11994 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11995 else if (is_list_ctor (decl
))
11996 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11998 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11999 && !copy_fn_p (decl
) && !move_fn_p (decl
))
12000 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
12002 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
12006 A non-template assignment operator for class X is a copy
12007 assignment operator if its parameter is of type X, X&, const
12008 X&, volatile X& or const volatile X&. */
12010 int assop
= copy_fn_p (decl
);
12014 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
12015 if (user_provided_p (decl
))
12016 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
12018 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
12020 else if (move_fn_p (decl
) && user_provided_p (decl
))
12021 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
12023 /* Destructors are handled in check_methods. */
12026 /* Check a constructor DECL has the correct form. Complains
12027 if the class has a constructor of the form X(X). */
12030 grok_ctor_properties (const_tree ctype
, const_tree decl
)
12032 int ctor_parm
= copy_fn_p (decl
);
12038 A declaration of a constructor for a class X is ill-formed if
12039 its first parameter is of type (optionally cv-qualified) X
12040 and either there are no other parameters or else all other
12041 parameters have default arguments.
12043 We *don't* complain about member template instantiations that
12044 have this form, though; they can occur as we try to decide
12045 what constructor to use during overload resolution. Since
12046 overload resolution will never prefer such a constructor to
12047 the non-template copy constructor (which is either explicitly
12048 or implicitly defined), there's no need to worry about their
12049 existence. Theoretically, they should never even be
12050 instantiated, but that's hard to forestall. */
12051 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
12059 /* An operator with this code is unary, but can also be binary. */
12062 ambi_op_p (enum tree_code code
)
12064 return (code
== INDIRECT_REF
12065 || code
== ADDR_EXPR
12066 || code
== UNARY_PLUS_EXPR
12067 || code
== NEGATE_EXPR
12068 || code
== PREINCREMENT_EXPR
12069 || code
== PREDECREMENT_EXPR
);
12072 /* An operator with this name can only be unary. */
12075 unary_op_p (enum tree_code code
)
12077 return (code
== TRUTH_NOT_EXPR
12078 || code
== BIT_NOT_EXPR
12079 || code
== COMPONENT_REF
12080 || code
== TYPE_EXPR
);
12083 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
12084 errors are issued for invalid declarations. */
12087 grok_op_properties (tree decl
, bool complain
)
12089 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12091 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
12092 tree name
= DECL_NAME (decl
);
12093 enum tree_code operator_code
;
12098 /* Count the number of arguments and check for ellipsis. */
12099 for (argtype
= argtypes
, arity
= 0;
12100 argtype
&& argtype
!= void_list_node
;
12101 argtype
= TREE_CHAIN (argtype
))
12103 ellipsis_p
= !argtype
;
12105 class_type
= DECL_CONTEXT (decl
);
12106 if (class_type
&& !CLASS_TYPE_P (class_type
))
12107 class_type
= NULL_TREE
;
12109 if (DECL_CONV_FN_P (decl
))
12110 operator_code
= TYPE_EXPR
;
12114 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12115 if (ansi_opname (CODE) == name) \
12117 operator_code = (CODE); \
12120 else if (ansi_assopname (CODE) == name) \
12122 operator_code = (CODE); \
12123 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12127 #include "operators.def"
12128 #undef DEF_OPERATOR
12130 gcc_unreachable ();
12133 gcc_assert (operator_code
!= MAX_TREE_CODES
);
12134 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12137 switch (operator_code
)
12140 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
12144 TYPE_GETS_DELETE (class_type
) |= 1;
12148 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
12151 case VEC_DELETE_EXPR
:
12152 TYPE_GETS_DELETE (class_type
) |= 2;
12159 /* [basic.std.dynamic.allocation]/1:
12161 A program is ill-formed if an allocation function is declared
12162 in a namespace scope other than global scope or declared static
12165 The same also holds true for deallocation functions. */
12166 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
12167 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12169 if (DECL_NAMESPACE_SCOPE_P (decl
))
12171 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
12173 error ("%qD may not be declared within a namespace", decl
);
12176 else if (!TREE_PUBLIC (decl
))
12178 error ("%qD may not be declared as static", decl
);
12184 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12186 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12187 DECL_IS_OPERATOR_NEW (decl
) = 1;
12189 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12190 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12193 /* An operator function must either be a non-static member function
12194 or have at least one parameter of a class, a reference to a class,
12195 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12196 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12198 if (operator_code
== TYPE_EXPR
12199 || operator_code
== CALL_EXPR
12200 || operator_code
== COMPONENT_REF
12201 || operator_code
== ARRAY_REF
12202 || operator_code
== NOP_EXPR
)
12204 error ("%qD must be a nonstatic member function", decl
);
12211 if (DECL_STATIC_FUNCTION_P (decl
))
12213 error ("%qD must be either a non-static member "
12214 "function or a non-member function", decl
);
12218 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
12220 tree arg
= non_reference (TREE_VALUE (p
));
12221 if (arg
== error_mark_node
)
12224 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
12225 because these checks are performed even on
12226 template functions. */
12227 if (MAYBE_CLASS_TYPE_P (arg
)
12228 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
12232 if (!p
|| p
== void_list_node
)
12235 error ("%qD must have an argument of class or "
12236 "enumerated type", decl
);
12242 /* There are no restrictions on the arguments to an overloaded
12244 if (operator_code
== CALL_EXPR
)
12247 /* Warn about conversion operators that will never be used. */
12248 if (IDENTIFIER_TYPENAME_P (name
)
12249 && ! DECL_TEMPLATE_INFO (decl
)
12251 /* Warn only declaring the function; there is no need to
12252 warn again about out-of-class definitions. */
12253 && class_type
== current_class_type
)
12255 tree t
= TREE_TYPE (name
);
12256 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12259 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12261 if (VOID_TYPE_P (t
))
12262 warning (OPT_Wconversion
,
12264 ? G_("conversion to a reference to void "
12265 "will never use a type conversion operator")
12266 : G_("conversion to void "
12267 "will never use a type conversion operator"));
12268 else if (class_type
)
12270 if (t
== class_type
)
12271 warning (OPT_Wconversion
,
12273 ? G_("conversion to a reference to the same type "
12274 "will never use a type conversion operator")
12275 : G_("conversion to the same type "
12276 "will never use a type conversion operator"));
12277 /* Don't force t to be complete here. */
12278 else if (MAYBE_CLASS_TYPE_P (t
)
12279 && COMPLETE_TYPE_P (t
)
12280 && DERIVED_FROM_P (t
, class_type
))
12281 warning (OPT_Wconversion
,
12283 ? G_("conversion to a reference to a base class "
12284 "will never use a type conversion operator")
12285 : G_("conversion to a base class "
12286 "will never use a type conversion operator"));
12291 if (operator_code
== COND_EXPR
)
12294 error ("ISO C++ prohibits overloading operator ?:");
12297 else if (ellipsis_p
)
12299 error ("%qD must not have variable number of arguments", decl
);
12302 else if (ambi_op_p (operator_code
))
12305 /* We pick the one-argument operator codes by default, so
12306 we don't have to change anything. */
12308 else if (arity
== 2)
12310 /* If we thought this was a unary operator, we now know
12311 it to be a binary operator. */
12312 switch (operator_code
)
12315 operator_code
= MULT_EXPR
;
12319 operator_code
= BIT_AND_EXPR
;
12322 case UNARY_PLUS_EXPR
:
12323 operator_code
= PLUS_EXPR
;
12327 operator_code
= MINUS_EXPR
;
12330 case PREINCREMENT_EXPR
:
12331 operator_code
= POSTINCREMENT_EXPR
;
12334 case PREDECREMENT_EXPR
:
12335 operator_code
= POSTDECREMENT_EXPR
;
12339 gcc_unreachable ();
12342 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12344 if ((operator_code
== POSTINCREMENT_EXPR
12345 || operator_code
== POSTDECREMENT_EXPR
)
12346 && ! processing_template_decl
12347 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12350 error ("postfix %qD must take %<int%> as its argument",
12353 error ("postfix %qD must take %<int%> as its second "
12361 error ("%qD must take either zero or one argument", decl
);
12363 error ("%qD must take either one or two arguments", decl
);
12367 /* More Effective C++ rule 6. */
12369 && (operator_code
== POSTINCREMENT_EXPR
12370 || operator_code
== POSTDECREMENT_EXPR
12371 || operator_code
== PREINCREMENT_EXPR
12372 || operator_code
== PREDECREMENT_EXPR
))
12374 tree arg
= TREE_VALUE (argtypes
);
12375 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12376 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12377 arg
= TREE_TYPE (arg
);
12378 arg
= TYPE_MAIN_VARIANT (arg
);
12379 if (operator_code
== PREINCREMENT_EXPR
12380 || operator_code
== PREDECREMENT_EXPR
)
12382 if (TREE_CODE (ret
) != REFERENCE_TYPE
12383 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12385 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
12386 build_reference_type (arg
));
12390 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12391 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
12395 else if (unary_op_p (operator_code
))
12400 error ("%qD must take %<void%>", decl
);
12402 error ("%qD must take exactly one argument", decl
);
12406 else /* if (binary_op_p (operator_code)) */
12411 error ("%qD must take exactly one argument", decl
);
12413 error ("%qD must take exactly two arguments", decl
);
12417 /* More Effective C++ rule 7. */
12419 && (operator_code
== TRUTH_ANDIF_EXPR
12420 || operator_code
== TRUTH_ORIF_EXPR
12421 || operator_code
== COMPOUND_EXPR
))
12422 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
12426 /* Effective C++ rule 23. */
12429 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
12430 && (operator_code
== PLUS_EXPR
12431 || operator_code
== MINUS_EXPR
12432 || operator_code
== TRUNC_DIV_EXPR
12433 || operator_code
== MULT_EXPR
12434 || operator_code
== TRUNC_MOD_EXPR
)
12435 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12436 warning (OPT_Weffc__
, "%qD should return by value", decl
);
12438 /* [over.oper]/8 */
12439 for (; argtypes
&& argtypes
!= void_list_node
;
12440 argtypes
= TREE_CHAIN (argtypes
))
12441 if (TREE_PURPOSE (argtypes
))
12443 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12444 if (operator_code
== POSTINCREMENT_EXPR
12445 || operator_code
== POSTDECREMENT_EXPR
)
12447 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
12452 error ("%qD cannot have default arguments", decl
);
12460 /* Return a string giving the keyword associate with CODE. */
12462 static const char *
12463 tag_name (enum tag_types code
)
12475 case typename_type
:
12478 gcc_unreachable ();
12482 /* Name lookup in an elaborated-type-specifier (after the keyword
12483 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12484 elaborated-type-specifier is invalid, issue a diagnostic and return
12485 error_mark_node; otherwise, return the *_TYPE to which it referred.
12486 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12489 check_elaborated_type_specifier (enum tag_types tag_code
,
12491 bool allow_template_p
)
12497 struct S { struct S *p; };
12499 name lookup will find the TYPE_DECL for the implicit "S::S"
12500 typedef. Adjust for that here. */
12501 if (DECL_SELF_REFERENCE_P (decl
))
12502 decl
= TYPE_NAME (TREE_TYPE (decl
));
12504 type
= TREE_TYPE (decl
);
12506 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12507 is false for this case as well. */
12508 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12510 error ("using template type parameter %qT after %qs",
12511 type
, tag_name (tag_code
));
12512 return error_mark_node
;
12514 /* Accept template template parameters. */
12515 else if (allow_template_p
12516 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
12517 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
12521 If the identifier resolves to a typedef-name or the
12522 simple-template-id resolves to an alias template
12523 specialization, the elaborated-type-specifier is ill-formed.
12525 In other words, the only legitimate declaration to use in the
12526 elaborated type specifier is the implicit typedef created when
12527 the type is declared. */
12528 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
12529 && !DECL_SELF_REFERENCE_P (decl
)
12530 && tag_code
!= typename_type
)
12532 if (alias_template_specialization_p (type
))
12533 error ("using alias template specialization %qT after %qs",
12534 type
, tag_name (tag_code
));
12536 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
12537 inform (DECL_SOURCE_LOCATION (decl
),
12538 "%qD has a previous declaration here", decl
);
12539 return error_mark_node
;
12541 else if (TREE_CODE (type
) != RECORD_TYPE
12542 && TREE_CODE (type
) != UNION_TYPE
12543 && tag_code
!= enum_type
12544 && tag_code
!= typename_type
)
12546 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
12547 inform (input_location
, "%q+T has a previous declaration here", type
);
12548 return error_mark_node
;
12550 else if (TREE_CODE (type
) != ENUMERAL_TYPE
12551 && tag_code
== enum_type
)
12553 error ("%qT referred to as enum", type
);
12554 inform (input_location
, "%q+T has a previous declaration here", type
);
12555 return error_mark_node
;
12557 else if (!allow_template_p
12558 && TREE_CODE (type
) == RECORD_TYPE
12559 && CLASSTYPE_IS_TEMPLATE (type
))
12561 /* If a class template appears as elaborated type specifier
12562 without a template header such as:
12564 template <class T> class C {};
12565 void f(class C); // No template header here
12567 then the required template argument is missing. */
12568 error ("template argument required for %<%s %T%>",
12569 tag_name (tag_code
),
12570 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
12571 return error_mark_node
;
12577 /* Lookup NAME in elaborate type specifier in scope according to
12578 SCOPE and issue diagnostics if necessary.
12579 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12580 found, and ERROR_MARK_NODE for type error. */
12583 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
12584 tag_scope scope
, bool template_header_p
)
12588 if (scope
== ts_global
)
12590 /* First try ordinary name lookup, ignoring hidden class name
12591 injected via friend declaration. */
12592 decl
= lookup_name_prefer_type (name
, 2);
12593 decl
= strip_using_decl (decl
);
12594 /* If that fails, the name will be placed in the smallest
12595 non-class, non-function-prototype scope according to 3.3.1/5.
12596 We may already have a hidden name declared as friend in this
12597 scope. So lookup again but not ignoring hidden names.
12598 If we find one, that name will be made visible rather than
12599 creating a new tag. */
12601 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
12604 decl
= lookup_type_scope (name
, scope
);
12607 && (DECL_CLASS_TEMPLATE_P (decl
)
12608 /* If scope is ts_current we're defining a class, so ignore a
12609 template template parameter. */
12610 || (scope
!= ts_current
12611 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
12612 decl
= DECL_TEMPLATE_RESULT (decl
);
12614 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
12616 /* Look for invalid nested type:
12620 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
12622 error ("%qD has the same name as the class in which it is "
12625 return error_mark_node
;
12628 /* Two cases we need to consider when deciding if a class
12629 template is allowed as an elaborated type specifier:
12630 1. It is a self reference to its own class.
12631 2. It comes with a template header.
12635 template <class T> class C {
12636 class C *c1; // DECL_SELF_REFERENCE_P is true
12639 template <class U> class C; // template_header_p is true
12640 template <class T> class C<T>::D {
12641 class C *c2; // DECL_SELF_REFERENCE_P is true
12644 t
= check_elaborated_type_specifier (tag_code
,
12647 | DECL_SELF_REFERENCE_P (decl
));
12648 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
12649 && (!CLASSTYPE_TEMPLATE_INFO (t
)
12650 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
12652 error ("%qT is not a template", t
);
12653 inform (location_of (t
), "previous declaration here");
12654 if (TYPE_CLASS_SCOPE_P (t
)
12655 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
12656 inform (input_location
,
12657 "perhaps you want to explicitly add %<%T::%>",
12659 t
= error_mark_node
;
12664 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12666 error ("reference to %qD is ambiguous", name
);
12667 print_candidates (decl
);
12668 return error_mark_node
;
12674 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12675 Define the tag as a forward-reference if it is not defined.
12677 If a declaration is given, process it here, and report an error if
12678 multiple declarations are not identical.
12680 SCOPE is TS_CURRENT when this is also a definition. Only look in
12681 the current frame for the name (since C++ allows new names in any
12682 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12683 declaration. Only look beginning from the current scope outward up
12684 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12686 TEMPLATE_HEADER_P is true when this declaration is preceded by
12687 a set of template parameters. */
12690 xref_tag_1 (enum tag_types tag_code
, tree name
,
12691 tag_scope orig_scope
, bool template_header_p
)
12693 enum tree_code code
;
12695 tree context
= NULL_TREE
;
12698 gcc_assert (identifier_p (name
));
12704 code
= RECORD_TYPE
;
12710 code
= ENUMERAL_TYPE
;
12713 gcc_unreachable ();
12716 if (orig_scope
== ts_lambda
)
12717 scope
= ts_current
;
12719 scope
= orig_scope
;
12721 /* In case of anonymous name, xref_tag is only called to
12722 make type node and push name. Name lookup is not required. */
12723 if (anon_aggrname_p (name
))
12726 t
= lookup_and_check_tag (tag_code
, name
,
12727 scope
, template_header_p
);
12729 if (t
== error_mark_node
)
12730 return error_mark_node
;
12732 if (scope
!= ts_current
&& t
&& current_class_type
12733 && template_class_depth (current_class_type
)
12734 && template_header_p
)
12736 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12739 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12740 definition of this tag. Since, in addition, we are currently
12741 processing a (member) template declaration of a template
12742 class, we must be very careful; consider:
12749 { template <class V>
12750 friend struct S1; };
12752 Here, the S2::S1 declaration should not be confused with the
12753 outer declaration. In particular, the inner version should
12754 have a template parameter of level 2, not level 1. This
12755 would be particularly important if the member declaration
12758 template <class V = U> friend struct S1;
12760 say, when we should tsubst into `U' when instantiating
12761 S2. On the other hand, when presented with:
12771 we must find the inner binding eventually. We
12772 accomplish this by making sure that the new type we
12773 create to represent this declaration has the right
12775 context
= TYPE_CONTEXT (t
);
12781 /* If no such tag is yet defined, create a forward-reference node
12782 and record it as the "definition".
12783 When a real declaration of this type is found,
12784 the forward-reference will be altered into a real type. */
12785 if (code
== ENUMERAL_TYPE
)
12787 error ("use of enum %q#D without previous declaration", name
);
12788 return error_mark_node
;
12792 t
= make_class_type (code
);
12793 TYPE_CONTEXT (t
) = context
;
12794 if (orig_scope
== ts_lambda
)
12795 /* Remember that we're declaring a lambda to avoid bogus errors
12796 in push_template_decl. */
12797 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12798 t
= pushtag (name
, t
, scope
);
12803 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12805 /* Check that we aren't trying to overload a class with different
12807 tree constr
= NULL_TREE
;
12808 if (current_template_parms
)
12810 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
12811 constr
= build_constraints (reqs
, NULL_TREE
);
12813 if (!redeclare_class_template (t
, current_template_parms
, constr
))
12814 return error_mark_node
;
12816 else if (!processing_template_decl
12817 && CLASS_TYPE_P (t
)
12818 && CLASSTYPE_IS_TEMPLATE (t
))
12820 error ("redeclaration of %qT as a non-template", t
);
12821 error ("previous declaration %q+D", t
);
12822 return error_mark_node
;
12825 /* Make injected friend class visible. */
12826 if (scope
!= ts_within_enclosing_non_class
12827 && hidden_name_p (TYPE_NAME (t
)))
12829 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12830 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12832 if (TYPE_TEMPLATE_INFO (t
))
12834 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12835 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12843 /* Wrapper for xref_tag_1. */
12846 xref_tag (enum tag_types tag_code
, tree name
,
12847 tag_scope scope
, bool template_header_p
)
12851 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12852 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12853 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12859 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12861 enum tag_types tag_kind
;
12863 if (TREE_CODE (old
) == RECORD_TYPE
)
12864 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12866 tag_kind
= union_type
;
12868 if (id
== NULL_TREE
)
12869 id
= TYPE_IDENTIFIER (old
);
12871 return xref_tag (tag_kind
, id
, scope
, false);
12874 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12875 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12876 access_* node, and the TREE_VALUE is the type of the base-class.
12877 Non-NULL TREE_TYPE indicates virtual inheritance.
12879 Returns true if the binfo hierarchy was successfully created,
12880 false if an error was detected. */
12883 xref_basetypes (tree ref
, tree base_list
)
12886 tree binfo
, base_binfo
;
12887 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12888 unsigned max_bases
= 0; /* Maximum direct bases. */
12889 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
12891 tree default_access
;
12892 tree igo_prev
; /* Track Inheritance Graph Order. */
12894 if (ref
== error_mark_node
)
12897 /* The base of a derived class is private by default, all others are
12899 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12900 && CLASSTYPE_DECLARED_CLASS (ref
)
12901 ? access_private_node
: access_public_node
);
12903 /* First, make sure that any templates in base-classes are
12904 instantiated. This ensures that if we call ourselves recursively
12905 we do not get confused about which classes are marked and which
12907 basep
= &base_list
;
12910 tree basetype
= TREE_VALUE (*basep
);
12912 /* The dependent_type_p call below should really be dependent_scope_p
12913 so that we give a hard error about using an incomplete type as a
12914 base, but we allow it with a pedwarn for backward
12916 if (processing_template_decl
12917 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12918 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12919 if (!dependent_type_p (basetype
)
12920 && !complete_type_or_else (basetype
, NULL
))
12921 /* An incomplete type. Remove it from the list. */
12922 *basep
= TREE_CHAIN (*basep
);
12926 if (TREE_TYPE (*basep
))
12928 if (CLASS_TYPE_P (basetype
))
12929 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12930 basep
= &TREE_CHAIN (*basep
);
12933 max_vbases
+= max_dvbases
;
12935 TYPE_MARKED_P (ref
) = 1;
12937 /* The binfo slot should be empty, unless this is an (ill-formed)
12939 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12941 error ("redefinition of %q#T", ref
);
12945 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12947 binfo
= make_tree_binfo (max_bases
);
12949 TYPE_BINFO (ref
) = binfo
;
12950 BINFO_OFFSET (binfo
) = size_zero_node
;
12951 BINFO_TYPE (binfo
) = ref
;
12953 /* Apply base-class info set up to the variants of this type. */
12954 fixup_type_variants (ref
);
12958 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12959 /* An aggregate cannot have baseclasses. */
12960 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12962 if (TREE_CODE (ref
) == UNION_TYPE
)
12964 error ("derived union %qT invalid", ref
);
12971 if (TYPE_FOR_JAVA (ref
))
12973 error ("Java class %qT cannot have multiple bases", ref
);
12977 warning (OPT_Wmultiple_inheritance
,
12978 "%qT defined with multiple direct bases", ref
);
12983 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12985 if (TYPE_FOR_JAVA (ref
))
12987 error ("Java class %qT cannot have virtual bases", ref
);
12990 else if (max_dvbases
)
12991 warning (OPT_Wvirtual_inheritance
,
12992 "%qT defined with direct virtual base", ref
);
12995 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12997 tree access
= TREE_PURPOSE (base_list
);
12998 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12999 tree basetype
= TREE_VALUE (base_list
);
13001 if (access
== access_default_node
)
13002 access
= default_access
;
13004 if (PACK_EXPANSION_P (basetype
))
13005 basetype
= PACK_EXPANSION_PATTERN (basetype
);
13006 if (TREE_CODE (basetype
) == TYPE_DECL
)
13007 basetype
= TREE_TYPE (basetype
);
13008 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
13010 error ("base type %qT fails to be a struct or class type",
13015 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
13016 TYPE_FOR_JAVA (ref
) = 1;
13018 base_binfo
= NULL_TREE
;
13019 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
13021 base_binfo
= TYPE_BINFO (basetype
);
13022 /* The original basetype could have been a typedef'd type. */
13023 basetype
= BINFO_TYPE (base_binfo
);
13025 /* Inherit flags from the base. */
13026 TYPE_HAS_NEW_OPERATOR (ref
)
13027 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13028 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13029 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13030 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13031 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
13032 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
13033 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
13034 CLASSTYPE_REPEATED_BASE_P (ref
)
13035 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
13038 /* We must do this test after we've seen through a typedef
13040 if (TYPE_MARKED_P (basetype
))
13042 if (basetype
== ref
)
13043 error ("recursive type %qT undefined", basetype
);
13045 error ("duplicate base type %qT invalid", basetype
);
13049 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
13050 /* Regenerate the pack expansion for the bases. */
13051 basetype
= make_pack_expansion (basetype
);
13053 TYPE_MARKED_P (basetype
) = 1;
13055 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
13056 &igo_prev
, via_virtual
);
13057 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
13058 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
13060 BINFO_BASE_APPEND (binfo
, base_binfo
);
13061 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
13064 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
13065 /* If we didn't get max_vbases vbases, we must have shared at
13066 least one of them, and are therefore diamond shaped. */
13067 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
13069 /* Unmark all the types. */
13070 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
13071 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13072 TYPE_MARKED_P (ref
) = 0;
13074 /* Now see if we have a repeated base type. */
13075 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
13077 for (base_binfo
= binfo
; base_binfo
;
13078 base_binfo
= TREE_CHAIN (base_binfo
))
13080 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13082 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
13085 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
13087 for (base_binfo
= binfo
; base_binfo
;
13088 base_binfo
= TREE_CHAIN (base_binfo
))
13089 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13090 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13099 /* Copies the enum-related properties from type SRC to type DST.
13100 Used with the underlying type of an enum and the enum itself. */
13102 copy_type_enum (tree dst
, tree src
)
13105 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
13107 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
13108 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
13109 TYPE_SIZE (t
) = TYPE_SIZE (src
);
13110 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
13111 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
13112 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
13113 unsigned valign
= TYPE_ALIGN (src
);
13114 if (TYPE_USER_ALIGN (t
))
13115 valign
= MAX (valign
, TYPE_ALIGN (t
));
13117 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
13118 SET_TYPE_ALIGN (t
, valign
);
13119 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
13123 /* Begin compiling the definition of an enumeration type.
13126 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
13128 UNDERLYING_TYPE is the type that will be used as the storage for
13129 the enumeration type. This should be NULL_TREE if no storage type
13132 ATTRIBUTES are any attributes specified after the enum-key.
13134 SCOPED_ENUM_P is true if this is a scoped enumeration type.
13136 if IS_NEW is not NULL, gets TRUE iff a new type is created.
13138 Returns the type object, as yet incomplete.
13139 Also records info about it so that build_enumerator
13140 may be used to declare the individual values as they are read. */
13143 start_enum (tree name
, tree enumtype
, tree underlying_type
,
13144 tree attributes
, bool scoped_enum_p
, bool *is_new
)
13146 tree prevtype
= NULL_TREE
;
13147 gcc_assert (identifier_p (name
));
13151 /* [C++0x dcl.enum]p5:
13153 If not explicitly specified, the underlying type of a scoped
13154 enumeration type is int. */
13155 if (!underlying_type
&& scoped_enum_p
)
13156 underlying_type
= integer_type_node
;
13158 if (underlying_type
)
13159 underlying_type
= cv_unqualified (underlying_type
);
13161 /* If this is the real definition for a previous forward reference,
13162 fill in the contents in the same object that used to be the
13163 forward reference. */
13165 enumtype
= lookup_and_check_tag (enum_type
, name
,
13166 /*tag_scope=*/ts_current
,
13167 /*template_header_p=*/false);
13169 /* In case of a template_decl, the only check that should be deferred
13170 to instantiation time is the comparison of underlying types. */
13171 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13173 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
13175 error_at (input_location
, "scoped/unscoped mismatch "
13176 "in enum %q#T", enumtype
);
13177 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13178 "previous definition here");
13179 enumtype
= error_mark_node
;
13181 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
13183 error_at (input_location
, "underlying type mismatch "
13184 "in enum %q#T", enumtype
);
13185 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13186 "previous definition here");
13187 enumtype
= error_mark_node
;
13189 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
13190 && !dependent_type_p (underlying_type
)
13191 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
13192 && !same_type_p (underlying_type
,
13193 ENUM_UNDERLYING_TYPE (enumtype
)))
13195 error_at (input_location
, "different underlying type "
13196 "in enum %q#T", enumtype
);
13197 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13198 "previous definition here");
13199 underlying_type
= NULL_TREE
;
13203 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
13204 || processing_template_decl
)
13206 /* In case of error, make a dummy enum to allow parsing to
13208 if (enumtype
== error_mark_node
)
13210 name
= make_anon_name ();
13211 enumtype
= NULL_TREE
;
13214 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
13215 of an opaque enum, or an opaque enum of an already defined
13216 enumeration (C++0x only).
13217 In any other case, it'll be NULL_TREE. */
13223 prevtype
= enumtype
;
13225 /* Do not push the decl more than once, unless we need to
13226 compare underlying types at instantiation time */
13228 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
13229 || (underlying_type
13230 && dependent_type_p (underlying_type
))
13231 || (ENUM_UNDERLYING_TYPE (enumtype
)
13232 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
13234 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
13235 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
13238 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
13241 if (enumtype
== error_mark_node
)
13242 return error_mark_node
;
13244 /* The enum is considered opaque until the opening '{' of the
13245 enumerator list. */
13246 SET_OPAQUE_ENUM_P (enumtype
, true);
13247 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
13250 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
13252 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
13254 if (underlying_type
)
13256 if (ENUM_UNDERLYING_TYPE (enumtype
))
13257 /* We already checked that it matches, don't change it to a different
13258 typedef variant. */;
13259 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
13261 copy_type_enum (enumtype
, underlying_type
);
13262 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13264 else if (dependent_type_p (underlying_type
))
13265 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13267 error ("underlying type %<%T%> of %<%T%> must be an integral type",
13268 underlying_type
, enumtype
);
13271 /* If into a template class, the returned enum is always the first
13272 declaration (opaque or not) seen. This way all the references to
13273 this type will be to the same declaration. The following ones are used
13274 only to check for definition errors. */
13275 if (prevtype
&& processing_template_decl
)
13281 /* After processing and defining all the values of an enumeration type,
13282 install their decls in the enumeration type.
13283 ENUMTYPE is the type object. */
13286 finish_enum_value_list (tree enumtype
)
13289 tree underlying_type
;
13292 tree minnode
, maxnode
;
13295 bool fixed_underlying_type_p
13296 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
13298 /* We built up the VALUES in reverse order. */
13299 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
13301 /* For an enum defined in a template, just set the type of the values;
13302 all further processing is postponed until the template is
13303 instantiated. We need to set the type so that tsubst of a CONST_DECL
13305 if (processing_template_decl
)
13307 for (values
= TYPE_VALUES (enumtype
);
13309 values
= TREE_CHAIN (values
))
13310 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
13314 /* Determine the minimum and maximum values of the enumerators. */
13315 if (TYPE_VALUES (enumtype
))
13317 minnode
= maxnode
= NULL_TREE
;
13319 for (values
= TYPE_VALUES (enumtype
);
13321 values
= TREE_CHAIN (values
))
13323 decl
= TREE_VALUE (values
);
13325 /* [dcl.enum]: Following the closing brace of an enum-specifier,
13326 each enumerator has the type of its enumeration. Prior to the
13327 closing brace, the type of each enumerator is the type of its
13328 initializing value. */
13329 TREE_TYPE (decl
) = enumtype
;
13331 /* Update the minimum and maximum values, if appropriate. */
13332 value
= DECL_INITIAL (decl
);
13333 if (value
== error_mark_node
)
13334 value
= integer_zero_node
;
13335 /* Figure out what the minimum and maximum values of the
13336 enumerators are. */
13338 minnode
= maxnode
= value
;
13339 else if (tree_int_cst_lt (maxnode
, value
))
13341 else if (tree_int_cst_lt (value
, minnode
))
13348 If the enumerator-list is empty, the underlying type is as if
13349 the enumeration had a single enumerator with value 0. */
13350 minnode
= maxnode
= integer_zero_node
;
13352 if (!fixed_underlying_type_p
)
13354 /* Compute the number of bits require to represent all values of the
13355 enumeration. We must do this before the type of MINNODE and
13356 MAXNODE are transformed, since tree_int_cst_min_precision relies
13357 on the TREE_TYPE of the value it is passed. */
13358 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
13359 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
13360 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
13361 int precision
= MAX (lowprec
, highprec
);
13363 bool use_short_enum
;
13365 /* Determine the underlying type of the enumeration.
13369 The underlying type of an enumeration is an integral type that
13370 can represent all the enumerator values defined in the
13371 enumeration. It is implementation-defined which integral type is
13372 used as the underlying type for an enumeration except that the
13373 underlying type shall not be larger than int unless the value of
13374 an enumerator cannot fit in an int or unsigned int.
13376 We use "int" or an "unsigned int" as the underlying type, even if
13377 a smaller integral type would work, unless the user has
13378 explicitly requested that we use the smallest possible type. The
13379 user can request that for all enumerations with a command line
13380 flag, or for just one enumeration with an attribute. */
13382 use_short_enum
= flag_short_enums
13383 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
13385 for (itk
= (use_short_enum
? itk_char
: itk_int
);
13389 underlying_type
= integer_types
[itk
];
13390 if (underlying_type
!= NULL_TREE
13391 && TYPE_PRECISION (underlying_type
) >= precision
13392 && TYPE_SIGN (underlying_type
) == sgn
)
13395 if (itk
== itk_none
)
13399 IF no integral type can represent all the enumerator values, the
13400 enumeration is ill-formed. */
13401 error ("no integral type can represent all of the enumerator values "
13402 "for %qT", enumtype
);
13403 precision
= TYPE_PRECISION (long_long_integer_type_node
);
13404 underlying_type
= integer_types
[itk_unsigned_long_long
];
13409 The value of sizeof() applied to an enumeration type, an object
13410 of an enumeration type, or an enumerator, is the value of sizeof()
13411 applied to the underlying type. */
13412 copy_type_enum (enumtype
, underlying_type
);
13414 /* Compute the minimum and maximum values for the type.
13418 For an enumeration where emin is the smallest enumerator and emax
13419 is the largest, the values of the enumeration are the values of the
13420 underlying type in the range bmin to bmax, where bmin and bmax are,
13421 respectively, the smallest and largest values of the smallest bit-
13422 field that can store emin and emax. */
13424 /* The middle-end currently assumes that types with TYPE_PRECISION
13425 narrower than their underlying type are suitably zero or sign
13426 extended to fill their mode. Similarly, it assumes that the front
13427 end assures that a value of a particular type must be within
13428 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
13430 We used to set these fields based on bmin and bmax, but that led
13431 to invalid assumptions like optimizing away bounds checking. So
13432 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
13433 TYPE_MAX_VALUE to the values for the mode above and only restrict
13434 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
13435 ENUM_UNDERLYING_TYPE (enumtype
)
13436 = build_distinct_type_copy (underlying_type
);
13437 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
13438 set_min_and_max_values_for_integral_type
13439 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
13441 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
13442 if (flag_strict_enums
)
13443 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
13446 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
13448 /* Convert each of the enumerators to the type of the underlying
13449 type of the enumeration. */
13450 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13452 location_t saved_location
;
13454 decl
= TREE_VALUE (values
);
13455 saved_location
= input_location
;
13456 input_location
= DECL_SOURCE_LOCATION (decl
);
13457 if (fixed_underlying_type_p
)
13458 /* If the enumeration type has a fixed underlying type, we
13459 already checked all of the enumerator values. */
13460 value
= DECL_INITIAL (decl
);
13462 value
= perform_implicit_conversion (underlying_type
,
13463 DECL_INITIAL (decl
),
13464 tf_warning_or_error
);
13465 input_location
= saved_location
;
13467 /* Do not clobber shared ints. */
13468 value
= copy_node (value
);
13470 TREE_TYPE (value
) = enumtype
;
13471 DECL_INITIAL (decl
) = value
;
13474 /* Fix up all variant types of this enum type. */
13475 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
13476 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
13478 if (at_class_scope_p ()
13479 && COMPLETE_TYPE_P (current_class_type
)
13480 && UNSCOPED_ENUM_P (enumtype
))
13481 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
13482 current_class_type
);
13484 /* Finish debugging output for this type. */
13485 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13487 /* Each enumerator now has the type of its enumeration. Clear the cache
13488 so that this change in types doesn't confuse us later on. */
13489 clear_cv_and_fold_caches ();
13492 /* Finishes the enum type. This is called only the first time an
13493 enumeration is seen, be it opaque or odinary.
13494 ENUMTYPE is the type object. */
13497 finish_enum (tree enumtype
)
13499 if (processing_template_decl
)
13501 if (at_function_scope_p ())
13502 add_stmt (build_min (TAG_DEFN
, enumtype
));
13506 /* If this is a forward declaration, there should not be any variants,
13507 though we can get a variant in the middle of an enum-specifier with
13508 wacky code like 'enum E { e = sizeof(const E*) };' */
13509 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
13510 && (TYPE_VALUES (enumtype
)
13511 || !TYPE_NEXT_VARIANT (enumtype
)));
13514 /* Build and install a CONST_DECL for an enumeration constant of the
13515 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13516 Apply ATTRIBUTES if available. LOC is the location of NAME.
13517 Assignment of sequential values by default is handled here. */
13520 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
13527 /* scalar_constant_value will pull out this expression, so make sure
13528 it's folded as appropriate. */
13529 if (processing_template_decl
)
13530 value
= fold_non_dependent_expr (value
);
13532 /* If the VALUE was erroneous, pretend it wasn't there; that will
13533 result in the enum being assigned the next value in sequence. */
13534 if (value
== error_mark_node
)
13537 /* Remove no-op casts from the value. */
13539 STRIP_TYPE_NOPS (value
);
13541 if (! processing_template_decl
)
13543 /* Validate and default VALUE. */
13544 if (value
!= NULL_TREE
)
13546 if (!ENUM_UNDERLYING_TYPE (enumtype
))
13548 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
13553 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
13554 (TREE_TYPE (value
)))
13555 value
= perform_implicit_conversion_flags
13556 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
13557 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
13559 if (value
== error_mark_node
)
13562 if (value
!= NULL_TREE
)
13564 value
= cxx_constant_value (value
);
13566 if (TREE_CODE (value
) != INTEGER_CST
13567 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13569 error ("enumerator value for %qD is not an integer constant",
13576 /* Default based on previous value. */
13577 if (value
== NULL_TREE
)
13579 if (TYPE_VALUES (enumtype
))
13584 /* C++03 7.2/4: If no initializer is specified for the first
13585 enumerator, the type is an unspecified integral
13586 type. Otherwise the type is the same as the type of the
13587 initializing value of the preceding enumerator unless the
13588 incremented value is not representable in that type, in
13589 which case the type is an unspecified integral type
13590 sufficient to contain the incremented value. */
13591 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13592 if (error_operand_p (prev_value
))
13593 value
= error_mark_node
;
13596 tree type
= TREE_TYPE (prev_value
);
13597 signop sgn
= TYPE_SIGN (type
);
13598 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
13602 bool pos
= !wi::neg_p (wi
, sgn
);
13603 if (!wi::fits_to_tree_p (wi
, type
))
13606 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
13608 type
= integer_types
[itk
];
13609 if (type
!= NULL_TREE
13610 && (pos
|| !TYPE_UNSIGNED (type
))
13611 && wi::fits_to_tree_p (wi
, type
))
13614 if (type
&& cxx_dialect
< cxx11
13615 && itk
> itk_unsigned_long
)
13616 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
13617 incremented enumerator value is too large for %<unsigned long%>" : "\
13618 incremented enumerator value is too large for %<long%>");
13620 if (type
== NULL_TREE
)
13623 value
= wide_int_to_tree (type
, wi
);
13628 error ("overflow in enumeration values at %qD", name
);
13629 value
= error_mark_node
;
13634 value
= integer_zero_node
;
13637 /* Remove no-op casts from the value. */
13638 STRIP_TYPE_NOPS (value
);
13640 /* If the underlying type of the enum is fixed, check whether
13641 the enumerator values fits in the underlying type. If it
13642 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13643 if (ENUM_UNDERLYING_TYPE (enumtype
)
13645 && TREE_CODE (value
) == INTEGER_CST
)
13647 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
13648 error ("enumerator value %E is outside the range of underlying "
13649 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
13651 /* Convert the value to the appropriate type. */
13652 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
13656 /* C++ associates enums with global, function, or class declarations. */
13657 context
= current_scope ();
13659 /* Build the actual enumeration constant. Note that the enumeration
13660 constants have the underlying type of the enum (if it is fixed)
13661 or the type of their initializer (if the underlying type of the
13662 enum is not fixed):
13666 If the underlying type is fixed, the type of each enumerator
13667 prior to the closing brace is the underlying type; if the
13668 initializing value of an enumerator cannot be represented by
13669 the underlying type, the program is ill-formed. If the
13670 underlying type is not fixed, the type of each enumerator is
13671 the type of its initializing value.
13673 If the underlying type is not fixed, it will be computed by
13674 finish_enum and we will reset the type of this enumerator. Of
13675 course, if we're processing a template, there may be no value. */
13676 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13678 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
13680 DECL_CONTEXT (decl
) = enumtype
;
13681 TREE_CONSTANT (decl
) = 1;
13682 TREE_READONLY (decl
) = 1;
13683 DECL_INITIAL (decl
) = value
;
13686 cplus_decl_attributes (&decl
, attributes
, 0);
13688 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
13690 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13691 on the TYPE_FIELDS list for `S'. (That's so that you can say
13692 things like `S::i' later.) */
13694 /* The enumerator may be getting declared outside of its enclosing
13697 class S { public: enum E : int; }; enum S::E : int { i = 7; };
13699 For which case we need to make sure that the access of `S::i'
13700 matches the access of `S::E'. */
13701 tree saved_cas
= current_access_specifier
;
13702 if (TREE_PRIVATE (TYPE_NAME (enumtype
)))
13703 current_access_specifier
= access_private_node
;
13704 else if (TREE_PROTECTED (TYPE_NAME (enumtype
)))
13705 current_access_specifier
= access_protected_node
;
13707 current_access_specifier
= access_public_node
;
13709 finish_member_declaration (decl
);
13711 current_access_specifier
= saved_cas
;
13716 /* Add this enumeration constant to the list for this type. */
13717 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13720 /* Look for an enumerator with the given NAME within the enumeration
13721 type ENUMTYPE. This routine is used primarily for qualified name
13722 lookup into an enumerator in C++0x, e.g.,
13724 enum class Color { Red, Green, Blue };
13726 Color color = Color::Red;
13728 Returns the value corresponding to the enumerator, or
13729 NULL_TREE if no such enumerator was found. */
13731 lookup_enumerator (tree enumtype
, tree name
)
13734 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13736 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13737 return e
? TREE_VALUE (e
) : NULL_TREE
;
13741 /* We're defining DECL. Make sure that its type is OK. */
13744 check_function_type (tree decl
, tree current_function_parms
)
13746 tree fntype
= TREE_TYPE (decl
);
13747 tree return_type
= complete_type (TREE_TYPE (fntype
));
13749 /* In a function definition, arg types must be complete. */
13750 require_complete_types_for_parms (current_function_parms
);
13752 if (dependent_type_p (return_type
)
13753 || type_uses_auto (return_type
))
13755 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13756 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13758 tree args
= TYPE_ARG_TYPES (fntype
);
13760 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13761 error ("return type %q#T is incomplete", return_type
);
13763 error ("return type has Java class type %q#T", return_type
);
13765 /* Make it return void instead. */
13766 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13767 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13769 TREE_CHAIN (args
));
13771 fntype
= build_function_type (void_type_node
, args
);
13773 = build_exception_variant (fntype
,
13774 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13775 fntype
= (cp_build_type_attribute_variant
13776 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13777 TREE_TYPE (decl
) = fntype
;
13780 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13783 /* True iff FN is an implicitly-defined default constructor. */
13786 implicit_default_ctor_p (tree fn
)
13788 return (DECL_CONSTRUCTOR_P (fn
)
13789 && !user_provided_p (fn
)
13790 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
13793 /* Clobber the contents of *this to let the back end know that the object
13794 storage is dead when we enter the constructor or leave the destructor. */
13797 build_clobber_this ()
13799 /* Clobbering an empty base is pointless, and harmful if its one byte
13800 TYPE_SIZE overlays real data. */
13801 if (is_empty_class (current_class_type
))
13804 /* If we have virtual bases, clobber the whole object, but only if we're in
13805 charge. If we don't have virtual bases, clobber the as-base type so we
13806 don't mess with tail padding. */
13807 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
13809 tree ctype
= current_class_type
;
13811 ctype
= CLASSTYPE_AS_BASE (ctype
);
13813 tree clobber
= build_constructor (ctype
, NULL
);
13814 TREE_THIS_VOLATILE (clobber
) = true;
13816 tree thisref
= current_class_ref
;
13817 if (ctype
!= current_class_type
)
13819 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
13820 thisref
= convert_from_reference (thisref
);
13823 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
13825 exprstmt
= build_if_in_charge (exprstmt
);
13830 /* Create the FUNCTION_DECL for a function definition.
13831 DECLSPECS and DECLARATOR are the parts of the declaration;
13832 they describe the function's name and the type it returns,
13833 but twisted together in a fashion that parallels the syntax of C.
13835 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13836 DECLARATOR is really the DECL for the function we are about to
13837 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13838 indicating that the function is an inline defined in-class.
13840 This function creates a binding context for the function body
13841 as well as setting up the FUNCTION_DECL in current_function_decl.
13843 For C++, we must first check whether that datum makes any sense.
13844 For example, "class A local_a(1,2);" means that variable local_a
13845 is an aggregate of type A, which should have a constructor
13846 applied to it with the argument list [1, 2].
13848 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13849 or may be a BLOCK if the function has been defined previously
13850 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13851 error_mark_node if the function has never been defined, or
13852 a BLOCK if the function has been defined somewhere. */
13855 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13857 tree ctype
= NULL_TREE
;
13860 int doing_friend
= 0;
13861 cp_binding_level
*bl
;
13862 tree current_function_parms
;
13863 struct c_fileinfo
*finfo
13864 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13865 bool honor_interface
;
13867 /* Sanity check. */
13868 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13869 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13871 fntype
= TREE_TYPE (decl1
);
13872 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13873 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13875 /* ISO C++ 11.4/5. A friend function defined in a class is in
13876 the (lexical) scope of the class in which it is defined. */
13877 if (!ctype
&& DECL_FRIEND_P (decl1
))
13879 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13881 /* CTYPE could be null here if we're dealing with a template;
13882 for example, `inline friend float foo()' inside a template
13883 will have no CTYPE set. */
13884 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13890 if (DECL_DECLARED_INLINE_P (decl1
)
13891 && lookup_attribute ("noinline", attrs
))
13892 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
13893 "inline function %qD given attribute noinline", decl1
);
13895 /* Handle gnu_inline attribute. */
13896 if (GNU_INLINE_P (decl1
))
13898 DECL_EXTERNAL (decl1
) = 1;
13899 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13900 DECL_INTERFACE_KNOWN (decl1
) = 1;
13901 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13904 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13905 /* This is a constructor, we must ensure that any default args
13906 introduced by this definition are propagated to the clones
13907 now. The clones are used directly in overload resolution. */
13908 adjust_clone_args (decl1
);
13910 /* Sometimes we don't notice that a function is a static member, and
13911 build a METHOD_TYPE for it. Fix that up now. */
13912 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13913 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13915 /* Set up current_class_type, and enter the scope of the class, if
13918 push_nested_class (ctype
);
13919 else if (DECL_STATIC_FUNCTION_P (decl1
))
13920 push_nested_class (DECL_CONTEXT (decl1
));
13922 /* Now that we have entered the scope of the class, we must restore
13923 the bindings for any template parameters surrounding DECL1, if it
13924 is an inline member template. (Order is important; consider the
13925 case where a template parameter has the same name as a field of
13926 the class.) It is not until after this point that
13927 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13928 if (flags
& SF_INCLASS_INLINE
)
13929 maybe_begin_member_template_processing (decl1
);
13931 /* Effective C++ rule 15. */
13933 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13934 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13935 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13937 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13938 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13939 if (!DECL_INITIAL (decl1
))
13940 DECL_INITIAL (decl1
) = error_mark_node
;
13942 /* This function exists in static storage.
13943 (This does not mean `static' in the C sense!) */
13944 TREE_STATIC (decl1
) = 1;
13946 /* We must call push_template_decl after current_class_type is set
13947 up. (If we are processing inline definitions after exiting a
13948 class scope, current_class_type will be NULL_TREE until set above
13949 by push_nested_class.) */
13950 if (processing_template_decl
)
13952 tree newdecl1
= push_template_decl (decl1
);
13953 if (newdecl1
== error_mark_node
)
13955 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13956 pop_nested_class ();
13962 /* We are now in the scope of the function being defined. */
13963 current_function_decl
= decl1
;
13965 /* Save the parm names or decls from this function's declarator
13966 where store_parm_decls will find them. */
13967 current_function_parms
= DECL_ARGUMENTS (decl1
);
13969 /* Make sure the parameter and return types are reasonable. When
13970 you declare a function, these types can be incomplete, but they
13971 must be complete when you define the function. */
13972 check_function_type (decl1
, current_function_parms
);
13974 /* Build the return declaration for the function. */
13975 restype
= TREE_TYPE (fntype
);
13977 if (DECL_RESULT (decl1
) == NULL_TREE
)
13981 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13982 DECL_ARTIFICIAL (resdecl
) = 1;
13983 DECL_IGNORED_P (resdecl
) = 1;
13984 DECL_RESULT (decl1
) = resdecl
;
13986 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13989 /* Let the user know we're compiling this function. */
13990 announce_function (decl1
);
13992 /* Record the decl so that the function name is defined.
13993 If we already have a decl for this name, and it is a FUNCTION_DECL,
13994 use the old decl. */
13995 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13997 /* A specialization is not used to guide overload resolution. */
13998 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13999 && !(DECL_USE_TEMPLATE (decl1
) &&
14000 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
14002 tree olddecl
= pushdecl (decl1
);
14004 if (olddecl
== error_mark_node
)
14005 /* If something went wrong when registering the declaration,
14006 use DECL1; we have to have a FUNCTION_DECL to use when
14007 parsing the body of the function. */
14011 /* Otherwise, OLDDECL is either a previous declaration
14012 of the same function or DECL1 itself. */
14014 if (warn_missing_declarations
14015 && olddecl
== decl1
14016 && !DECL_MAIN_P (decl1
)
14017 && TREE_PUBLIC (decl1
)
14018 && !DECL_DECLARED_INLINE_P (decl1
))
14022 /* Check whether DECL1 is in an anonymous
14024 for (context
= DECL_CONTEXT (decl1
);
14026 context
= DECL_CONTEXT (context
))
14028 if (TREE_CODE (context
) == NAMESPACE_DECL
14029 && DECL_NAME (context
) == NULL_TREE
)
14033 if (context
== NULL
)
14034 warning_at (DECL_SOURCE_LOCATION (decl1
),
14035 OPT_Wmissing_declarations
,
14036 "no previous declaration for %qD", decl1
);
14044 /* We need to set the DECL_CONTEXT. */
14045 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
14046 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
14048 fntype
= TREE_TYPE (decl1
);
14049 restype
= TREE_TYPE (fntype
);
14051 /* If #pragma weak applies, mark the decl appropriately now.
14052 The pragma only applies to global functions. Because
14053 determining whether or not the #pragma applies involves
14054 computing the mangled name for the declaration, we cannot
14055 apply the pragma until after we have merged this declaration
14056 with any previous declarations; if the original declaration
14057 has a linkage specification, that specification applies to
14058 the definition as well, and may affect the mangled name. */
14059 if (DECL_FILE_SCOPE_P (decl1
))
14060 maybe_apply_pragma_weak (decl1
);
14063 /* Reset this in case the call to pushdecl changed it. */
14064 current_function_decl
= decl1
;
14066 gcc_assert (DECL_INITIAL (decl1
));
14068 /* This function may already have been parsed, in which case just
14069 return; our caller will skip over the body without parsing. */
14070 if (DECL_INITIAL (decl1
) != error_mark_node
)
14073 /* Initialize RTL machinery. We cannot do this until
14074 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
14075 even when processing a template; this is how we get
14076 CFUN set up, and our per-function variables initialized.
14077 FIXME factor out the non-RTL stuff. */
14078 bl
= current_binding_level
;
14079 allocate_struct_function (decl1
, processing_template_decl
);
14081 /* Initialize the language data structures. Whenever we start
14082 a new function, we destroy temporaries in the usual way. */
14083 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
14084 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14085 current_binding_level
= bl
;
14087 if (!processing_template_decl
&& type_uses_auto (restype
))
14089 FNDECL_USED_AUTO (decl1
) = true;
14090 current_function_auto_return_pattern
= restype
;
14093 /* Start the statement-tree, start the tree now. */
14094 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
14096 /* If we are (erroneously) defining a function that we have already
14097 defined before, wipe out what we knew before. */
14098 if (!DECL_PENDING_INLINE_P (decl1
))
14099 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
14101 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
14103 /* We know that this was set up by `grokclassfn'. We do not
14104 wait until `store_parm_decls', since evil parse errors may
14105 never get us to that point. Here we keep the consistency
14106 between `current_class_type' and `current_class_ptr'. */
14107 tree t
= DECL_ARGUMENTS (decl1
);
14109 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
14110 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
14112 cp_function_chain
->x_current_class_ref
14113 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
14114 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
14115 cp_function_chain
->x_current_class_ptr
= t
;
14117 /* Constructors and destructors need to know whether they're "in
14118 charge" of initializing virtual base classes. */
14119 t
= DECL_CHAIN (t
);
14120 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
14122 current_in_charge_parm
= t
;
14123 t
= DECL_CHAIN (t
);
14125 if (DECL_HAS_VTT_PARM_P (decl1
))
14127 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
14128 current_vtt_parm
= t
;
14132 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
14133 /* Implicitly-defined methods (like the
14134 destructor for a class in which no destructor
14135 is explicitly declared) must not be defined
14136 until their definition is needed. So, we
14137 ignore interface specifications for
14138 compiler-generated functions. */
14139 && !DECL_ARTIFICIAL (decl1
));
14141 if (processing_template_decl
)
14142 /* Don't mess with interface flags. */;
14143 else if (DECL_INTERFACE_KNOWN (decl1
))
14145 tree ctx
= decl_function_context (decl1
);
14147 if (DECL_NOT_REALLY_EXTERN (decl1
))
14148 DECL_EXTERNAL (decl1
) = 0;
14150 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
14151 /* This is a function in a local class in an extern inline
14152 or template function. */
14153 comdat_linkage (decl1
);
14155 /* If this function belongs to an interface, it is public.
14156 If it belongs to someone else's interface, it is also external.
14157 This only affects inlines and template instantiations. */
14158 else if (!finfo
->interface_unknown
&& honor_interface
)
14160 if (DECL_DECLARED_INLINE_P (decl1
)
14161 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14163 DECL_EXTERNAL (decl1
)
14164 = (finfo
->interface_only
14165 || (DECL_DECLARED_INLINE_P (decl1
)
14166 && ! flag_implement_inlines
14167 && !DECL_VINDEX (decl1
)));
14169 /* For WIN32 we also want to put these in linkonce sections. */
14170 maybe_make_one_only (decl1
);
14173 DECL_EXTERNAL (decl1
) = 0;
14174 DECL_INTERFACE_KNOWN (decl1
) = 1;
14175 /* If this function is in an interface implemented in this file,
14176 make sure that the back end knows to emit this function
14178 if (!DECL_EXTERNAL (decl1
))
14179 mark_needed (decl1
);
14181 else if (finfo
->interface_unknown
&& finfo
->interface_only
14182 && honor_interface
)
14184 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14185 interface, we will have both finfo->interface_unknown and
14186 finfo->interface_only set. In that case, we don't want to
14187 use the normal heuristics because someone will supply a
14188 #pragma implementation elsewhere, and deducing it here would
14189 produce a conflict. */
14190 comdat_linkage (decl1
);
14191 DECL_EXTERNAL (decl1
) = 0;
14192 DECL_INTERFACE_KNOWN (decl1
) = 1;
14193 DECL_DEFER_OUTPUT (decl1
) = 1;
14197 /* This is a definition, not a reference.
14198 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
14199 if (!GNU_INLINE_P (decl1
))
14200 DECL_EXTERNAL (decl1
) = 0;
14202 if ((DECL_DECLARED_INLINE_P (decl1
)
14203 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14204 && ! DECL_INTERFACE_KNOWN (decl1
))
14205 DECL_DEFER_OUTPUT (decl1
) = 1;
14207 DECL_INTERFACE_KNOWN (decl1
) = 1;
14210 /* Determine the ELF visibility attribute for the function. We must not
14211 do this before calling "pushdecl", as we must allow "duplicate_decls"
14212 to merge any attributes appropriately. We also need to wait until
14214 if (!DECL_CLONED_FUNCTION_P (decl1
))
14215 determine_visibility (decl1
);
14217 if (!processing_template_decl
)
14218 maybe_instantiate_noexcept (decl1
);
14220 begin_scope (sk_function_parms
, decl1
);
14224 if (DECL_DESTRUCTOR_P (decl1
)
14225 || (DECL_CONSTRUCTOR_P (decl1
)
14226 && targetm
.cxx
.cdtor_returns_this ()))
14227 cdtor_label
= create_artificial_label (input_location
);
14229 start_fname_decls ();
14231 store_parm_decls (current_function_parms
);
14233 if (!processing_template_decl
14234 && (flag_lifetime_dse
> 1)
14235 && DECL_CONSTRUCTOR_P (decl1
)
14236 && !DECL_CLONED_FUNCTION_P (decl1
)
14237 /* Clobbering an empty base is harmful if it overlays real data. */
14238 && !is_empty_class (current_class_type
)
14239 /* We can't clobber safely for an implicitly-defined default constructor
14240 because part of the initialization might happen before we enter the
14241 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
14242 && !implicit_default_ctor_p (decl1
))
14243 finish_expr_stmt (build_clobber_this ());
14245 if (!processing_template_decl
14246 && DECL_CONSTRUCTOR_P (decl1
)
14247 && (flag_sanitize
& SANITIZE_VPTR
)
14248 && !DECL_CLONED_FUNCTION_P (decl1
)
14249 && !implicit_default_ctor_p (decl1
))
14250 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
14256 /* Like start_preparsed_function, except that instead of a
14257 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
14259 Returns true on success. If the DECLARATOR is not suitable
14260 for a function, we return false, which tells the parser to
14261 skip the entire function. */
14264 start_function (cp_decl_specifier_seq
*declspecs
,
14265 const cp_declarator
*declarator
,
14270 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
14271 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
14272 if (decl1
== error_mark_node
)
14274 /* If the declarator is not suitable for a function definition,
14275 cause a syntax error. */
14276 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
14278 error ("invalid function declaration");
14282 if (DECL_MAIN_P (decl1
))
14283 /* main must return int. grokfndecl should have corrected it
14284 (and issued a diagnostic) if the user got it wrong. */
14285 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
14286 integer_type_node
));
14288 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
14291 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
14295 use_eh_spec_block (tree fn
)
14297 return (flag_exceptions
&& flag_enforce_eh_specs
14298 && !processing_template_decl
14299 && !type_throw_all_p (TREE_TYPE (fn
))
14300 /* We insert the EH_SPEC_BLOCK only in the original
14301 function; then, it is copied automatically to the
14303 && !DECL_CLONED_FUNCTION_P (fn
)
14304 /* Implicitly-generated constructors and destructors have
14305 exception specifications. However, those specifications
14306 are the union of the possible exceptions specified by the
14307 constructors/destructors for bases and members, so no
14308 unallowed exception will ever reach this function. By
14309 not creating the EH_SPEC_BLOCK we save a little memory,
14310 and we avoid spurious warnings about unreachable
14312 && !DECL_DEFAULTED_FN (fn
));
14315 /* Store the parameter declarations into the current function declaration.
14316 This is called after parsing the parameter declarations, before
14317 digesting the body of the function.
14319 Also install to binding contour return value identifier, if any. */
14322 store_parm_decls (tree current_function_parms
)
14324 tree fndecl
= current_function_decl
;
14327 /* This is a chain of any other decls that came in among the parm
14328 declarations. If a parm is declared with enum {foo, bar} x;
14329 then CONST_DECLs for foo and bar are put here. */
14330 tree nonparms
= NULL_TREE
;
14332 if (current_function_parms
)
14334 /* This case is when the function was defined with an ANSI prototype.
14335 The parms already have decls, so we need not do anything here
14336 except record them as in effect
14337 and complain if any redundant old-style parm decls were written. */
14339 tree specparms
= current_function_parms
;
14342 /* Must clear this because it might contain TYPE_DECLs declared
14344 current_binding_level
->names
= NULL
;
14346 /* If we're doing semantic analysis, then we'll call pushdecl
14347 for each of these. We must do them in reverse order so that
14348 they end in the correct forward order. */
14349 specparms
= nreverse (specparms
);
14351 for (parm
= specparms
; parm
; parm
= next
)
14353 next
= DECL_CHAIN (parm
);
14354 if (TREE_CODE (parm
) == PARM_DECL
)
14356 if (DECL_NAME (parm
) == NULL_TREE
14357 || !VOID_TYPE_P (parm
))
14360 error ("parameter %qD declared void", parm
);
14364 /* If we find an enum constant or a type tag,
14365 put it aside for the moment. */
14366 TREE_CHAIN (parm
) = NULL_TREE
;
14367 nonparms
= chainon (nonparms
, parm
);
14371 /* Get the decls in their original chain order and record in the
14372 function. This is all and only the PARM_DECLs that were
14373 pushed into scope by the loop above. */
14374 DECL_ARGUMENTS (fndecl
) = getdecls ();
14377 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
14379 /* Now store the final chain of decls for the arguments
14380 as the decl-chain of the current lexical scope.
14381 Put the enumerators in as well, at the front so that
14382 DECL_ARGUMENTS is not modified. */
14383 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
14385 if (use_eh_spec_block (current_function_decl
))
14386 current_eh_spec_block
= begin_eh_spec_block ();
14390 /* We have finished doing semantic analysis on DECL, but have not yet
14391 generated RTL for its body. Save away our current state, so that
14392 when we want to generate RTL later we know what to do. */
14395 save_function_data (tree decl
)
14397 struct language_function
*f
;
14399 /* Save the language-specific per-function data so that we can
14400 get it back when we really expand this function. */
14401 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
14404 f
= ggc_alloc
<language_function
> ();
14405 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
14406 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
14408 /* Clear out the bits we don't need. */
14409 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
14410 f
->bindings
= NULL
;
14411 f
->x_local_names
= NULL
;
14412 f
->base
.local_typedefs
= NULL
;
14416 /* Set the return value of the constructor (if present). */
14419 finish_constructor_body (void)
14424 if (targetm
.cxx
.cdtor_returns_this ()
14425 && (! TYPE_FOR_JAVA (current_class_type
)))
14427 /* Any return from a constructor will end up here. */
14428 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14430 val
= DECL_ARGUMENTS (current_function_decl
);
14431 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14432 DECL_RESULT (current_function_decl
), val
);
14433 /* Return the address of the object. */
14434 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14435 add_stmt (exprstmt
);
14439 /* Do all the processing for the beginning of a destructor; set up the
14440 vtable pointers and cleanups for bases and members. */
14443 begin_destructor_body (void)
14445 tree compound_stmt
;
14447 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
14448 issued an error message. We still want to try to process the
14449 body of the function, but initialize_vtbl_ptrs will crash if
14450 TYPE_BINFO is NULL. */
14451 if (COMPLETE_TYPE_P (current_class_type
))
14453 compound_stmt
= begin_compound_stmt (0);
14454 /* Make all virtual function table pointers in non-virtual base
14455 classes point to CURRENT_CLASS_TYPE's virtual function
14457 initialize_vtbl_ptrs (current_class_ptr
);
14458 finish_compound_stmt (compound_stmt
);
14460 if (flag_lifetime_dse
14461 /* Clobbering an empty base is harmful if it overlays real data. */
14462 && !is_empty_class (current_class_type
))
14463 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
14465 /* And insert cleanups for our bases and members so that they
14466 will be properly destroyed if we throw. */
14467 push_base_cleanups ();
14471 /* At the end of every destructor we generate code to delete the object if
14472 necessary. Do that now. */
14475 finish_destructor_body (void)
14479 /* Any return from a destructor will end up here; that way all base
14480 and member cleanups will be run when the function returns. */
14481 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14483 if (targetm
.cxx
.cdtor_returns_this ())
14487 val
= DECL_ARGUMENTS (current_function_decl
);
14488 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14489 DECL_RESULT (current_function_decl
), val
);
14490 /* Return the address of the object. */
14491 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14492 add_stmt (exprstmt
);
14496 /* Do the necessary processing for the beginning of a function body, which
14497 in this case includes member-initializers, but not the catch clauses of
14498 a function-try-block. Currently, this means opening a binding level
14499 for the member-initializers (in a ctor), member cleanups (in a dtor),
14500 and capture proxies (in a lambda operator()). */
14503 begin_function_body (void)
14507 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
14510 if (processing_template_decl
)
14511 /* Do nothing now. */;
14513 /* Always keep the BLOCK node associated with the outermost pair of
14514 curly braces of a function. These are needed for correct
14515 operation of dwarfout.c. */
14516 keep_next_level (true);
14518 stmt
= begin_compound_stmt (BCS_FN_BODY
);
14520 if (processing_template_decl
)
14521 /* Do nothing now. */;
14522 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14523 begin_destructor_body ();
14528 /* Do the processing for the end of a function body. Currently, this means
14529 closing out the cleanups for fully-constructed bases and members, and in
14530 the case of the destructor, deleting the object if desired. Again, this
14531 is only meaningful for [cd]tors, since they are the only functions where
14532 there is a significant distinction between the main body and any
14533 function catch clauses. Handling, say, main() return semantics here
14534 would be wrong, as flowing off the end of a function catch clause for
14535 main() would also need to return 0. */
14538 finish_function_body (tree compstmt
)
14540 if (compstmt
== NULL_TREE
)
14543 /* Close the block. */
14544 finish_compound_stmt (compstmt
);
14546 if (processing_template_decl
)
14547 /* Do nothing now. */;
14548 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
14549 finish_constructor_body ();
14550 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14551 finish_destructor_body ();
14554 /* Given a function, returns the BLOCK corresponding to the outermost level
14555 of curly braces, skipping the artificial block created for constructor
14559 outer_curly_brace_block (tree fndecl
)
14561 tree block
= DECL_INITIAL (fndecl
);
14562 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14564 block
= BLOCK_SUBBLOCKS (block
);
14565 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14567 block
= BLOCK_SUBBLOCKS (block
);
14568 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
14572 /* If FNDECL is a class's key method, add the class to the list of
14573 keyed classes that should be emitted. */
14576 record_key_method_defined (tree fndecl
)
14578 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
14579 && DECL_VIRTUAL_P (fndecl
)
14580 && !processing_template_decl
)
14582 tree fnclass
= DECL_CONTEXT (fndecl
);
14583 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
14584 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
14588 /* Subroutine of finish_function.
14589 Save the body of constexpr functions for possible
14590 future compile time evaluation. */
14593 maybe_save_function_definition (tree fun
)
14595 if (!processing_template_decl
14596 && DECL_DECLARED_CONSTEXPR_P (fun
)
14597 && !cp_function_chain
->invalid_constexpr
14598 && !DECL_CLONED_FUNCTION_P (fun
))
14599 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
14602 /* Finish up a function declaration and compile that function
14603 all the way to assembler language output. The free the storage
14604 for the function definition.
14606 FLAGS is a bitwise or of the following values:
14608 We just finished processing the body of an in-class inline
14609 function definition. (This processing will have taken place
14610 after the class definition is complete.) */
14613 finish_function (int flags
)
14615 tree fndecl
= current_function_decl
;
14616 tree fntype
, ctype
= NULL_TREE
;
14617 int inclass_inline
= (flags
& 2) != 0;
14619 /* When we get some parse errors, we can end up without a
14620 current_function_decl, so cope. */
14621 if (fndecl
== NULL_TREE
)
14622 return error_mark_node
;
14624 if (c_dialect_objc ())
14625 objc_finish_function ();
14627 record_key_method_defined (fndecl
);
14629 fntype
= TREE_TYPE (fndecl
);
14631 /* TREE_READONLY (fndecl) = 1;
14632 This caused &foo to be of type ptr-to-const-function
14633 which then got a warning when stored in a ptr-to-function variable. */
14635 gcc_assert (building_stmt_list_p ());
14636 /* The current function is being defined, so its DECL_INITIAL should
14637 be set, and unless there's a multiple definition, it should be
14638 error_mark_node. */
14639 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
14641 /* For a cloned function, we've already got all the code we need;
14642 there's no need to add any extra bits. */
14643 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14645 /* Make it so that `main' always returns 0 by default. */
14646 if (DECL_MAIN_P (current_function_decl
))
14647 finish_return_stmt (integer_zero_node
);
14649 if (use_eh_spec_block (current_function_decl
))
14650 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14651 (TREE_TYPE (current_function_decl
)),
14652 current_eh_spec_block
);
14655 /* If we're saving up tree structure, tie off the function now. */
14656 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
14658 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
14659 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
14661 finish_fname_decls ();
14663 /* If this function can't throw any exceptions, remember that. */
14664 if (!processing_template_decl
14665 && !cp_function_chain
->can_throw
14666 && !flag_non_call_exceptions
14667 && !decl_replaceable_p (fndecl
))
14668 TREE_NOTHROW (fndecl
) = 1;
14670 /* This must come after expand_function_end because cleanups might
14671 have declarations (from inline functions) that need to go into
14672 this function's blocks. */
14674 /* If the current binding level isn't the outermost binding level
14675 for this function, either there is a bug, or we have experienced
14676 syntax errors and the statement tree is malformed. */
14677 if (current_binding_level
->kind
!= sk_function_parms
)
14679 /* Make sure we have already experienced errors. */
14680 gcc_assert (errorcount
);
14682 /* Throw away the broken statement tree and extra binding
14684 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
14686 while (current_binding_level
->kind
!= sk_function_parms
)
14688 if (current_binding_level
->kind
== sk_class
)
14689 pop_nested_class ();
14691 poplevel (0, 0, 0);
14694 poplevel (1, 0, 1);
14696 /* Statements should always be full-expressions at the outermost set
14697 of curly braces for a function. */
14698 gcc_assert (stmts_are_full_exprs_p ());
14700 /* If there are no return statements in a function with auto return type,
14701 the return type is void. But if the declared type is something like
14702 auto*, this is an error. */
14703 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
14704 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
14706 if (!is_auto (current_function_auto_return_pattern
)
14707 && !current_function_returns_value
&& !current_function_returns_null
)
14709 error ("no return statements in function returning %qT",
14710 current_function_auto_return_pattern
);
14711 inform (input_location
, "only plain %<auto%> return type can be "
14712 "deduced to %<void%>");
14714 apply_deduced_return_type (fndecl
, void_type_node
);
14715 fntype
= TREE_TYPE (fndecl
);
14718 // If this is a concept, check that the definition is reasonable.
14719 if (DECL_DECLARED_CONCEPT_P (fndecl
))
14720 check_function_concept (fndecl
);
14722 /* Save constexpr function body before it gets munged by
14723 the NRV transformation. */
14724 maybe_save_function_definition (fndecl
);
14726 /* Invoke the pre-genericize plugin before we start munging things. */
14727 if (!processing_template_decl
)
14728 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14730 /* Perform delayed folding before NRV transformation. */
14731 if (!processing_template_decl
)
14732 cp_fold_function (fndecl
);
14734 /* Set up the named return value optimization, if we can. Candidate
14735 variables are selected in check_return_expr. */
14736 if (current_function_return_value
)
14738 tree r
= current_function_return_value
;
14741 if (r
!= error_mark_node
14742 /* This is only worth doing for fns that return in memory--and
14743 simpler, since we don't have to worry about promoted modes. */
14744 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
14745 /* Only allow this for variables declared in the outer scope of
14746 the function so we know that their lifetime always ends with a
14747 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14748 we were to do this optimization in tree-ssa. */
14749 && (outer
= outer_curly_brace_block (fndecl
))
14750 && chain_member (r
, BLOCK_VARS (outer
)))
14751 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
14753 current_function_return_value
= NULL_TREE
;
14756 /* Remember that we were in class scope. */
14757 if (current_class_name
)
14758 ctype
= current_class_type
;
14760 /* Must mark the RESULT_DECL as being in this function. */
14761 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14763 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14764 to the FUNCTION_DECL node itself. */
14765 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14767 /* Save away current state, if appropriate. */
14768 if (!processing_template_decl
)
14769 save_function_data (fndecl
);
14771 /* Complain if there's just no return statement. */
14772 if (warn_return_type
14773 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14774 && !dependent_type_p (TREE_TYPE (fntype
))
14775 && !current_function_returns_value
&& !current_function_returns_null
14776 /* Don't complain if we abort or throw. */
14777 && !current_function_returns_abnormally
14778 /* Don't complain if there's an infinite loop. */
14779 && !current_function_infinite_loop
14780 /* Don't complain if we are declared noreturn. */
14781 && !TREE_THIS_VOLATILE (fndecl
)
14782 && !DECL_NAME (DECL_RESULT (fndecl
))
14783 && !TREE_NO_WARNING (fndecl
)
14784 /* Structor return values (if any) are set by the compiler. */
14785 && !DECL_CONSTRUCTOR_P (fndecl
)
14786 && !DECL_DESTRUCTOR_P (fndecl
)
14787 && targetm
.warn_func_return (fndecl
))
14789 warning (OPT_Wreturn_type
,
14790 "no return statement in function returning non-void");
14791 TREE_NO_WARNING (fndecl
) = 1;
14794 /* Store the end of the function, so that we get good line number
14795 info for the epilogue. */
14796 cfun
->function_end_locus
= input_location
;
14798 /* Complain about parameters that are only set, but never otherwise used. */
14799 if (warn_unused_but_set_parameter
14800 && !processing_template_decl
14801 && errorcount
== unused_but_set_errorcount
14802 && !DECL_CLONED_FUNCTION_P (fndecl
))
14806 for (decl
= DECL_ARGUMENTS (fndecl
);
14808 decl
= DECL_CHAIN (decl
))
14809 if (TREE_USED (decl
)
14810 && TREE_CODE (decl
) == PARM_DECL
14811 && !DECL_READ_P (decl
)
14812 && DECL_NAME (decl
)
14813 && !DECL_ARTIFICIAL (decl
)
14814 && !TREE_NO_WARNING (decl
)
14815 && !DECL_IN_SYSTEM_HEADER (decl
)
14816 && TREE_TYPE (decl
) != error_mark_node
14817 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14818 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14819 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14820 warning_at (DECL_SOURCE_LOCATION (decl
),
14821 OPT_Wunused_but_set_parameter
,
14822 "parameter %qD set but not used", decl
);
14823 unused_but_set_errorcount
= errorcount
;
14826 /* Complain about locally defined typedefs that are not used in this
14828 maybe_warn_unused_local_typedefs ();
14830 /* Possibly warn about unused parameters. */
14831 if (warn_unused_parameter
14832 && !processing_template_decl
14833 && !DECL_CLONED_FUNCTION_P (fndecl
))
14834 do_warn_unused_parameter (fndecl
);
14836 /* Genericize before inlining. */
14837 if (!processing_template_decl
)
14839 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14840 cp_genericize (fndecl
);
14841 /* Clear out the bits we don't need. */
14842 f
->x_current_class_ptr
= NULL
;
14843 f
->x_current_class_ref
= NULL
;
14844 f
->x_eh_spec_block
= NULL
;
14845 f
->x_in_charge_parm
= NULL
;
14846 f
->x_vtt_parm
= NULL
;
14847 f
->x_return_value
= NULL
;
14848 f
->bindings
= NULL
;
14849 f
->extern_decl_map
= NULL
;
14850 f
->infinite_loops
= NULL
;
14852 /* Clear out the bits we don't need. */
14853 local_names
= NULL
;
14855 /* We're leaving the context of this function, so zap cfun. It's still in
14856 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14858 current_function_decl
= NULL
;
14860 /* If this is an in-class inline definition, we may have to pop the
14861 bindings for the template parameters that we added in
14862 maybe_begin_member_template_processing when start_function was
14864 if (inclass_inline
)
14865 maybe_end_member_template_processing ();
14867 /* Leave the scope of the class. */
14869 pop_nested_class ();
14874 current_function_decl
= NULL_TREE
;
14876 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
14880 /* Create the FUNCTION_DECL for a function definition.
14881 DECLSPECS and DECLARATOR are the parts of the declaration;
14882 they describe the return type and the name of the function,
14883 but twisted together in a fashion that parallels the syntax of C.
14885 This function creates a binding context for the function body
14886 as well as setting up the FUNCTION_DECL in current_function_decl.
14888 Returns a FUNCTION_DECL on success.
14890 If the DECLARATOR is not suitable for a function (it defines a datum
14891 instead), we return 0, which tells yyparse to report a parse error.
14893 May return void_type_node indicating that this method is actually
14894 a friend. See grokfield for more details.
14896 Came here with a `.pushlevel' .
14898 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14899 CHANGES TO CODE IN `grokfield'. */
14902 grokmethod (cp_decl_specifier_seq
*declspecs
,
14903 const cp_declarator
*declarator
, tree attrlist
)
14905 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14908 if (fndecl
== error_mark_node
)
14909 return error_mark_node
;
14911 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14913 error ("invalid member function declaration");
14914 return error_mark_node
;
14918 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14920 /* Pass friends other than inline friend functions back. */
14921 if (fndecl
== void_type_node
)
14924 if (DECL_IN_AGGR_P (fndecl
))
14926 if (DECL_CLASS_SCOPE_P (fndecl
))
14927 error ("%qD is already defined in class %qT", fndecl
,
14928 DECL_CONTEXT (fndecl
));
14929 return error_mark_node
;
14932 check_template_shadow (fndecl
);
14934 if (TREE_PUBLIC (fndecl
))
14935 DECL_COMDAT (fndecl
) = 1;
14936 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14937 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14939 /* We process method specializations in finish_struct_1. */
14940 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14942 fndecl
= push_template_decl (fndecl
);
14943 if (fndecl
== error_mark_node
)
14947 if (! DECL_FRIEND_P (fndecl
))
14949 if (DECL_CHAIN (fndecl
))
14951 fndecl
= copy_node (fndecl
);
14952 TREE_CHAIN (fndecl
) = NULL_TREE
;
14956 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14958 DECL_IN_AGGR_P (fndecl
) = 1;
14963 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14964 we can lay it out later, when and if its type becomes complete.
14966 Also handle constexpr variables where the initializer involves
14967 an unlowered PTRMEM_CST because the class isn't complete yet. */
14970 maybe_register_incomplete_var (tree var
)
14972 gcc_assert (VAR_P (var
));
14974 /* Keep track of variables with incomplete types. */
14975 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14976 && DECL_EXTERNAL (var
))
14978 tree inner_type
= TREE_TYPE (var
);
14980 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14981 inner_type
= TREE_TYPE (inner_type
);
14982 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14984 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14985 /* RTTI TD entries are created while defining the type_info. */
14986 || (TYPE_LANG_SPECIFIC (inner_type
)
14987 && TYPE_BEING_DEFINED (inner_type
)))
14989 incomplete_var iv
= {var
, inner_type
};
14990 vec_safe_push (incomplete_vars
, iv
);
14992 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
14993 && decl_constant_var_p (var
)
14994 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
14996 /* When the outermost open class is complete we can resolve any
14997 pointers-to-members. */
14998 tree context
= outermost_open_class ();
14999 incomplete_var iv
= {var
, context
};
15000 vec_safe_push (incomplete_vars
, iv
);
15005 /* Called when a class type (given by TYPE) is defined. If there are
15006 any existing VAR_DECLs whose type has been completed by this
15007 declaration, update them now. */
15010 complete_vars (tree type
)
15013 incomplete_var
*iv
;
15015 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
15017 if (same_type_p (type
, iv
->incomplete_type
))
15019 tree var
= iv
->decl
;
15020 tree type
= TREE_TYPE (var
);
15022 if (TYPE_MAIN_VARIANT (strip_array_types (type
))
15023 == iv
->incomplete_type
)
15025 /* Complete the type of the variable. The VAR_DECL itself
15026 will be laid out in expand_expr. */
15027 complete_type (type
);
15028 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
15031 /* Remove this entry from the list. */
15032 incomplete_vars
->unordered_remove (ix
);
15038 /* Check for pending declarations which may have abstract type. */
15039 complete_type_check_abstract (type
);
15042 /* If DECL is of a type which needs a cleanup, build and return an
15043 expression to perform that cleanup here. Return NULL_TREE if no
15044 cleanup need be done. DECL can also be a _REF when called from
15045 split_nonconstant_init_1. */
15048 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
15054 /* Assume no cleanup is required. */
15055 cleanup
= NULL_TREE
;
15057 if (error_operand_p (decl
))
15060 /* Handle "__attribute__((cleanup))". We run the cleanup function
15061 before the destructor since the destructor is what actually
15062 terminates the lifetime of the object. */
15064 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
15073 /* Get the name specified by the user for the cleanup function. */
15074 id
= TREE_VALUE (TREE_VALUE (attr
));
15075 /* Look up the name to find the cleanup function to call. It is
15076 important to use lookup_name here because that is what is
15077 used in c-common.c:handle_cleanup_attribute when performing
15078 initial checks on the attribute. Note that those checks
15079 include ensuring that the function found is not an overloaded
15080 function, or an object with an overloaded call operator,
15081 etc.; we can rely on the fact that the function found is an
15082 ordinary FUNCTION_DECL. */
15083 fn
= lookup_name (id
);
15084 arg
= build_address (decl
);
15085 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
15086 return error_mark_node
;
15087 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
15088 if (cleanup
== error_mark_node
)
15089 return error_mark_node
;
15091 /* Handle ordinary C++ destructors. */
15092 type
= TREE_TYPE (decl
);
15093 if (type_build_dtor_call (type
))
15095 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
15099 if (TREE_CODE (type
) == ARRAY_TYPE
)
15102 addr
= build_address (decl
);
15104 call
= build_delete (TREE_TYPE (addr
), addr
,
15105 sfk_complete_destructor
, flags
, 0, complain
);
15106 if (call
== error_mark_node
)
15107 cleanup
= error_mark_node
;
15108 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
15109 /* Discard the call. */;
15111 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
15116 /* build_delete sets the location of the destructor call to the
15117 current location, even though the destructor is going to be
15118 called later, at the end of the current scope. This can lead to
15119 a "jumpy" behavior for users of debuggers when they step around
15120 the end of the block. So let's unset the location of the
15121 destructor call instead. */
15122 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
15126 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
15127 /* Treat objects with destructors as used; the destructor may do
15128 something substantive. */
15129 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
15130 return error_mark_node
;
15136 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
15137 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
15138 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
15141 static_fn_type (tree memfntype
)
15146 if (TYPE_PTRMEMFUNC_P (memfntype
))
15147 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
15148 if (POINTER_TYPE_P (memfntype
)
15149 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
15150 memfntype
= TREE_TYPE (memfntype
);
15151 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
15153 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
15154 args
= TYPE_ARG_TYPES (memfntype
);
15155 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
15156 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
15157 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
15158 fntype
= (cp_build_type_attribute_variant
15159 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
15160 fntype
= (build_exception_variant
15161 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
15162 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
15163 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
15167 /* DECL was originally constructed as a non-static member function,
15168 but turned out to be static. Update it accordingly. */
15171 revert_static_member_fn (tree decl
)
15173 tree stype
= static_fn_type (decl
);
15174 cp_cv_quals quals
= type_memfn_quals (stype
);
15175 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
15177 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
15178 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
15180 TREE_TYPE (decl
) = stype
;
15182 if (DECL_ARGUMENTS (decl
))
15183 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
15184 DECL_STATIC_FUNCTION_P (decl
) = 1;
15187 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
15188 one of the language-independent trees. */
15190 enum cp_tree_node_structure_enum
15191 cp_tree_node_structure (union lang_tree_node
* t
)
15193 switch (TREE_CODE (&t
->generic
))
15195 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
15196 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
15197 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
15198 case OVERLOAD
: return TS_CP_OVERLOAD
;
15199 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
15200 case PTRMEM_CST
: return TS_CP_PTRMEM
;
15201 case BASELINK
: return TS_CP_BASELINK
;
15202 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
15203 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
15204 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
15205 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
15206 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
15207 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
15208 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
15209 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
15210 default: return TS_CP_GENERIC
;
15214 /* Build the void_list_node (void_type_node having been created). */
15216 build_void_list_node (void)
15218 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
15223 cp_missing_noreturn_ok_p (tree decl
)
15225 /* A missing noreturn is ok for the `main' function. */
15226 return DECL_MAIN_P (decl
);
15229 /* Return the decl used to identify the COMDAT group into which DECL should
15233 cxx_comdat_group (tree decl
)
15235 /* Virtual tables, construction virtual tables, and virtual table
15236 tables all go in a single COMDAT group, named after the primary
15238 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
15239 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
15240 /* For all other DECLs, the COMDAT group is the mangled name of the
15241 declaration itself. */
15244 while (DECL_THUNK_P (decl
))
15246 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
15247 into the same section as the target function. In that case
15248 we must return target's name. */
15249 tree target
= THUNK_TARGET (decl
);
15250 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
15251 && DECL_SECTION_NAME (target
) != NULL
15252 && DECL_ONE_ONLY (target
))
15262 /* Returns the return type for FN as written by the user, which may include
15263 a placeholder for a deduced return type. */
15266 fndecl_declared_return_type (tree fn
)
15268 fn
= STRIP_TEMPLATE (fn
);
15269 if (FNDECL_USED_AUTO (fn
))
15271 struct language_function
*f
= NULL
;
15272 if (DECL_STRUCT_FUNCTION (fn
))
15273 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
15275 f
= DECL_SAVED_FUNCTION_DATA (fn
);
15276 return f
->x_auto_return_pattern
;
15278 return TREE_TYPE (TREE_TYPE (fn
));
15281 /* Returns true iff DECL was declared with an auto return type and it has
15282 not yet been deduced to a real type. */
15285 undeduced_auto_decl (tree decl
)
15287 if (cxx_dialect
< cxx14
)
15289 return type_uses_auto (TREE_TYPE (decl
));
15292 /* Complain if DECL has an undeduced return type. */
15295 require_deduced_type (tree decl
)
15297 if (undeduced_auto_decl (decl
))
15298 error ("use of %qD before deduction of %<auto%>", decl
);
15301 #include "gt-cp-decl.h"