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_at (DECL_SOURCE_LOCATION (decl
),
918 OPT_Wunused_function
,
919 "%qF declared %<static%> but never defined", decl
);
920 TREE_NO_WARNING (decl
) = 1;
924 /* Write out any globals that need to be output. */
925 return wrapup_global_declarations (vec
, len
);
928 /* In C++, you don't have to write `struct S' to refer to `S'; you
929 can just use `S'. We accomplish this by creating a TYPE_DECL as
930 if the user had written `typedef struct S S'. Create and return
931 the TYPE_DECL for TYPE. */
934 create_implicit_typedef (tree name
, tree type
)
938 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
939 DECL_ARTIFICIAL (decl
) = 1;
940 /* There are other implicit type declarations, like the one *within*
941 a class that allows you to write `S::S'. We must distinguish
943 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
944 TYPE_NAME (type
) = decl
;
945 TYPE_STUB_DECL (type
) = decl
;
950 /* Remember a local name for name-mangling purposes. */
953 push_local_name (tree decl
)
958 timevar_start (TV_NAME_LOOKUP
);
960 name
= DECL_NAME (decl
);
962 nelts
= vec_safe_length (local_names
);
963 for (i
= 0; i
< nelts
; i
++)
965 t
= (*local_names
)[i
];
966 if (DECL_NAME (t
) == name
)
968 if (!DECL_LANG_SPECIFIC (decl
))
969 retrofit_lang_decl (decl
);
970 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
971 if (DECL_DISCRIMINATOR_SET_P (t
))
972 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
974 DECL_DISCRIMINATOR (decl
) = 1;
976 (*local_names
)[i
] = decl
;
977 timevar_stop (TV_NAME_LOOKUP
);
982 vec_safe_push (local_names
, decl
);
983 timevar_stop (TV_NAME_LOOKUP
);
986 /* Subroutine of duplicate_decls: return truthvalue of whether
987 or not types of these decls match.
989 For C++, we must compare the parameter list so that `int' can match
990 `int&' in a parameter position, but `int&' is not confused with
994 decls_match (tree newdecl
, tree olddecl
)
998 if (newdecl
== olddecl
)
1001 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
1002 /* If the two DECLs are not even the same kind of thing, we're not
1003 interested in their types. */
1006 gcc_assert (DECL_P (newdecl
));
1008 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1010 tree f1
= TREE_TYPE (newdecl
);
1011 tree f2
= TREE_TYPE (olddecl
);
1012 tree p1
= TYPE_ARG_TYPES (f1
);
1013 tree p2
= TYPE_ARG_TYPES (f2
);
1016 /* Specializations of different templates are different functions
1017 even if they have the same type. */
1018 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
1019 ? DECL_TI_TEMPLATE (newdecl
)
1021 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
1022 ? DECL_TI_TEMPLATE (olddecl
)
1027 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1028 && ! (DECL_EXTERN_C_P (newdecl
)
1029 && DECL_EXTERN_C_P (olddecl
)))
1032 /* A new declaration doesn't match a built-in one unless it
1033 is also extern "C". */
1034 if (DECL_IS_BUILTIN (olddecl
)
1035 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1038 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1041 /* A declaration with deduced return type should use its pre-deduction
1042 type for declaration matching. */
1043 r2
= fndecl_declared_return_type (olddecl
);
1045 if (same_type_p (TREE_TYPE (f1
), r2
))
1047 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1048 && (DECL_BUILT_IN (olddecl
)
1049 #ifndef NO_IMPLICIT_EXTERN_C
1050 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1051 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1055 types_match
= self_promoting_args_p (p1
);
1056 if (p1
== void_list_node
)
1057 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1059 #ifndef NO_IMPLICIT_EXTERN_C
1060 else if (!prototype_p (f1
)
1061 && (DECL_EXTERN_C_P (olddecl
)
1062 && DECL_IN_SYSTEM_HEADER (olddecl
)
1063 && !DECL_CLASS_SCOPE_P (olddecl
))
1064 && (DECL_EXTERN_C_P (newdecl
)
1065 && DECL_IN_SYSTEM_HEADER (newdecl
)
1066 && !DECL_CLASS_SCOPE_P (newdecl
)))
1068 types_match
= self_promoting_args_p (p2
);
1069 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1075 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1076 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1077 || comp_type_attributes (TREE_TYPE (newdecl
),
1078 TREE_TYPE (olddecl
)) != 0);
1083 /* The decls dont match if they correspond to two different versions
1084 of the same function. Disallow extern "C" functions to be
1085 versions for now. */
1087 && !DECL_EXTERN_C_P (newdecl
)
1088 && !DECL_EXTERN_C_P (olddecl
)
1089 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1091 /* Mark functions as versions if necessary. Modify the mangled decl
1092 name if necessary. */
1093 if (DECL_FUNCTION_VERSIONED (newdecl
)
1094 && DECL_FUNCTION_VERSIONED (olddecl
))
1096 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1098 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1099 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1100 mangle_decl (newdecl
);
1102 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1104 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1105 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1106 mangle_decl (olddecl
);
1108 cgraph_node::record_function_versions (olddecl
, newdecl
);
1112 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1114 tree oldres
= DECL_TEMPLATE_RESULT (olddecl
);
1115 tree newres
= DECL_TEMPLATE_RESULT (newdecl
);
1117 if (TREE_CODE (newres
) != TREE_CODE (oldres
))
1120 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1121 DECL_TEMPLATE_PARMS (olddecl
)))
1124 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1125 types_match
= (same_type_p (TREE_TYPE (oldres
), TREE_TYPE (newres
))
1126 && equivalently_constrained (olddecl
, newdecl
));
1128 // We don't need to check equivalently_constrained for variable and
1129 // function templates because we check it on the results.
1130 types_match
= decls_match (oldres
, newres
);
1134 /* Need to check scope for variable declaration (VAR_DECL).
1135 For typedef (TYPE_DECL), scope is ignored. */
1137 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1139 Two declarations for an object with C language linkage
1140 with the same name (ignoring the namespace that qualify
1141 it) that appear in different namespace scopes refer to
1143 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1146 if (TREE_TYPE (newdecl
) == error_mark_node
)
1147 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1148 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1149 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1150 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1153 types_match
= comptypes (TREE_TYPE (newdecl
),
1154 TREE_TYPE (olddecl
),
1155 COMPARE_REDECLARATION
);
1158 // Normal functions can be constrained, as can variable partial
1160 if (types_match
&& VAR_OR_FUNCTION_DECL_P (newdecl
))
1161 types_match
= equivalently_constrained (newdecl
, olddecl
);
1166 /* If NEWDECL is `static' and an `extern' was seen previously,
1167 warn about it. OLDDECL is the previous declaration.
1169 Note that this does not apply to the C++ case of declaring
1170 a variable `extern const' and then later `const'.
1172 Don't complain about built-in functions, since they are beyond
1173 the user's control. */
1176 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1178 if (TREE_CODE (newdecl
) == TYPE_DECL
1179 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1180 || TREE_CODE (newdecl
) == CONST_DECL
1181 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1184 /* Don't get confused by static member functions; that's a different
1186 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1187 && DECL_STATIC_FUNCTION_P (newdecl
))
1190 /* If the old declaration was `static', or the new one isn't, then
1191 everything is OK. */
1192 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1195 /* It's OK to declare a builtin function as `static'. */
1196 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1197 && DECL_ARTIFICIAL (olddecl
))
1200 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1201 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1202 inform (DECL_SOURCE_LOCATION (olddecl
),
1203 "previous declaration of %qD", olddecl
);
1206 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1207 function templates. If their exception specifications do not
1208 match, issue a diagnostic. */
1211 check_redeclaration_exception_specification (tree new_decl
,
1214 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1215 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1217 /* Two default specs are equivalent, don't force evaluation. */
1218 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1219 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1222 maybe_instantiate_noexcept (new_decl
);
1223 maybe_instantiate_noexcept (old_decl
);
1224 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1225 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1229 If any declaration of a function has an exception-specification,
1230 all declarations, including the definition and an explicit
1231 specialization, of that function shall have an
1232 exception-specification with the same set of type-ids. */
1233 if (! DECL_IS_BUILTIN (old_decl
)
1234 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1237 = "declaration of %qF has a different exception specifier";
1238 bool complained
= true;
1239 location_t new_loc
= DECL_SOURCE_LOCATION (new_decl
);
1240 if (DECL_IN_SYSTEM_HEADER (old_decl
))
1241 complained
= pedwarn (new_loc
, OPT_Wsystem_headers
, msg
, new_decl
);
1242 else if (!flag_exceptions
)
1243 /* We used to silently permit mismatched eh specs with
1244 -fno-exceptions, so make them a pedwarn now. */
1245 complained
= pedwarn (new_loc
, OPT_Wpedantic
, msg
, new_decl
);
1247 error_at (new_loc
, msg
, new_decl
);
1249 inform (DECL_SOURCE_LOCATION (old_decl
),
1250 "from previous declaration %qF", old_decl
);
1254 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1255 Otherwise issue diagnostics. */
1258 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1260 old_decl
= STRIP_TEMPLATE (old_decl
);
1261 new_decl
= STRIP_TEMPLATE (new_decl
);
1262 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1263 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1265 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1266 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1268 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1270 if (DECL_BUILT_IN (old_decl
))
1272 /* Hide a built-in declaration. */
1273 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1274 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1277 /* 7.1.5 [dcl.constexpr]
1278 Note: An explicit specialization can differ from the template
1279 declaration with respect to the constexpr specifier. */
1280 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1281 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1284 error ("redeclaration %q+D differs in %<constexpr%>", new_decl
);
1285 error ("from previous declaration %q+D", old_decl
);
1291 // If OLDDECL and NEWDECL are concept declarations with the same type
1292 // (i.e., and template parameters), but different requirements,
1293 // emit diagnostics and return true. Otherwise, return false.
1295 check_concept_refinement (tree olddecl
, tree newdecl
)
1297 if (!DECL_DECLARED_CONCEPT_P (olddecl
) || !DECL_DECLARED_CONCEPT_P (newdecl
))
1300 tree d1
= DECL_TEMPLATE_RESULT (olddecl
);
1301 tree d2
= DECL_TEMPLATE_RESULT (newdecl
);
1302 if (TREE_CODE (d1
) != TREE_CODE (d2
))
1305 tree t1
= TREE_TYPE (d1
);
1306 tree t2
= TREE_TYPE (d2
);
1307 if (TREE_CODE (d1
) == FUNCTION_DECL
)
1309 if (compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
))
1310 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl
),
1311 DECL_TEMPLATE_PARMS (newdecl
))
1312 && !equivalently_constrained (olddecl
, newdecl
))
1314 error ("cannot specialize concept %q#D", olddecl
);
1321 /* DECL is a redeclaration of a function or function template. If
1322 it does have default arguments issue a diagnostic. Note: this
1323 function is used to enforce the requirements in C++11 8.3.6 about
1324 no default arguments in redeclarations. */
1327 check_redeclaration_no_default_args (tree decl
)
1329 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1331 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1332 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1333 if (TREE_PURPOSE (t
))
1335 permerror (DECL_SOURCE_LOCATION (decl
),
1336 "redeclaration of %q#D may not have default "
1342 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1343 && lookup_attribute ("gnu_inline", \
1344 DECL_ATTRIBUTES (fn)))
1346 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1347 If the redeclaration is invalid, a diagnostic is issued, and the
1348 error_mark_node is returned. Otherwise, OLDDECL is returned.
1350 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1353 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1356 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1358 unsigned olddecl_uid
= DECL_UID (olddecl
);
1359 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1360 int new_defines_function
= 0;
1361 tree new_template_info
;
1363 if (newdecl
== olddecl
)
1366 types_match
= decls_match (newdecl
, olddecl
);
1368 /* If either the type of the new decl or the type of the old decl is an
1369 error_mark_node, then that implies that we have already issued an
1370 error (earlier) for some bogus type specification, and in that case,
1371 it is rather pointless to harass the user with yet more error message
1372 about the same declaration, so just pretend the types match here. */
1373 if (TREE_TYPE (newdecl
) == error_mark_node
1374 || TREE_TYPE (olddecl
) == error_mark_node
)
1375 return error_mark_node
;
1377 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1378 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1380 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1381 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1382 && check_raw_literal_operator (olddecl
))
1383 error ("literal operator template %q+D conflicts with"
1384 " raw literal operator %qD", newdecl
, olddecl
);
1385 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1386 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1387 && check_raw_literal_operator (newdecl
))
1388 error ("raw literal operator %q+D conflicts with"
1389 " literal operator template %qD", newdecl
, olddecl
);
1392 if (DECL_P (olddecl
)
1393 && TREE_CODE (newdecl
) == FUNCTION_DECL
1394 && TREE_CODE (olddecl
) == FUNCTION_DECL
1395 && diagnose_mismatched_attributes (olddecl
, newdecl
))
1397 if (DECL_INITIAL (olddecl
))
1398 inform (DECL_SOURCE_LOCATION (olddecl
),
1399 "previous definition of %qD was here", olddecl
);
1401 inform (DECL_SOURCE_LOCATION (olddecl
),
1402 "previous declaration of %qD was here", olddecl
);
1405 /* Check for redeclaration and other discrepancies. */
1406 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1407 && DECL_ARTIFICIAL (olddecl
))
1409 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1410 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1412 /* Avoid warnings redeclaring built-ins which have not been
1413 explicitly declared. */
1414 if (DECL_ANTICIPATED (olddecl
))
1417 /* If you declare a built-in or predefined function name as static,
1418 the old definition is overridden, but optionally warn this was a
1419 bad choice of name. */
1420 if (! TREE_PUBLIC (newdecl
))
1422 warning (OPT_Wshadow
,
1423 DECL_BUILT_IN (olddecl
)
1424 ? G_("shadowing built-in function %q#D")
1425 : G_("shadowing library function %q#D"), olddecl
);
1426 /* Discard the old built-in function. */
1429 /* If the built-in is not ansi, then programs can override
1430 it even globally without an error. */
1431 else if (! DECL_BUILT_IN (olddecl
))
1432 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1433 "library function %q#D redeclared as non-function %q#D",
1436 error ("declaration of %q+#D conflicts with built-in "
1437 "declaration %q#D", newdecl
, olddecl
);
1440 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1442 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1443 error_at (DECL_SOURCE_LOCATION (newdecl
),
1444 "redeclaration of %<pragma omp declare reduction%>");
1445 inform (DECL_SOURCE_LOCATION (olddecl
),
1446 "previous %<pragma omp declare reduction%> declaration");
1447 return error_mark_node
;
1449 else if (!types_match
)
1451 /* Avoid warnings redeclaring built-ins which have not been
1452 explicitly declared. */
1453 if (DECL_ANTICIPATED (olddecl
))
1455 /* Deal with fileptr_type_node. FILE type is not known
1456 at the time we create the builtins. */
1459 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1460 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1462 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1465 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1467 tree t
= TREE_VALUE (t1
);
1470 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1471 == get_identifier ("FILE")
1472 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1474 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1476 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1477 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1478 types_match
= decls_match (newdecl
, olddecl
);
1480 return duplicate_decls (newdecl
, olddecl
,
1482 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1485 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1488 else if ((DECL_EXTERN_C_P (newdecl
)
1489 && DECL_EXTERN_C_P (olddecl
))
1490 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1491 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1493 /* A near match; override the builtin. */
1495 if (TREE_PUBLIC (newdecl
))
1496 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1497 "new declaration %q#D ambiguates built-in "
1498 "declaration %q#D", newdecl
, olddecl
);
1500 warning (OPT_Wshadow
,
1501 DECL_BUILT_IN (olddecl
)
1502 ? G_("shadowing built-in function %q#D")
1503 : G_("shadowing library function %q#D"), olddecl
);
1506 /* Discard the old built-in function. */
1509 /* Replace the old RTL to avoid problems with inlining. */
1510 COPY_DECL_RTL (newdecl
, olddecl
);
1512 /* Even if the types match, prefer the new declarations type for
1513 built-ins which have not been explicitly declared, for
1514 exception lists, etc... */
1515 else if (DECL_IS_BUILTIN (olddecl
))
1517 tree type
= TREE_TYPE (newdecl
);
1518 tree attribs
= (*targetm
.merge_type_attributes
)
1519 (TREE_TYPE (olddecl
), type
);
1521 type
= cp_build_type_attribute_variant (type
, attribs
);
1522 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1525 /* If a function is explicitly declared "throw ()", propagate that to
1526 the corresponding builtin. */
1527 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1528 && DECL_ANTICIPATED (olddecl
)
1529 && TREE_NOTHROW (newdecl
)
1530 && !TREE_NOTHROW (olddecl
))
1532 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1533 tree tmpdecl
= builtin_decl_explicit (fncode
);
1534 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1535 TREE_NOTHROW (tmpdecl
) = 1;
1538 /* Whether or not the builtin can throw exceptions has no
1539 bearing on this declarator. */
1540 TREE_NOTHROW (olddecl
) = 0;
1542 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1544 /* If a builtin function is redeclared as `static', merge
1545 the declarations, but make the original one static. */
1546 DECL_THIS_STATIC (olddecl
) = 1;
1547 TREE_PUBLIC (olddecl
) = 0;
1549 /* Make the old declaration consistent with the new one so
1550 that all remnants of the builtin-ness of this function
1551 will be banished. */
1552 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1553 COPY_DECL_RTL (newdecl
, olddecl
);
1556 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1558 /* C++ Standard, 3.3, clause 4:
1559 "[Note: a namespace name or a class template name must be unique
1560 in its declarative region (7.3.2, clause 14). ]" */
1561 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1562 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1563 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1564 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1565 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1566 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1568 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1569 && TREE_CODE (newdecl
) != TYPE_DECL
)
1570 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1571 && TREE_CODE (olddecl
) != TYPE_DECL
))
1573 /* We do nothing special here, because C++ does such nasty
1574 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1575 get shadowed, and know that if we need to find a TYPE_DECL
1576 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1577 slot of the identifier. */
1581 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1582 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1583 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1584 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1588 error ("%q#D redeclared as different kind of symbol", newdecl
);
1589 if (TREE_CODE (olddecl
) == TREE_LIST
)
1590 olddecl
= TREE_VALUE (olddecl
);
1591 inform (DECL_SOURCE_LOCATION (olddecl
),
1592 "previous declaration %q#D", olddecl
);
1594 return error_mark_node
;
1596 else if (!types_match
)
1598 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1599 /* These are certainly not duplicate declarations; they're
1600 from different scopes. */
1603 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1605 /* The name of a class template may not be declared to refer to
1606 any other template, class, function, object, namespace, value,
1607 or type in the same scope. */
1608 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1609 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1611 error ("conflicting declaration of template %q+#D", newdecl
);
1612 inform (DECL_SOURCE_LOCATION (olddecl
),
1613 "previous declaration %q#D", olddecl
);
1614 return error_mark_node
;
1616 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1617 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1618 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1619 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1620 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1621 DECL_TEMPLATE_PARMS (olddecl
))
1622 /* Template functions can be disambiguated by
1624 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1625 TREE_TYPE (TREE_TYPE (olddecl
)))
1626 // Template functions can also be disambiguated by
1628 && equivalently_constrained (olddecl
, newdecl
))
1630 error ("ambiguating new declaration %q+#D", newdecl
);
1631 inform (DECL_SOURCE_LOCATION (olddecl
),
1632 "old declaration %q#D", olddecl
);
1634 else if (check_concept_refinement (olddecl
, newdecl
))
1635 return error_mark_node
;
1638 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1640 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1642 error ("conflicting declaration of C function %q+#D",
1644 inform (DECL_SOURCE_LOCATION (olddecl
),
1645 "previous declaration %q#D", olddecl
);
1648 /* For function versions, params and types match, but they
1649 are not ambiguous. */
1650 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1651 && !DECL_FUNCTION_VERSIONED (olddecl
))
1652 // The functions have the same parameter types.
1653 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1654 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))
1655 // And the same constraints.
1656 && equivalently_constrained (newdecl
, olddecl
))
1658 error ("ambiguating new declaration of %q+#D", newdecl
);
1659 inform (DECL_SOURCE_LOCATION (olddecl
),
1660 "old declaration %q#D", olddecl
);
1661 return error_mark_node
;
1668 error ("conflicting declaration %q+#D", newdecl
);
1669 inform (DECL_SOURCE_LOCATION (olddecl
),
1670 "previous declaration as %q#D", olddecl
);
1671 return error_mark_node
;
1674 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1675 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1676 && (!DECL_TEMPLATE_INFO (newdecl
)
1677 || (DECL_TI_TEMPLATE (newdecl
)
1678 != DECL_TI_TEMPLATE (olddecl
))))
1679 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1680 && (!DECL_TEMPLATE_INFO (olddecl
)
1681 || (DECL_TI_TEMPLATE (olddecl
)
1682 != DECL_TI_TEMPLATE (newdecl
))))))
1683 /* It's OK to have a template specialization and a non-template
1684 with the same type, or to have specializations of two
1685 different templates with the same type. Note that if one is a
1686 specialization, and the other is an instantiation of the same
1687 template, that we do not exit at this point. That situation
1688 can occur if we instantiate a template class, and then
1689 specialize one of its methods. This situation is valid, but
1690 the declarations must be merged in the usual way. */
1692 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1693 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1694 && !DECL_USE_TEMPLATE (newdecl
))
1695 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1696 && !DECL_USE_TEMPLATE (olddecl
))))
1697 /* One of the declarations is a template instantiation, and the
1698 other is not a template at all. That's OK. */
1700 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1702 /* In [namespace.alias] we have:
1704 In a declarative region, a namespace-alias-definition can be
1705 used to redefine a namespace-alias declared in that declarative
1706 region to refer only to the namespace to which it already
1709 Therefore, if we encounter a second alias directive for the same
1710 alias, we can just ignore the second directive. */
1711 if (DECL_NAMESPACE_ALIAS (newdecl
)
1712 && (DECL_NAMESPACE_ALIAS (newdecl
)
1713 == DECL_NAMESPACE_ALIAS (olddecl
)))
1715 /* [namespace.alias]
1717 A namespace-name or namespace-alias shall not be declared as
1718 the name of any other entity in the same declarative region.
1719 A namespace-name defined at global scope shall not be
1720 declared as the name of any other entity in any global scope
1722 error ("conflicting declaration of namespace %q+D", newdecl
);
1723 inform (DECL_SOURCE_LOCATION (olddecl
),
1724 "previous declaration of namespace %qD here", olddecl
);
1725 return error_mark_node
;
1729 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1732 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1733 if (DECL_NAME (olddecl
) != NULL_TREE
)
1734 inform (DECL_SOURCE_LOCATION (olddecl
),
1735 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1736 ? G_("%q#D previously defined here")
1737 : G_("%q#D previously declared here"), olddecl
);
1738 return error_mark_node
;
1740 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1741 && DECL_INITIAL (olddecl
) != NULL_TREE
1742 && !prototype_p (TREE_TYPE (olddecl
))
1743 && prototype_p (TREE_TYPE (newdecl
)))
1745 /* Prototype decl follows defn w/o prototype. */
1746 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1747 "prototype specified for %q#D", newdecl
))
1748 inform (DECL_SOURCE_LOCATION (olddecl
),
1749 "previous non-prototype definition here");
1751 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1752 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1755 If two declarations of the same function or object
1756 specify different linkage-specifications ..., the program
1757 is ill-formed.... Except for functions with C++ linkage,
1758 a function declaration without a linkage specification
1759 shall not precede the first linkage specification for
1760 that function. A function can be declared without a
1761 linkage specification after an explicit linkage
1762 specification has been seen; the linkage explicitly
1763 specified in the earlier declaration is not affected by
1764 such a function declaration.
1766 DR 563 raises the question why the restrictions on
1767 functions should not also apply to objects. Older
1768 versions of G++ silently ignore the linkage-specification
1776 which is clearly wrong. Therefore, we now treat objects
1778 if (current_lang_depth () == 0)
1780 /* There is no explicit linkage-specification, so we use
1781 the linkage from the previous declaration. */
1782 if (!DECL_LANG_SPECIFIC (newdecl
))
1783 retrofit_lang_decl (newdecl
);
1784 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1788 error ("conflicting declaration of %q+#D with %qL linkage",
1789 newdecl
, DECL_LANGUAGE (newdecl
));
1790 inform (DECL_SOURCE_LOCATION (olddecl
),
1791 "previous declaration with %qL linkage",
1792 DECL_LANGUAGE (olddecl
));
1796 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1798 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1800 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1801 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1802 && (/* grokfndecl passes member function templates too
1803 as FUNCTION_DECLs. */
1804 DECL_TEMPLATE_INFO (olddecl
)
1806 Default arguments for a member function of a class
1807 template shall be specified on the initial declaration
1808 of the member function within the class template. */
1809 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1810 check_redeclaration_no_default_args (newdecl
);
1813 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1814 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1817 for (; t1
&& t1
!= void_list_node
;
1818 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1819 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1821 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1824 if (permerror (input_location
,
1825 "default argument given for parameter "
1826 "%d of %q#D", i
, newdecl
))
1827 inform (DECL_SOURCE_LOCATION (olddecl
),
1828 "previous specification in %q#D here",
1833 error ("default argument given for parameter %d "
1834 "of %q#D", i
, newdecl
);
1835 inform (DECL_SOURCE_LOCATION (olddecl
),
1836 "previous specification in %q#D here",
1844 /* Do not merge an implicit typedef with an explicit one. In:
1848 typedef class A A __attribute__ ((foo));
1850 the attribute should apply only to the typedef. */
1851 if (TREE_CODE (olddecl
) == TYPE_DECL
1852 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1853 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1856 /* If new decl is `static' and an `extern' was seen previously,
1858 warn_extern_redeclared_static (newdecl
, olddecl
);
1860 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1861 return error_mark_node
;
1863 /* We have committed to returning 1 at this point. */
1864 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1866 /* Now that functions must hold information normally held
1867 by field decls, there is extra work to do so that
1868 declaration information does not get destroyed during
1870 if (DECL_VINDEX (olddecl
))
1871 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1872 if (DECL_CONTEXT (olddecl
))
1873 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1874 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1875 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1876 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1877 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1878 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1879 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1880 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1881 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1882 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1883 SET_OVERLOADED_OPERATOR_CODE
1884 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1885 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1887 /* Optionally warn about more than one declaration for the same
1888 name, but don't warn about a function declaration followed by a
1890 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1891 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1892 /* Don't warn about extern decl followed by definition. */
1893 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1894 /* Don't warn about friends, let add_friend take care of it. */
1895 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1896 /* Don't warn about declaration followed by specialization. */
1897 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1898 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1900 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1901 OPT_Wredundant_decls
,
1902 "redundant redeclaration of %qD in same scope",
1904 inform (DECL_SOURCE_LOCATION (olddecl
),
1905 "previous declaration of %qD", olddecl
);
1908 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1909 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1911 if (DECL_DELETED_FN (newdecl
))
1913 error ("deleted definition of %q+D", newdecl
);
1914 inform (DECL_SOURCE_LOCATION (olddecl
),
1915 "previous declaration of %qD", olddecl
);
1917 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1921 /* Deal with C++: must preserve virtual function table size. */
1922 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1924 tree newtype
= TREE_TYPE (newdecl
);
1925 tree oldtype
= TREE_TYPE (olddecl
);
1927 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1928 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1929 CLASSTYPE_FRIEND_CLASSES (newtype
)
1930 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1932 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1935 /* Copy all the DECL_... slots specified in the new decl
1936 except for any that we copy here from the old type. */
1937 DECL_ATTRIBUTES (newdecl
)
1938 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1940 if (DECL_DECLARES_FUNCTION_P (olddecl
) && DECL_DECLARES_FUNCTION_P (newdecl
))
1942 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1943 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1944 && DECL_HIDDEN_FRIEND_P (olddecl
)
1945 && newdecl_is_friend
);
1948 DECL_ANTICIPATED (olddecl
) = 0;
1949 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
1953 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1957 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1958 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1959 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1960 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1961 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1962 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1964 DECL_ATTRIBUTES (old_result
)
1965 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1967 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1969 /* Per C++11 8.3.6/4, default arguments cannot be added in later
1970 declarations of a function template. */
1971 if (DECL_SOURCE_LOCATION (newdecl
)
1972 != DECL_SOURCE_LOCATION (olddecl
))
1973 check_redeclaration_no_default_args (newdecl
);
1975 check_default_args (newdecl
);
1977 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1978 && DECL_INITIAL (new_result
))
1980 if (DECL_INITIAL (old_result
))
1981 DECL_UNINLINABLE (old_result
) = 1;
1983 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1984 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1985 DECL_NOT_REALLY_EXTERN (old_result
)
1986 = DECL_NOT_REALLY_EXTERN (new_result
);
1987 DECL_INTERFACE_KNOWN (old_result
)
1988 = DECL_INTERFACE_KNOWN (new_result
);
1989 DECL_DECLARED_INLINE_P (old_result
)
1990 = DECL_DECLARED_INLINE_P (new_result
);
1991 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1992 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1997 DECL_DECLARED_INLINE_P (old_result
)
1998 |= DECL_DECLARED_INLINE_P (new_result
);
1999 DECL_DISREGARD_INLINE_LIMITS (old_result
)
2000 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
2001 check_redeclaration_exception_specification (newdecl
, olddecl
);
2005 /* If the new declaration is a definition, update the file and
2006 line information on the declaration, and also make
2007 the old declaration the same definition. */
2008 if (DECL_INITIAL (new_result
) != NULL_TREE
)
2010 DECL_SOURCE_LOCATION (olddecl
)
2011 = DECL_SOURCE_LOCATION (old_result
)
2012 = DECL_SOURCE_LOCATION (newdecl
);
2013 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
2014 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
2017 DECL_ARGUMENTS (old_result
)
2018 = DECL_ARGUMENTS (new_result
);
2019 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
2020 parm
= DECL_CHAIN (parm
))
2021 DECL_CONTEXT (parm
) = old_result
;
2030 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2031 check_redeclaration_exception_specification (newdecl
, olddecl
);
2033 /* Automatically handles default parameters. */
2034 tree oldtype
= TREE_TYPE (olddecl
);
2037 /* For typedefs use the old type, as the new type's DECL_NAME points
2038 at newdecl, which will be ggc_freed. */
2039 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2041 /* But NEWTYPE might have an attribute, honor that. */
2042 tree tem
= TREE_TYPE (newdecl
);
2045 if (TYPE_USER_ALIGN (tem
))
2047 if (TYPE_ALIGN (tem
) > TYPE_ALIGN (newtype
))
2048 SET_TYPE_ALIGN (newtype
, TYPE_ALIGN (tem
));
2049 TYPE_USER_ALIGN (newtype
) = true;
2052 /* And remove the new type from the variants list. */
2053 if (TYPE_NAME (TREE_TYPE (newdecl
)) == newdecl
)
2055 tree remove
= TREE_TYPE (newdecl
);
2056 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2057 t
= TYPE_NEXT_VARIANT (t
))
2058 if (TYPE_NEXT_VARIANT (t
) == remove
)
2060 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2066 /* Merge the data types specified in the two decls. */
2067 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2069 if (VAR_P (newdecl
))
2071 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2072 /* For already initialized vars, TREE_READONLY could have been
2073 cleared in cp_finish_decl, because the var needs runtime
2074 initialization or destruction. Make sure not to set
2075 TREE_READONLY on it again. */
2076 if (DECL_INITIALIZED_P (olddecl
)
2077 && !DECL_EXTERNAL (olddecl
)
2078 && !TREE_READONLY (olddecl
))
2079 TREE_READONLY (newdecl
) = 0;
2080 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2081 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2082 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2083 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2084 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2086 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2087 if (DECL_LANG_SPECIFIC (olddecl
)
2088 && CP_DECL_THREADPRIVATE_P (olddecl
))
2090 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2091 if (!DECL_LANG_SPECIFIC (newdecl
))
2092 retrofit_lang_decl (newdecl
);
2094 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2098 /* An explicit specialization of a function template or of a member
2099 function of a class template can be declared transaction_safe
2100 independently of whether the corresponding template entity is declared
2101 transaction_safe. */
2102 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2103 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2104 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2105 && tx_safe_fn_type_p (newtype
)
2106 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2107 newtype
= tx_unsafe_fn_variant (newtype
);
2109 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2111 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2112 check_default_args (newdecl
);
2114 /* Lay the type out, unless already done. */
2115 if (! same_type_p (newtype
, oldtype
)
2116 && TREE_TYPE (newdecl
) != error_mark_node
2117 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2118 layout_type (TREE_TYPE (newdecl
));
2120 if ((VAR_P (newdecl
)
2121 || TREE_CODE (newdecl
) == PARM_DECL
2122 || TREE_CODE (newdecl
) == RESULT_DECL
2123 || TREE_CODE (newdecl
) == FIELD_DECL
2124 || TREE_CODE (newdecl
) == TYPE_DECL
)
2125 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2126 layout_decl (newdecl
, 0);
2128 /* Merge the type qualifiers. */
2129 if (TREE_READONLY (newdecl
))
2130 TREE_READONLY (olddecl
) = 1;
2131 if (TREE_THIS_VOLATILE (newdecl
))
2132 TREE_THIS_VOLATILE (olddecl
) = 1;
2133 if (TREE_NOTHROW (newdecl
))
2134 TREE_NOTHROW (olddecl
) = 1;
2136 /* Merge deprecatedness. */
2137 if (TREE_DEPRECATED (newdecl
))
2138 TREE_DEPRECATED (olddecl
) = 1;
2140 /* Preserve function specific target and optimization options */
2141 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2143 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2144 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2145 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2146 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2148 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2149 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2150 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2151 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2154 /* Merge the initialization information. */
2155 if (DECL_INITIAL (newdecl
) == NULL_TREE
2156 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2158 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2159 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2160 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2162 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2163 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2167 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2169 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2170 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2171 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2172 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2173 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2174 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2175 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2176 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2177 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2178 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2179 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2180 /* Keep the old RTL. */
2181 COPY_DECL_RTL (olddecl
, newdecl
);
2183 else if (VAR_P (newdecl
)
2184 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2186 /* Keep the old RTL. We cannot keep the old RTL if the old
2187 declaration was for an incomplete object and the new
2188 declaration is not since many attributes of the RTL will
2190 COPY_DECL_RTL (olddecl
, newdecl
);
2193 /* If cannot merge, then use the new type and qualifiers,
2194 and don't preserve the old rtl. */
2197 /* Clean out any memory we had of the old declaration. */
2198 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2200 TREE_VALUE (oldstatic
) = error_mark_node
;
2202 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2203 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2204 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2205 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2208 /* Merge the storage class information. */
2209 merge_weak (newdecl
, olddecl
);
2211 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2212 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2213 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2214 if (! DECL_EXTERNAL (olddecl
))
2215 DECL_EXTERNAL (newdecl
) = 0;
2216 if (! DECL_COMDAT (olddecl
))
2217 DECL_COMDAT (newdecl
) = 0;
2219 new_template_info
= NULL_TREE
;
2220 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2222 bool new_redefines_gnu_inline
= false;
2224 if (new_defines_function
2225 && ((DECL_INTERFACE_KNOWN (olddecl
)
2226 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2227 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2228 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2229 == FUNCTION_DECL
))))
2233 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2234 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2236 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2239 if (!new_redefines_gnu_inline
)
2241 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2242 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2243 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2245 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2246 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2247 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2249 /* If the OLDDECL is an instantiation and/or specialization,
2250 then the NEWDECL must be too. But, it may not yet be marked
2251 as such if the caller has created NEWDECL, but has not yet
2252 figured out that it is a redeclaration. */
2253 if (!DECL_USE_TEMPLATE (newdecl
))
2254 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2256 /* Don't really know how much of the language-specific
2257 values we should copy from old to new. */
2258 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2259 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2260 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2261 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2263 if (LANG_DECL_HAS_MIN (newdecl
))
2265 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2266 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2267 if (DECL_TEMPLATE_INFO (newdecl
))
2269 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2270 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2271 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2272 /* Remember the presence of explicit specialization args. */
2273 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2274 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2276 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2278 /* Only functions have these fields. */
2279 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2281 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2282 DECL_BEFRIENDING_CLASSES (newdecl
)
2283 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2284 DECL_BEFRIENDING_CLASSES (olddecl
));
2285 /* DECL_THUNKS is only valid for virtual functions,
2286 otherwise it is a DECL_FRIEND_CONTEXT. */
2287 if (DECL_VIRTUAL_P (newdecl
))
2288 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2290 /* Only variables have this field. */
2291 else if (VAR_P (newdecl
)
2292 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2293 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2296 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2300 /* Merge parameter attributes. */
2301 tree oldarg
, newarg
;
2302 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2303 newarg
= DECL_ARGUMENTS(newdecl
);
2305 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2306 DECL_ATTRIBUTES (newarg
)
2307 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2308 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2311 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2312 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2314 /* If newdecl is not a specialization, then it is not a
2315 template-related function at all. And that means that we
2316 should have exited above, returning 0. */
2317 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2319 if (DECL_ODR_USED (olddecl
))
2320 /* From [temp.expl.spec]:
2322 If a template, a member template or the member of a class
2323 template is explicitly specialized then that
2324 specialization shall be declared before the first use of
2325 that specialization that would cause an implicit
2326 instantiation to take place, in every translation unit in
2327 which such a use occurs. */
2328 error ("explicit specialization of %qD after first use",
2331 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2332 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2333 && DECL_DECLARED_INLINE_P (newdecl
));
2335 /* Don't propagate visibility from the template to the
2336 specialization here. We'll do that in determine_visibility if
2338 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2340 /* [temp.expl.spec/14] We don't inline explicit specialization
2341 just because the primary template says so. */
2343 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2344 the always_inline attribute. */
2345 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2346 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2348 if (DECL_DECLARED_INLINE_P (newdecl
))
2349 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2351 DECL_ATTRIBUTES (newdecl
)
2352 = remove_attribute ("always_inline",
2353 DECL_ATTRIBUTES (newdecl
));
2356 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2358 /* Never inline re-defined extern inline functions.
2359 FIXME: this could be better handled by keeping both
2360 function as separate declarations. */
2361 DECL_UNINLINABLE (newdecl
) = 1;
2365 if (DECL_PENDING_INLINE_P (olddecl
))
2367 DECL_PENDING_INLINE_P (newdecl
) = 1;
2368 DECL_PENDING_INLINE_INFO (newdecl
)
2369 = DECL_PENDING_INLINE_INFO (olddecl
);
2371 else if (DECL_PENDING_INLINE_P (newdecl
))
2373 else if (DECL_SAVED_FUNCTION_DATA (newdecl
) == NULL
)
2374 DECL_SAVED_FUNCTION_DATA (newdecl
)
2375 = DECL_SAVED_FUNCTION_DATA (olddecl
);
2377 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2379 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2380 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2382 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2383 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2384 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2385 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2388 /* Preserve abstractness on cloned [cd]tors. */
2389 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2391 /* Update newdecl's parms to point at olddecl. */
2392 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2393 parm
= DECL_CHAIN (parm
))
2394 DECL_CONTEXT (parm
) = olddecl
;
2398 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2399 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2400 COPY_DECL_RTL (newdecl
, olddecl
);
2402 if (! types_match
|| new_defines_function
)
2404 /* These need to be copied so that the names are available.
2405 Note that if the types do match, we'll preserve inline
2406 info and other bits, but if not, we won't. */
2407 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2408 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2410 /* If redeclaring a builtin function, it stays built in
2411 if newdecl is a gnu_inline definition, or if newdecl is just
2413 if (DECL_BUILT_IN (olddecl
)
2414 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2416 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2417 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2418 /* If we're keeping the built-in definition, keep the rtl,
2419 regardless of declaration matches. */
2420 COPY_DECL_RTL (olddecl
, newdecl
);
2421 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2423 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2426 /* If a compatible prototype of these builtin functions
2427 is seen, assume the runtime implements it with the
2428 expected semantics. */
2429 case BUILT_IN_STPCPY
:
2430 if (builtin_decl_explicit_p (fncode
))
2431 set_builtin_decl_implicit_p (fncode
, true);
2434 if (builtin_decl_explicit_p (fncode
))
2435 set_builtin_decl_declared_p (fncode
, true);
2440 if (new_defines_function
)
2441 /* If defining a function declared with other language
2442 linkage, use the previously declared language linkage. */
2443 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2444 else if (types_match
)
2446 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2447 /* Don't clear out the arguments if we're just redeclaring a
2449 if (DECL_ARGUMENTS (olddecl
))
2450 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2453 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2454 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2456 /* Now preserve various other info from the definition. */
2457 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2458 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2459 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2460 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2462 /* Warn about conflicting visibility specifications. */
2463 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2464 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2465 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2467 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2468 "%qD: visibility attribute ignored because it "
2469 "conflicts with previous declaration", newdecl
))
2470 inform (DECL_SOURCE_LOCATION (olddecl
),
2471 "previous declaration of %qD", olddecl
);
2473 /* Choose the declaration which specified visibility. */
2474 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2476 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2477 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2479 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2480 so keep this behavior. */
2481 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2483 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2484 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2486 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2487 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2489 SET_DECL_ALIGN (newdecl
, DECL_ALIGN (olddecl
));
2490 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2492 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2493 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2494 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2496 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2497 with that from NEWDECL below. */
2498 if (DECL_LANG_SPECIFIC (olddecl
))
2500 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2501 != DECL_LANG_SPECIFIC (newdecl
));
2502 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2505 /* Merge the USED information. */
2506 if (TREE_USED (olddecl
))
2507 TREE_USED (newdecl
) = 1;
2508 else if (TREE_USED (newdecl
))
2509 TREE_USED (olddecl
) = 1;
2510 if (VAR_P (newdecl
))
2512 if (DECL_READ_P (olddecl
))
2513 DECL_READ_P (newdecl
) = 1;
2514 else if (DECL_READ_P (newdecl
))
2515 DECL_READ_P (olddecl
) = 1;
2517 if (DECL_PRESERVE_P (olddecl
))
2518 DECL_PRESERVE_P (newdecl
) = 1;
2519 else if (DECL_PRESERVE_P (newdecl
))
2520 DECL_PRESERVE_P (olddecl
) = 1;
2522 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2523 to olddecl and deleted. */
2524 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2525 && DECL_FUNCTION_VERSIONED (olddecl
))
2527 /* Set the flag for newdecl so that it gets copied to olddecl. */
2528 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2529 /* newdecl will be purged after copying to olddecl and is no longer
2531 cgraph_node::delete_function_version (newdecl
);
2534 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2537 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2539 function_size
= sizeof (struct tree_decl_common
);
2541 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2542 (char *) newdecl
+ sizeof (struct tree_common
),
2543 function_size
- sizeof (struct tree_common
));
2545 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2546 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2547 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2549 /* Preserve symtab node mapping. */
2550 olddecl
->decl_with_vis
.symtab_node
= snode
;
2552 if (new_template_info
)
2553 /* If newdecl is a template instantiation, it is possible that
2554 the following sequence of events has occurred:
2556 o A friend function was declared in a class template. The
2557 class template was instantiated.
2559 o The instantiation of the friend declaration was
2560 recorded on the instantiation list, and is newdecl.
2562 o Later, however, instantiate_class_template called pushdecl
2563 on the newdecl to perform name injection. But, pushdecl in
2564 turn called duplicate_decls when it discovered that another
2565 declaration of a global function with the same name already
2568 o Here, in duplicate_decls, we decided to clobber newdecl.
2570 If we're going to do that, we'd better make sure that
2571 olddecl, and not newdecl, is on the list of
2572 instantiations so that if we try to do the instantiation
2573 again we won't get the clobbered declaration. */
2574 reregister_specialization (newdecl
,
2580 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2582 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2583 (char *) newdecl
+ sizeof (struct tree_common
),
2584 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2585 switch (TREE_CODE (newdecl
))
2595 struct symtab_node
*snode
= NULL
;
2598 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2599 || DECL_EXTERNAL (olddecl
)))
2600 snode
= symtab_node::get (olddecl
);
2601 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2602 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2603 size
- sizeof (struct tree_decl_common
)
2604 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2605 if (VAR_P (newdecl
))
2606 olddecl
->decl_with_vis
.symtab_node
= snode
;
2610 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2611 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2612 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2613 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2618 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2620 if (DECL_EXTERNAL (olddecl
)
2621 || TREE_PUBLIC (olddecl
)
2622 || TREE_STATIC (olddecl
))
2624 /* Merge the section attribute.
2625 We want to issue an error if the sections conflict but that must be
2626 done later in decl_attributes since we are called before attributes
2628 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2629 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2631 if (DECL_ONE_ONLY (newdecl
))
2633 struct symtab_node
*oldsym
, *newsym
;
2634 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2635 oldsym
= cgraph_node::get_create (olddecl
);
2637 oldsym
= varpool_node::get_create (olddecl
);
2638 newsym
= symtab_node::get (newdecl
);
2639 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2644 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2646 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2647 if (!processing_template_decl
)
2648 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2652 DECL_UID (olddecl
) = olddecl_uid
;
2654 DECL_FRIEND_P (olddecl
) = 1;
2657 DECL_ANTICIPATED (olddecl
) = 1;
2658 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2661 /* NEWDECL contains the merged attribute lists.
2662 Update OLDDECL to be the same. */
2663 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2665 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2666 so that encode_section_info has a chance to look at the new decl
2667 flags and attributes. */
2668 if (DECL_RTL_SET_P (olddecl
)
2669 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2671 && TREE_STATIC (olddecl
))))
2672 make_decl_rtl (olddecl
);
2674 /* The NEWDECL will no longer be needed. Because every out-of-class
2675 declaration of a member results in a call to duplicate_decls,
2676 freeing these nodes represents in a significant savings.
2678 Before releasing the node, be sore to remove function from symbol
2679 table that might have been inserted there to record comdat group.
2680 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2681 structure is shared in between newdecl and oldecl. */
2682 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2683 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2684 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2686 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2691 /* Remove the associated constraints for newdecl, if any, before
2692 reclaiming memory. */
2694 remove_constraints (newdecl
);
2701 /* Return zero if the declaration NEWDECL is valid
2702 when the declaration OLDDECL (assumed to be for the same name)
2703 has already been seen.
2704 Otherwise return an error message format string with a %s
2705 where the identifier should go. */
2708 redeclaration_error_message (tree newdecl
, tree olddecl
)
2710 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2712 /* Because C++ can put things into name space for free,
2713 constructs like "typedef struct foo { ... } foo"
2714 would look like an erroneous redeclaration. */
2715 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2718 return G_("redefinition of %q#D");
2720 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2722 /* If this is a pure function, its olddecl will actually be
2723 the original initialization to `0' (which we force to call
2724 abort()). Don't complain about redefinition in this case. */
2725 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2726 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2729 /* If both functions come from different namespaces, this is not
2730 a redeclaration - this is a conflict with a used function. */
2731 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2732 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2733 && ! decls_match (olddecl
, newdecl
))
2734 return G_("%qD conflicts with used function");
2736 /* We'll complain about linkage mismatches in
2737 warn_extern_redeclared_static. */
2739 /* Defining the same name twice is no good. */
2740 if (DECL_INITIAL (olddecl
) != NULL_TREE
2741 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2743 if (DECL_NAME (olddecl
) == NULL_TREE
)
2744 return G_("%q#D not declared in class");
2745 else if (!GNU_INLINE_P (olddecl
)
2746 || GNU_INLINE_P (newdecl
))
2747 return G_("redefinition of %q#D");
2750 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2752 bool olda
= GNU_INLINE_P (olddecl
);
2753 bool newa
= GNU_INLINE_P (newdecl
);
2758 return G_("%q+D redeclared inline with "
2759 "%<gnu_inline%> attribute");
2761 return G_("%q+D redeclared inline without "
2762 "%<gnu_inline%> attribute");
2766 check_abi_tag_redeclaration
2767 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2768 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2772 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2776 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2778 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2779 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2780 return G_("redefinition of %q#D");
2784 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2785 || (DECL_TEMPLATE_RESULT (newdecl
)
2786 == DECL_TEMPLATE_RESULT (olddecl
)))
2789 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2790 if (DECL_TEMPLATE_INFO (nt
))
2791 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2792 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2793 if (DECL_TEMPLATE_INFO (ot
))
2794 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2795 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2796 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2797 return G_("redefinition of %q#D");
2799 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2801 bool olda
= GNU_INLINE_P (ot
);
2802 bool newa
= GNU_INLINE_P (nt
);
2807 return G_("%q+D redeclared inline with "
2808 "%<gnu_inline%> attribute");
2810 return G_("%q+D redeclared inline without "
2811 "%<gnu_inline%> attribute");
2815 /* Core issue #226 (C++0x):
2817 If a friend function template declaration specifies a
2818 default template-argument, that declaration shall be a
2819 definition and shall be the only declaration of the
2820 function template in the translation unit. */
2821 if ((cxx_dialect
!= cxx98
)
2822 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2823 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2824 /*is_primary=*/true,
2825 /*is_partial=*/false,
2826 /*is_friend_decl=*/2))
2827 return G_("redeclaration of friend %q#D "
2828 "may not have default template arguments");
2832 else if (VAR_P (newdecl
)
2833 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2834 && (! DECL_LANG_SPECIFIC (olddecl
)
2835 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2836 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2838 /* Only variables can be thread-local, and all declarations must
2839 agree on this property. */
2840 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2841 return G_("thread-local declaration of %q#D follows "
2842 "non-thread-local declaration");
2844 return G_("non-thread-local declaration of %q#D follows "
2845 "thread-local declaration");
2847 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2849 /* The objects have been declared at namespace scope. If either
2850 is a member of an anonymous union, then this is an invalid
2851 redeclaration. For example:
2857 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2858 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2859 return G_("redeclaration of %q#D");
2860 /* If at least one declaration is a reference, there is no
2861 conflict. For example:
2867 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2869 /* Reject two definitions. */
2870 return G_("redefinition of %q#D");
2874 /* Objects declared with block scope: */
2875 /* Reject two definitions, and reject a definition
2876 together with an external reference. */
2877 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2878 return G_("redeclaration of %q#D");
2883 /* Hash and equality functions for the named_label table. */
2886 named_label_hasher::hash (named_label_entry
*ent
)
2888 return DECL_UID (ent
->label_decl
);
2892 named_label_hasher::equal (named_label_entry
*a
, named_label_entry
*b
)
2894 return a
->label_decl
== b
->label_decl
;
2897 /* Create a new label, named ID. */
2900 make_label_decl (tree id
, int local_p
)
2902 struct named_label_entry
*ent
;
2905 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2907 DECL_CONTEXT (decl
) = current_function_decl
;
2908 DECL_MODE (decl
) = VOIDmode
;
2909 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2911 /* Say where one reference is to the label, for the sake of the
2912 error if it is not defined. */
2913 DECL_SOURCE_LOCATION (decl
) = input_location
;
2915 /* Record the fact that this identifier is bound to this label. */
2916 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2918 /* Create the label htab for the function on demand. */
2920 named_labels
= hash_table
<named_label_hasher
>::create_ggc (13);
2922 /* Record this label on the list of labels used in this function.
2923 We do this before calling make_label_decl so that we get the
2924 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2925 ent
= ggc_cleared_alloc
<named_label_entry
> ();
2926 ent
->label_decl
= decl
;
2928 named_label_entry
**slot
= named_labels
->find_slot (ent
, INSERT
);
2929 gcc_assert (*slot
== NULL
);
2935 /* Look for a label named ID in the current function. If one cannot
2936 be found, create one. (We keep track of used, but undefined,
2937 labels, and complain about them at the end of a function.) */
2940 lookup_label_1 (tree id
)
2944 /* You can't use labels at global scope. */
2945 if (current_function_decl
== NULL_TREE
)
2947 error ("label %qE referenced outside of any function", id
);
2951 /* See if we've already got this label. */
2952 decl
= IDENTIFIER_LABEL_VALUE (id
);
2953 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2956 decl
= make_label_decl (id
, /*local_p=*/0);
2960 /* Wrapper for lookup_label_1. */
2963 lookup_label (tree id
)
2966 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2967 ret
= lookup_label_1 (id
);
2968 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2972 /* Declare a local label named ID. */
2975 declare_local_label (tree id
)
2978 cp_label_binding bind
;
2980 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2981 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2982 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2984 decl
= make_label_decl (id
, /*local_p=*/1);
2986 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2991 /* Returns nonzero if it is ill-formed to jump past the declaration of
2992 DECL. Returns 2 if it's also a real problem. */
2995 decl_jump_unsafe (tree decl
)
2997 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2998 with automatic storage duration is not in scope to a point where it is
2999 in scope is ill-formed unless the variable has scalar type, class type
3000 with a trivial default constructor and a trivial destructor, a
3001 cv-qualified version of one of these types, or an array of one of the
3002 preceding types and is declared without an initializer (8.5). */
3003 tree type
= TREE_TYPE (decl
);
3005 if (!VAR_P (decl
) || TREE_STATIC (decl
)
3006 || type
== error_mark_node
)
3009 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
3010 || variably_modified_type_p (type
, NULL_TREE
))
3013 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3019 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3023 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
3024 diagnostic_t diag_kind
)
3027 = (decl
? emit_diagnostic (diag_kind
, loc
, 0, "jump to label %qD", decl
)
3028 : emit_diagnostic (diag_kind
, loc
, 0, "jump to case label"));
3029 if (complained
&& locus
)
3030 inform (*locus
, " from here");
3034 /* Check that a single previously seen jump to a newly defined label
3035 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3036 the jump context; NAMES are the names in scope in LEVEL at the jump
3037 context; LOCUS is the source position of the jump or 0. Returns
3038 true if all is well. */
3041 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
3042 bool exited_omp
, const location_t
*locus
)
3044 cp_binding_level
*b
;
3045 bool complained
= false;
3047 bool saw_eh
= false, saw_omp
= false, saw_tm
= false;
3051 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3053 inform (input_location
, " exits OpenMP structured block");
3058 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3060 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3062 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3063 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3064 : TREE_CHAIN (new_decls
)))
3066 int problem
= decl_jump_unsafe (new_decls
);
3072 complained
= identify_goto (decl
, input_location
, locus
,
3079 inform (DECL_SOURCE_LOCATION (new_decls
),
3080 " crosses initialization of %q#D", new_decls
);
3082 inform (DECL_SOURCE_LOCATION (new_decls
),
3083 " enters scope of %q#D which has "
3084 "non-trivial destructor", new_decls
);
3090 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
3094 complained
= identify_goto (decl
, input_location
, locus
,
3100 if (b
->kind
== sk_try
)
3101 inform (input_location
, " enters try block");
3103 inform (input_location
, " enters catch block");
3107 if (b
->kind
== sk_omp
&& !saw_omp
)
3111 complained
= identify_goto (decl
, input_location
, locus
,
3116 inform (input_location
, " enters OpenMP structured block");
3119 if (b
->kind
== sk_transaction
&& !saw_tm
)
3123 complained
= identify_goto (decl
, input_location
, locus
,
3128 inform (input_location
,
3129 " enters synchronized or atomic statement");
3138 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3140 check_previous_goto_1 (decl
, use
->binding_level
,
3141 use
->names_in_scope
, use
->in_omp_scope
,
3142 &use
->o_goto_locus
);
3146 check_switch_goto (cp_binding_level
* level
)
3148 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3151 /* Check that a new jump to a label DECL is OK. Called by
3152 finish_goto_stmt. */
3155 check_goto (tree decl
)
3157 struct named_label_entry
*ent
, dummy
;
3158 bool saw_catch
= false, complained
= false;
3163 /* We can't know where a computed goto is jumping.
3164 So we assume that it's OK. */
3165 if (TREE_CODE (decl
) != LABEL_DECL
)
3168 /* We didn't record any information about this label when we created it,
3169 and there's not much point since it's trivial to analyze as a return. */
3170 if (decl
== cdtor_label
)
3173 dummy
.label_decl
= decl
;
3174 ent
= named_labels
->find (&dummy
);
3175 gcc_assert (ent
!= NULL
);
3177 /* If the label hasn't been defined yet, defer checking. */
3178 if (! DECL_INITIAL (decl
))
3180 struct named_label_use_entry
*new_use
;
3182 /* Don't bother creating another use if the last goto had the
3183 same data, and will therefore create the same set of errors. */
3185 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3188 new_use
= ggc_alloc
<named_label_use_entry
> ();
3189 new_use
->binding_level
= current_binding_level
;
3190 new_use
->names_in_scope
= current_binding_level
->names
;
3191 new_use
->o_goto_locus
= input_location
;
3192 new_use
->in_omp_scope
= false;
3194 new_use
->next
= ent
->uses
;
3195 ent
->uses
= new_use
;
3199 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3200 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3202 diagnostic_t diag_kind
= DK_PERMERROR
;
3203 if (ent
->in_try_scope
|| ent
->in_catch_scope
3204 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3205 diag_kind
= DK_ERROR
;
3206 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3207 &input_location
, diag_kind
);
3208 identified
= 1 + (diag_kind
== DK_ERROR
);
3211 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3213 int u
= decl_jump_unsafe (bad
);
3215 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3217 /* Can't skip init of __exception_info. */
3218 if (identified
== 1)
3220 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3221 &input_location
, DK_ERROR
);
3225 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3228 else if (complained
)
3231 inform (DECL_SOURCE_LOCATION (bad
),
3232 " skips initialization of %q#D", bad
);
3234 inform (DECL_SOURCE_LOCATION (bad
),
3235 " enters scope of %q#D which has "
3236 "non-trivial destructor", bad
);
3242 if (ent
->in_try_scope
)
3243 inform (input_location
, " enters try block");
3244 else if (ent
->in_catch_scope
&& !saw_catch
)
3245 inform (input_location
, " enters catch block");
3246 else if (ent
->in_transaction_scope
)
3247 inform (input_location
, " enters synchronized or atomic statement");
3250 if (ent
->in_omp_scope
)
3253 inform (input_location
, " enters OpenMP structured block");
3255 else if (flag_openmp
)
3257 cp_binding_level
*b
;
3258 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3260 if (b
== ent
->binding_level
)
3262 if (b
->kind
== sk_omp
)
3266 complained
= identify_goto (decl
,
3267 DECL_SOURCE_LOCATION (decl
),
3268 &input_location
, DK_ERROR
);
3272 inform (input_location
, " exits OpenMP structured block");
3279 /* Check that a return is ok wrt OpenMP structured blocks.
3280 Called by finish_return_stmt. Returns true if all is well. */
3283 check_omp_return (void)
3285 cp_binding_level
*b
;
3286 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3287 if (b
->kind
== sk_omp
)
3289 error ("invalid exit from OpenMP structured block");
3292 else if (b
->kind
== sk_function_parms
)
3297 /* Define a label, specifying the location in the source file.
3298 Return the LABEL_DECL node for the label. */
3301 define_label_1 (location_t location
, tree name
)
3303 struct named_label_entry
*ent
, dummy
;
3304 cp_binding_level
*p
;
3307 decl
= lookup_label (name
);
3309 dummy
.label_decl
= decl
;
3310 ent
= named_labels
->find (&dummy
);
3311 gcc_assert (ent
!= NULL
);
3313 /* After labels, make any new cleanups in the function go into their
3314 own new (temporary) binding contour. */
3315 for (p
= current_binding_level
;
3316 p
->kind
!= sk_function_parms
;
3318 p
->more_cleanups_ok
= 0;
3320 if (name
== get_identifier ("wchar_t"))
3321 permerror (input_location
, "label named wchar_t");
3323 if (DECL_INITIAL (decl
) != NULL_TREE
)
3325 error ("duplicate label %qD", decl
);
3326 return error_mark_node
;
3330 struct named_label_use_entry
*use
;
3332 /* Mark label as having been defined. */
3333 DECL_INITIAL (decl
) = error_mark_node
;
3334 /* Say where in the source. */
3335 DECL_SOURCE_LOCATION (decl
) = location
;
3337 ent
->binding_level
= current_binding_level
;
3338 ent
->names_in_scope
= current_binding_level
->names
;
3340 for (use
= ent
->uses
; use
; use
= use
->next
)
3341 check_previous_goto (decl
, use
);
3348 /* Wrapper for define_label_1. */
3351 define_label (location_t location
, tree name
)
3354 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3355 ret
= define_label_1 (location
, name
);
3356 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3363 cp_binding_level
*level
;
3364 struct cp_switch
*next
;
3365 /* The SWITCH_STMT being built. */
3367 /* A splay-tree mapping the low element of a case range to the high
3368 element, or NULL_TREE if there is no high element. Used to
3369 determine whether or not a new case label duplicates an old case
3370 label. We need a tree, rather than simply a hash table, because
3371 of the GNU case range extension. */
3373 /* Remember whether there was a case value that is outside the
3374 range of the original type of the controlling expression. */
3375 bool outside_range_p
;
3378 /* A stack of the currently active switch statements. The innermost
3379 switch statement is on the top of the stack. There is no need to
3380 mark the stack for garbage collection because it is only active
3381 during the processing of the body of a function, and we never
3382 collect at that point. */
3384 static struct cp_switch
*switch_stack
;
3386 /* Called right after a switch-statement condition is parsed.
3387 SWITCH_STMT is the switch statement being parsed. */
3390 push_switch (tree switch_stmt
)
3392 struct cp_switch
*p
= XNEW (struct cp_switch
);
3393 p
->level
= current_binding_level
;
3394 p
->next
= switch_stack
;
3395 p
->switch_stmt
= switch_stmt
;
3396 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3397 p
->outside_range_p
= false;
3404 struct cp_switch
*cs
= switch_stack
;
3405 location_t switch_location
;
3407 /* Emit warnings as needed. */
3408 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3409 const bool bool_cond_p
3410 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3411 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3412 if (!processing_template_decl
)
3413 c_do_switch_warnings (cs
->cases
, switch_location
,
3414 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3415 SWITCH_STMT_COND (cs
->switch_stmt
),
3416 bool_cond_p
, cs
->outside_range_p
);
3418 splay_tree_delete (cs
->cases
);
3419 switch_stack
= switch_stack
->next
;
3423 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3424 condition. Note that if TYPE and VALUE are already integral we don't
3425 really do the conversion because the language-independent
3426 warning/optimization code will work better that way. */
3429 case_conversion (tree type
, tree value
)
3431 if (value
== NULL_TREE
)
3434 if (cxx_dialect
>= cxx11
3435 && (SCOPED_ENUM_P (type
)
3436 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3438 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3439 type
= type_promotes_to (type
);
3440 value
= (perform_implicit_conversion_flags
3441 (type
, value
, tf_warning_or_error
,
3442 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3444 return cxx_constant_value (value
);
3447 /* Note that we've seen a definition of a case label, and complain if this
3448 is a bad place for one. */
3451 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3454 cp_binding_level
*p
;
3457 if (processing_template_decl
)
3461 /* For templates, just add the case label; we'll do semantic
3462 analysis at instantiation-time. */
3463 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3464 return add_stmt (build_case_label (low_value
, high_value
, label
));
3467 /* Find the condition on which this switch statement depends. */
3468 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3469 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3470 cond
= TREE_VALUE (cond
);
3472 if (!check_switch_goto (switch_stack
->level
))
3473 return error_mark_node
;
3475 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3477 low_value
= case_conversion (type
, low_value
);
3478 high_value
= case_conversion (type
, high_value
);
3480 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3481 low_value
, high_value
,
3482 &switch_stack
->outside_range_p
);
3484 /* After labels, make any new cleanups in the function go into their
3485 own new (temporary) binding contour. */
3486 for (p
= current_binding_level
;
3487 p
->kind
!= sk_function_parms
;
3489 p
->more_cleanups_ok
= 0;
3494 struct typename_info
{
3502 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3504 typedef typename_info
*compare_type
;
3506 /* Hash a TYPENAME_TYPE. */
3513 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3514 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3519 /* Compare two TYPENAME_TYPEs. */
3522 equal (tree t1
, const typename_info
*t2
)
3524 return (TYPE_IDENTIFIER (t1
) == t2
->name
3525 && TYPE_CONTEXT (t1
) == t2
->scope
3526 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3527 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3528 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3532 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3533 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3535 Returns the new TYPENAME_TYPE. */
3537 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3540 build_typename_type (tree context
, tree name
, tree fullname
,
3541 enum tag_types tag_type
)
3549 if (typename_htab
== NULL
)
3550 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3552 ti
.scope
= FROB_CONTEXT (context
);
3554 ti
.template_id
= fullname
;
3555 ti
.enum_p
= tag_type
== enum_type
;
3556 ti
.class_p
= (tag_type
== class_type
3557 || tag_type
== record_type
3558 || tag_type
== union_type
);
3559 hash
= (htab_hash_pointer (ti
.scope
)
3560 ^ htab_hash_pointer (ti
.name
));
3562 /* See if we already have this type. */
3563 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3568 /* Build the TYPENAME_TYPE. */
3569 t
= cxx_make_type (TYPENAME_TYPE
);
3570 TYPE_CONTEXT (t
) = ti
.scope
;
3571 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3572 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3573 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3575 /* Build the corresponding TYPE_DECL. */
3576 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3577 TYPE_NAME (TREE_TYPE (d
)) = d
;
3578 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3579 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3580 DECL_ARTIFICIAL (d
) = 1;
3582 /* Store it in the hash table. */
3585 /* TYPENAME_TYPEs must always be compared structurally, because
3586 they may or may not resolve down to another type depending on
3587 the currently open classes. */
3588 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3594 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3595 provided to name the type. Returns an appropriate type, unless an
3596 error occurs, in which case error_mark_node is returned. If we
3597 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3598 return that, rather than the _TYPE it corresponds to, in other
3599 cases we look through the type decl. If TF_ERROR is set, complain
3600 about errors, otherwise be quiet. */
3603 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3604 tsubst_flags_t complain
)
3610 if (name
== error_mark_node
3611 || context
== NULL_TREE
3612 || context
== error_mark_node
)
3613 return error_mark_node
;
3617 if (!(TYPE_LANG_SPECIFIC (name
)
3618 && (CLASSTYPE_IS_TEMPLATE (name
)
3619 || CLASSTYPE_USE_TEMPLATE (name
))))
3620 name
= TYPE_IDENTIFIER (name
);
3622 /* Create a TEMPLATE_ID_EXPR for the type. */
3623 name
= build_nt (TEMPLATE_ID_EXPR
,
3624 CLASSTYPE_TI_TEMPLATE (name
),
3625 CLASSTYPE_TI_ARGS (name
));
3627 else if (TREE_CODE (name
) == TYPE_DECL
)
3628 name
= DECL_NAME (name
);
3632 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3634 name
= TREE_OPERAND (name
, 0);
3635 if (DECL_TYPE_TEMPLATE_P (name
))
3636 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3637 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3639 if (complain
& tf_error
)
3640 error ("%qD is not a type", name
);
3641 return error_mark_node
;
3644 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3646 if (complain
& tf_error
)
3647 error ("%qD used without template parameters", name
);
3648 return error_mark_node
;
3650 gcc_assert (identifier_p (name
));
3651 gcc_assert (TYPE_P (context
));
3653 if (!MAYBE_CLASS_TYPE_P (context
))
3655 if (complain
& tf_error
)
3656 error ("%q#T is not a class", context
);
3657 return error_mark_node
;
3660 /* When the CONTEXT is a dependent type, NAME could refer to a
3661 dependent base class of CONTEXT. But look inside it anyway
3662 if CONTEXT is a currently open scope, in case it refers to a
3663 member of the current instantiation or a non-dependent base;
3664 lookup will stop when we hit a dependent base. */
3665 if (!dependent_scope_p (context
))
3666 /* We should only set WANT_TYPE when we're a nested typename type.
3667 Then we can give better diagnostics if we find a non-type. */
3668 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3672 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3673 return build_typename_type (context
, name
, fullname
, tag_type
);
3675 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3679 if (complain
& tf_error
)
3680 error (want_template
? G_("no class template named %q#T in %q#T")
3681 : G_("no type named %q#T in %q#T"), name
, context
);
3682 return error_mark_node
;
3685 /* Pull out the template from an injected-class-name (or multiple). */
3687 t
= maybe_get_template_decl_from_type_decl (t
);
3689 if (TREE_CODE (t
) == TREE_LIST
)
3691 if (complain
& tf_error
)
3693 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3694 print_candidates (t
);
3696 return error_mark_node
;
3699 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3701 if (complain
& tf_error
)
3702 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3704 return error_mark_node
;
3706 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3708 if (complain
& tf_error
)
3709 error ("%<typename %T::%D%> names %q#T, which is not a type",
3711 return error_mark_node
;
3714 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3715 return error_mark_node
;
3717 /* If we are currently parsing a template and if T is a typedef accessed
3718 through CONTEXT then we need to remember and check access of T at
3719 template instantiation time. */
3720 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3723 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3725 /*entering_scope=*/0,
3726 complain
| tf_user
);
3728 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3731 maybe_record_typedef_use (t
);
3736 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3737 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3738 in which case error_mark_node is returned.
3740 If PARM_LIST is non-NULL, also make sure that the template parameter
3741 list of TEMPLATE_DECL matches.
3743 If COMPLAIN zero, don't complain about any errors that occur. */
3746 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3747 tsubst_flags_t complain
)
3753 name
= TYPE_IDENTIFIER (name
);
3754 else if (DECL_P (name
))
3755 name
= DECL_NAME (name
);
3756 gcc_assert (identifier_p (name
));
3758 if (!dependent_type_p (context
)
3759 || currently_open_class (context
))
3761 tree tmpl
= NULL_TREE
;
3763 if (MAYBE_CLASS_TYPE_P (context
))
3764 tmpl
= lookup_field (context
, name
, 0, false);
3766 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3767 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3769 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3771 if (complain
& tf_error
)
3772 error ("no class template named %q#T in %q#T", name
, context
);
3773 return error_mark_node
;
3777 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3779 if (complain
& tf_error
)
3781 error ("template parameters do not match template %qD", tmpl
);
3782 inform (DECL_SOURCE_LOCATION (tmpl
),
3783 "%qD declared here", tmpl
);
3785 return error_mark_node
;
3788 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3790 return error_mark_node
;
3795 /* Build the UNBOUND_CLASS_TEMPLATE. */
3796 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3797 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3798 TREE_TYPE (t
) = NULL_TREE
;
3799 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3801 /* Build the corresponding TEMPLATE_DECL. */
3802 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3803 TYPE_NAME (TREE_TYPE (d
)) = d
;
3804 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3805 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3806 DECL_ARTIFICIAL (d
) = 1;
3807 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3814 /* Push the declarations of builtin types into the namespace.
3815 RID_INDEX is the index of the builtin type in the array
3816 RID_POINTERS. NAME is the name used when looking up the builtin
3817 type. TYPE is the _TYPE node for the builtin type. */
3820 record_builtin_type (enum rid rid_index
,
3824 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3825 tree tdecl
= NULL_TREE
;
3827 if ((int) rid_index
< (int) RID_MAX
)
3828 rname
= ridpointers
[(int) rid_index
];
3830 tname
= get_identifier (name
);
3832 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3833 eliminated. Built-in types should not be looked up name; their
3834 names are keywords that the parser can recognize. However, there
3835 is code in c-common.c that uses identifier_global_value to look
3836 up built-in types by name. */
3839 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3840 DECL_ARTIFICIAL (tdecl
) = 1;
3841 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3847 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3848 DECL_ARTIFICIAL (tdecl
) = 1;
3850 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3853 if (!TYPE_NAME (type
))
3854 TYPE_NAME (type
) = tdecl
;
3857 debug_hooks
->type_decl (tdecl
, 0);
3860 /* Record one of the standard Java types.
3861 * Declare it as having the given NAME.
3862 * If SIZE > 0, it is the size of one of the integral types;
3863 * otherwise it is the negative of the size of one of the other types. */
3866 record_builtin_java_type (const char* name
, int size
)
3871 type
= build_nonstandard_integer_type (size
, 0);
3872 type
= build_distinct_type_copy (type
);
3874 else if (size
> -32)
3877 /* "__java_char" or ""__java_boolean". */
3878 type
= build_nonstandard_integer_type (-size
, 1);
3879 type
= build_distinct_type_copy (type
);
3880 /* Get the signed type cached and attached to the unsigned type,
3881 so it doesn't get garbage-collected at "random" times,
3882 causing potential codegen differences out of different UIDs
3883 and different alias set numbers. */
3884 stype
= build_nonstandard_integer_type (-size
, 0);
3885 stype
= build_distinct_type_copy (stype
);
3886 TREE_CHAIN (type
) = stype
;
3887 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3890 { /* "__java_float" or ""__java_double". */
3891 type
= make_node (REAL_TYPE
);
3892 TYPE_PRECISION (type
) = - size
;
3895 record_builtin_type (RID_MAX
, name
, type
);
3896 decl
= TYPE_NAME (type
);
3898 /* Suppress generate debug symbol entries for these types,
3899 since for normal C++ they are just clutter.
3900 However, push_lang_context undoes this if extern "Java" is seen. */
3901 DECL_IGNORED_P (decl
) = 1;
3903 TYPE_FOR_JAVA (type
) = 1;
3907 /* Push a type into the namespace so that the back ends ignore it. */
3910 record_unknown_type (tree type
, const char* name
)
3912 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3913 TYPE_DECL
, get_identifier (name
), type
));
3914 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3915 DECL_IGNORED_P (decl
) = 1;
3916 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3917 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3918 SET_TYPE_ALIGN (type
, 1);
3919 TYPE_USER_ALIGN (type
) = 0;
3920 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3923 /* A string for which we should create an IDENTIFIER_NODE at
3926 struct predefined_identifier
3928 /* The name of the identifier. */
3929 const char *const name
;
3930 /* The place where the IDENTIFIER_NODE should be stored. */
3932 /* Nonzero if this is the name of a constructor or destructor. */
3933 const int ctor_or_dtor_p
;
3936 /* Create all the predefined identifiers. */
3939 initialize_predefined_identifiers (void)
3941 const predefined_identifier
*pid
;
3943 /* A table of identifiers to create at startup. */
3944 static const predefined_identifier predefined_identifiers
[] = {
3945 { "C++", &lang_name_cplusplus
, 0 },
3946 { "C", &lang_name_c
, 0 },
3947 { "Java", &lang_name_java
, 0 },
3948 /* Some of these names have a trailing space so that it is
3949 impossible for them to conflict with names written by users. */
3950 { "__ct ", &ctor_identifier
, 1 },
3951 { "__base_ctor ", &base_ctor_identifier
, 1 },
3952 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3953 { "__dt ", &dtor_identifier
, 1 },
3954 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3955 { "__base_dtor ", &base_dtor_identifier
, 1 },
3956 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3957 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3958 { "nelts", &nelts_identifier
, 0 },
3959 { THIS_NAME
, &this_identifier
, 0 },
3960 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3961 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3962 { "_vptr", &vptr_identifier
, 0 },
3963 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3964 { "::", &global_scope_name
, 0 },
3965 { "std", &std_identifier
, 0 },
3969 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3971 *pid
->node
= get_identifier (pid
->name
);
3972 if (pid
->ctor_or_dtor_p
)
3973 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3977 /* Create the predefined scalar types of C,
3978 and some nodes representing standard constants (0, 1, (void *)0).
3979 Initialize the global binding level.
3980 Make definitions for built-in primitive functions. */
3983 cxx_init_decl_processing (void)
3986 tree void_ftype_ptr
;
3988 /* Create all the identifiers we need. */
3989 initialize_predefined_identifiers ();
3991 /* Create the global variables. */
3992 push_to_top_level ();
3994 current_function_decl
= NULL_TREE
;
3995 current_binding_level
= NULL
;
3996 /* Enter the global namespace. */
3997 gcc_assert (global_namespace
== NULL_TREE
);
3998 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
4000 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
4001 debug_hooks
->register_main_translation_unit
4002 (DECL_CONTEXT (global_namespace
));
4003 TREE_PUBLIC (global_namespace
) = 1;
4004 begin_scope (sk_namespace
, global_namespace
);
4006 if (flag_visibility_ms_compat
)
4007 default_visibility
= VISIBILITY_HIDDEN
;
4010 current_lang_name
= lang_name_c
;
4012 /* Create the `std' namespace. */
4013 push_namespace (std_identifier
);
4014 std_node
= current_namespace
;
4017 c_common_nodes_and_builtins ();
4019 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
4020 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
4021 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
4022 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
4023 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
4024 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
4025 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
4026 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
4028 integer_two_node
= build_int_cst (NULL_TREE
, 2);
4030 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
4031 truthvalue_type_node
= boolean_type_node
;
4032 truthvalue_false_node
= boolean_false_node
;
4033 truthvalue_true_node
= boolean_true_node
;
4035 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
4036 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
4037 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
4040 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
4043 delta_type_node
= ptrdiff_type_node
;
4044 vtable_index_type
= ptrdiff_type_node
;
4046 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
4047 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
4048 void_ftype_ptr
= build_function_type_list (void_type_node
,
4049 ptr_type_node
, NULL_TREE
);
4051 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4053 /* C++ extensions */
4055 unknown_type_node
= make_node (LANG_TYPE
);
4056 record_unknown_type (unknown_type_node
, "unknown type");
4058 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4059 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4061 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4063 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4064 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4066 init_list_type_node
= make_node (LANG_TYPE
);
4067 record_unknown_type (init_list_type_node
, "init list");
4070 /* Make sure we get a unique function type, so we can give
4071 its pointer type a name. (This wins for gdb.) */
4072 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4073 TREE_TYPE (vfunc_type
) = integer_type_node
;
4074 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4075 layout_type (vfunc_type
);
4077 vtable_entry_type
= build_pointer_type (vfunc_type
);
4079 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
4082 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4083 layout_type (vtbl_type_node
);
4084 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4085 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4086 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4087 layout_type (vtbl_ptr_type_node
);
4088 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4090 push_namespace (get_identifier ("__cxxabiv1"));
4091 abi_node
= current_namespace
;
4094 global_type_node
= make_node (LANG_TYPE
);
4095 record_unknown_type (global_type_node
, "global type");
4098 current_lang_name
= lang_name_cplusplus
;
4101 tree newattrs
, extvisattr
;
4102 tree newtype
, deltype
;
4103 tree ptr_ftype_sizetype
;
4107 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4108 if (cxx_dialect
== cxx98
)
4111 tree bad_alloc_type_node
;
4112 tree bad_alloc_decl
;
4114 push_namespace (std_identifier
);
4115 bad_alloc_id
= get_identifier ("bad_alloc");
4116 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4117 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4119 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4120 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4124 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4127 new_eh_spec
= noexcept_false_spec
;
4129 /* Ensure attribs.c is initialized. */
4132 /* Ensure constraint.cc is initialized. */
4133 init_constraint_processing ();
4135 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4137 newattrs
= tree_cons (get_identifier ("alloc_size"),
4138 build_tree_list (NULL_TREE
, integer_one_node
),
4140 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4141 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4142 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4143 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4144 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4145 DECL_IS_MALLOC (opnew
) = 1;
4146 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4147 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4148 DECL_IS_MALLOC (opnew
) = 1;
4149 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4150 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4151 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4152 if (flag_sized_deallocation
)
4154 /* Also push the sized deallocation variants:
4155 void operator delete(void*, std::size_t) throw();
4156 void operator delete[](void*, std::size_t) throw(); */
4157 tree void_ftype_ptr_size
4158 = build_function_type_list (void_type_node
, ptr_type_node
,
4159 size_type_node
, NULL_TREE
);
4160 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4162 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4163 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4164 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4167 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4168 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4169 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4170 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4171 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4172 if (abi_version_at_least (9))
4173 SET_TYPE_ALIGN (nullptr_type_node
, GET_MODE_ALIGNMENT (ptr_mode
));
4174 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4175 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4176 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4180 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4181 ECF_NORETURN
| ECF_NOTHROW
);
4183 /* Perform other language dependent initializations. */
4184 init_class_processing ();
4185 init_rtti_processing ();
4186 init_template_processing ();
4188 if (flag_exceptions
)
4189 init_exception_processing ();
4191 if (! supports_one_only ())
4194 make_fname_decl
= cp_make_fname_decl
;
4195 start_fname_decls ();
4197 /* Show we use EH for cleanups. */
4198 if (flag_exceptions
)
4199 using_eh_for_cleanups ();
4202 /* Generate an initializer for a function naming variable from
4203 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4204 filled in with the type of the init. */
4207 cp_fname_init (const char* name
, tree
*type_p
)
4209 tree domain
= NULL_TREE
;
4211 tree init
= NULL_TREE
;
4216 length
= strlen (name
);
4217 domain
= build_index_type (size_int (length
));
4218 init
= build_string (length
+ 1, name
);
4221 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4222 type
= build_cplus_array_type (type
, domain
);
4227 TREE_TYPE (init
) = type
;
4229 init
= error_mark_node
;
4234 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4235 the decl, LOC is the location to give the decl, NAME is the
4236 initialization string and TYPE_DEP indicates whether NAME depended
4237 on the type of the function. We make use of that to detect
4238 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4239 at the point of first use, so we mustn't push the decl now. */
4242 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4244 const char *const name
= (type_dep
&& processing_template_decl
4245 ? NULL
: fname_as_string (type_dep
));
4247 tree init
= cp_fname_init (name
, &type
);
4248 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4251 free (CONST_CAST (char *, name
));
4253 /* As we're using pushdecl_with_scope, we must set the context. */
4254 DECL_CONTEXT (decl
) = current_function_decl
;
4256 TREE_STATIC (decl
) = 1;
4257 TREE_READONLY (decl
) = 1;
4258 DECL_ARTIFICIAL (decl
) = 1;
4260 TREE_USED (decl
) = 1;
4262 if (current_function_decl
)
4264 cp_binding_level
*b
= current_binding_level
;
4265 if (b
->kind
== sk_function_parms
)
4266 return error_mark_node
;
4267 while (b
->level_chain
->kind
!= sk_function_parms
)
4269 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
4270 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
4271 LOOKUP_ONLYCONVERTING
);
4275 DECL_THIS_STATIC (decl
) = true;
4276 pushdecl_top_level_and_finish (decl
, init
);
4283 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4285 tree id
= DECL_NAME (decl
);
4286 const char *name
= IDENTIFIER_POINTER (id
);
4288 retrofit_lang_decl (decl
);
4290 DECL_ARTIFICIAL (decl
) = 1;
4291 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
4292 SET_DECL_LANGUAGE (decl
, lang_c
);
4293 /* Runtime library routines are, by definition, available in an
4294 external shared object. */
4295 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4296 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4298 DECL_CONTEXT (decl
) = context
;
4301 pushdecl_top_level (decl
);
4305 /* A function in the user's namespace should have an explicit
4306 declaration before it is used. Mark the built-in function as
4307 anticipated but not actually declared. */
4308 if (name
[0] != '_' || name
[1] != '_')
4309 DECL_ANTICIPATED (decl
) = 1;
4310 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4312 size_t len
= strlen (name
);
4314 /* Treat __*_chk fortification functions as anticipated as well,
4315 unless they are __builtin_*. */
4316 if (len
> strlen ("___chk")
4317 && memcmp (name
+ len
- strlen ("_chk"),
4318 "_chk", strlen ("_chk") + 1) == 0)
4319 DECL_ANTICIPATED (decl
) = 1;
4326 cxx_builtin_function (tree decl
)
4328 tree id
= DECL_NAME (decl
);
4329 const char *name
= IDENTIFIER_POINTER (id
);
4330 /* All builtins that don't begin with an '_' should additionally
4331 go in the 'std' namespace. */
4334 tree decl2
= copy_node(decl
);
4335 push_namespace (std_identifier
);
4336 builtin_function_1 (decl2
, std_node
, false);
4340 return builtin_function_1 (decl
, NULL_TREE
, false);
4343 /* Like cxx_builtin_function, but guarantee the function is added to the global
4344 scope. This is to allow function specific options to add new machine
4345 dependent builtins when the target ISA changes via attribute((target(...)))
4346 which saves space on program startup if the program does not use non-generic
4350 cxx_builtin_function_ext_scope (tree decl
)
4353 tree id
= DECL_NAME (decl
);
4354 const char *name
= IDENTIFIER_POINTER (id
);
4355 /* All builtins that don't begin with an '_' should additionally
4356 go in the 'std' namespace. */
4359 tree decl2
= copy_node(decl
);
4360 push_namespace (std_identifier
);
4361 builtin_function_1 (decl2
, std_node
, true);
4365 return builtin_function_1 (decl
, NULL_TREE
, true);
4368 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4369 function. Not called directly. */
4372 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4375 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4376 DECL_EXTERNAL (fn
) = 1;
4377 TREE_PUBLIC (fn
) = 1;
4378 DECL_ARTIFICIAL (fn
) = 1;
4379 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4380 SET_DECL_LANGUAGE (fn
, lang_c
);
4381 /* Runtime library routines are, by definition, available in an
4382 external shared object. */
4383 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4384 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4385 set_call_expr_flags (fn
, ecf_flags
);
4389 /* Returns the _DECL for a library function with C++ linkage. */
4392 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4395 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4396 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4397 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4401 /* Like build_library_fn, but takes a C string instead of an
4405 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4407 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4410 /* Like build_cp_library_fn, but takes a C string instead of an
4414 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4416 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4420 /* Like build_library_fn, but also pushes the function so that we will
4421 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4422 may throw exceptions listed in RAISES. */
4425 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4430 type
= build_exception_variant (type
, raises
);
4432 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4433 pushdecl_top_level (fn
);
4437 /* Like build_cp_library_fn, but also pushes the function so that it
4438 will be found by normal lookup. */
4441 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4444 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4449 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4453 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4457 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4459 tree type
= build_function_type (void_type_node
, parmtypes
);
4460 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4463 /* Like push_library_fn, but also note that this function throws
4464 and does not return. Used for __throw_foo and the like. */
4467 push_throw_library_fn (tree name
, tree type
)
4469 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4473 /* When we call finish_struct for an anonymous union, we create
4474 default copy constructors and such. But, an anonymous union
4475 shouldn't have such things; this function undoes the damage to the
4476 anonymous union type T.
4478 (The reason that we create the synthesized methods is that we don't
4479 distinguish `union { int i; }' from `typedef union { int i; } U'.
4480 The first is an anonymous union; the second is just an ordinary
4484 fixup_anonymous_aggr (tree t
)
4488 /* Wipe out memory of synthesized methods. */
4489 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4490 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4491 TYPE_HAS_COPY_CTOR (t
) = 0;
4492 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4493 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4494 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4496 /* Splice the implicitly generated functions out of the TYPE_METHODS
4498 q
= &TYPE_METHODS (t
);
4501 if (DECL_ARTIFICIAL (*q
))
4502 *q
= TREE_CHAIN (*q
);
4504 q
= &DECL_CHAIN (*q
);
4507 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4508 if (TYPE_METHODS (t
))
4510 tree decl
= TYPE_MAIN_DECL (t
);
4512 if (TREE_CODE (t
) != UNION_TYPE
)
4513 error_at (DECL_SOURCE_LOCATION (decl
),
4514 "an anonymous struct cannot have function members");
4516 error_at (DECL_SOURCE_LOCATION (decl
),
4517 "an anonymous union cannot have function members");
4520 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4521 assignment operators (because they cannot have these methods themselves).
4522 For anonymous unions this is already checked because they are not allowed
4523 in any union, otherwise we have to check it. */
4524 if (TREE_CODE (t
) != UNION_TYPE
)
4528 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4529 if (TREE_CODE (field
) == FIELD_DECL
)
4531 type
= TREE_TYPE (field
);
4532 if (CLASS_TYPE_P (type
))
4534 if (TYPE_NEEDS_CONSTRUCTING (type
))
4535 error ("member %q+#D with constructor not allowed "
4536 "in anonymous aggregate", field
);
4537 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4538 error ("member %q+#D with destructor not allowed "
4539 "in anonymous aggregate", field
);
4540 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4541 error ("member %q+#D with copy assignment operator "
4542 "not allowed in anonymous aggregate", field
);
4548 /* Warn for an attribute located at LOCATION that appertains to the
4549 class type CLASS_TYPE that has not been properly placed after its
4550 class-key, in it class-specifier. */
4553 warn_misplaced_attr_for_class_type (source_location location
,
4556 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4558 if (warning_at (location
, OPT_Wattributes
,
4559 "attribute ignored in declaration "
4560 "of %q#T", class_type
))
4562 "attribute for %q#T must follow the %qs keyword",
4563 class_type
, class_key_or_enum_as_string (class_type
));
4566 /* Make sure that a declaration with no declarator is well-formed, i.e.
4567 just declares a tagged type or anonymous union.
4569 Returns the type declared; or NULL_TREE if none. */
4572 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4573 bool explicit_type_instantiation_p
)
4575 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4576 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4577 /* If a class, struct, or enum type is declared by the DECLSPECS
4578 (i.e, if a class-specifier, enum-specifier, or non-typename
4579 elaborated-type-specifier appears in the DECLSPECS),
4580 DECLARED_TYPE is set to the corresponding type. */
4581 tree declared_type
= NULL_TREE
;
4582 bool error_p
= false;
4584 if (declspecs
->multiple_types_p
)
4585 error ("multiple types in one declaration");
4586 else if (declspecs
->redefined_builtin_type
)
4588 if (!in_system_header_at (input_location
))
4589 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4590 "redeclaration of C++ built-in type %qT",
4591 declspecs
->redefined_builtin_type
);
4596 && TYPE_P (declspecs
->type
)
4597 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4598 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4599 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4600 declared_type
= declspecs
->type
;
4601 else if (declspecs
->type
== error_mark_node
)
4603 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4604 permerror (input_location
, "declaration does not declare anything");
4605 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4607 error_at (declspecs
->locations
[ds_type_spec
],
4608 "%<auto%> can only be specified for variables "
4609 "or function declarations");
4610 return error_mark_node
;
4612 /* Check for an anonymous union. */
4613 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4614 && TYPE_ANONYMOUS_P (declared_type
))
4616 /* 7/3 In a simple-declaration, the optional init-declarator-list
4617 can be omitted only when declaring a class (clause 9) or
4618 enumeration (7.2), that is, when the decl-specifier-seq contains
4619 either a class-specifier, an elaborated-type-specifier with
4620 a class-key (9.1), or an enum-specifier. In these cases and
4621 whenever a class-specifier or enum-specifier is present in the
4622 decl-specifier-seq, the identifiers in these specifiers are among
4623 the names being declared by the declaration (as class-name,
4624 enum-names, or enumerators, depending on the syntax). In such
4625 cases, and except for the declaration of an unnamed bit-field (9.6),
4626 the decl-specifier-seq shall introduce one or more names into the
4627 program, or shall redeclare a name introduced by a previous
4628 declaration. [Example:
4629 enum { }; // ill-formed
4630 typedef class { }; // ill-formed
4634 error ("missing type-name in typedef-declaration");
4637 /* Anonymous unions are objects, so they can have specifiers. */;
4638 SET_ANON_AGGR_TYPE_P (declared_type
);
4640 if (TREE_CODE (declared_type
) != UNION_TYPE
4641 && !in_system_header_at (input_location
))
4642 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4647 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4648 error_at (declspecs
->locations
[ds_inline
],
4649 "%<inline%> can only be specified for functions");
4650 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4651 error_at (declspecs
->locations
[ds_virtual
],
4652 "%<virtual%> can only be specified for functions");
4654 && (!current_class_type
4655 || current_scope () != current_class_type
))
4656 error_at (declspecs
->locations
[ds_friend
],
4657 "%<friend%> can only be specified inside a class");
4658 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4659 error_at (declspecs
->locations
[ds_explicit
],
4660 "%<explicit%> can only be specified for constructors");
4661 else if (declspecs
->storage_class
)
4662 error_at (declspecs
->locations
[ds_storage_class
],
4663 "a storage class can only be specified for objects "
4665 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4666 error_at (declspecs
->locations
[ds_const
],
4667 "%<const%> can only be specified for objects and "
4669 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4670 error_at (declspecs
->locations
[ds_volatile
],
4671 "%<volatile%> can only be specified for objects and "
4673 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4674 error_at (declspecs
->locations
[ds_restrict
],
4675 "%<__restrict%> can only be specified for objects and "
4677 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4678 error_at (declspecs
->locations
[ds_thread
],
4679 "%<__thread%> can only be specified for objects "
4681 else if (saw_typedef
)
4682 warning_at (declspecs
->locations
[ds_typedef
], 0,
4683 "%<typedef%> was ignored in this declaration");
4684 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4685 error_at (declspecs
->locations
[ds_constexpr
],
4686 "%<constexpr%> cannot be used for type declarations");
4689 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4692 if (!CLASS_TYPE_P (declared_type
)
4693 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4694 /* For a non-template class, use the name location. */
4695 loc
= location_of (declared_type
);
4697 /* For a template class (an explicit instantiation), use the
4698 current location. */
4699 loc
= input_location
;
4701 if (explicit_type_instantiation_p
)
4702 /* [dcl.attr.grammar]/4:
4704 No attribute-specifier-seq shall appertain to an explicit
4707 if (warning_at (loc
, OPT_Wattributes
,
4708 "attribute ignored in explicit instantiation %q#T",
4711 "no attribute can be applied to "
4712 "an explicit instantiation");
4715 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4718 return declared_type
;
4721 /* Called when a declaration is seen that contains no names to declare.
4722 If its type is a reference to a structure, union or enum inherited
4723 from a containing scope, shadow that tag name for the current scope
4724 with a forward reference.
4725 If its type defines a new named structure or union
4726 or defines an enum, it is valid but we need not do anything here.
4727 Otherwise, it is an error.
4729 C++: may have to grok the declspecs to learn about static,
4730 complain for anonymous unions.
4732 Returns the TYPE declared -- or NULL_TREE if none. */
4735 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4737 tree t
= check_tag_decl (declspecs
,
4738 /*explicit_type_instantiation_p=*/false);
4743 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4746 /* This is where the variables in an anonymous union are
4747 declared. An anonymous union declaration looks like:
4749 because there is no declarator after the union, the parser
4750 sends that declaration here. */
4751 if (ANON_AGGR_TYPE_P (t
))
4753 fixup_anonymous_aggr (t
);
4755 if (TYPE_FIELDS (t
))
4757 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4758 declspecs
, NORMAL
, 0, NULL
);
4759 finish_anon_union (decl
);
4766 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4769 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4770 const cp_declarator
*declarator
,
4771 bool is_template_arg
)
4775 enum decl_context context
4776 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4777 attrs
= type_specifiers
->attributes
;
4778 type_specifiers
->attributes
= NULL_TREE
;
4779 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4780 if (attrs
&& type
!= error_mark_node
)
4782 if (CLASS_TYPE_P (type
))
4783 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4784 "outside of definition", type
);
4785 else if (MAYBE_CLASS_TYPE_P (type
))
4786 /* A template type parameter or other dependent type. */
4787 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4788 "type %qT without an associated declaration", type
);
4790 cplus_decl_attributes (&type
, attrs
, 0);
4795 /* Process a DECLARATOR for a function-scope variable declaration,
4796 namespace-scope variable declaration, or function declaration.
4797 (Function definitions go through start_function; class member
4798 declarations appearing in the body of the class go through
4799 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4800 If an error occurs, the error_mark_node is returned instead.
4802 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4803 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4804 for an explicitly defaulted function, or SD_DELETED for an explicitly
4805 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4806 implicitly initialized via a default constructor. ATTRIBUTES and
4807 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4809 The scope represented by the context of the returned DECL is pushed
4810 (if it is not the global namespace) and is assigned to
4811 *PUSHED_SCOPE_P. The caller is then responsible for calling
4812 pop_scope on *PUSHED_SCOPE_P if it is set. */
4815 start_decl (const cp_declarator
*declarator
,
4816 cp_decl_specifier_seq
*declspecs
,
4819 tree prefix_attributes
,
4820 tree
*pushed_scope_p
)
4828 *pushed_scope_p
= NULL_TREE
;
4830 /* An object declared as __attribute__((deprecated)) suppresses
4831 warnings of uses of other deprecated items. */
4832 if (lookup_attribute ("deprecated", attributes
))
4833 deprecated_state
= DEPRECATED_SUPPRESS
;
4835 attributes
= chainon (attributes
, prefix_attributes
);
4837 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4840 deprecated_state
= DEPRECATED_NORMAL
;
4842 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4843 || decl
== error_mark_node
)
4844 return error_mark_node
;
4846 context
= CP_DECL_CONTEXT (decl
);
4847 if (context
!= global_namespace
)
4848 *pushed_scope_p
= push_scope (context
);
4850 /* Is it valid for this decl to have an initializer at all?
4851 If not, set INITIALIZED to zero, which will indirectly
4852 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4854 && TREE_CODE (decl
) == TYPE_DECL
)
4856 error ("typedef %qD is initialized (use decltype instead)", decl
);
4857 return error_mark_node
;
4862 if (! toplevel_bindings_p ()
4863 && DECL_EXTERNAL (decl
))
4864 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4866 DECL_EXTERNAL (decl
) = 0;
4867 if (toplevel_bindings_p ())
4868 TREE_STATIC (decl
) = 1;
4870 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4872 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4873 record_key_method_defined (decl
);
4875 /* If this is a typedef that names the class for linkage purposes
4876 (7.1.3p8), apply any attributes directly to the type. */
4877 if (TREE_CODE (decl
) == TYPE_DECL
4878 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4879 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4880 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4884 /* Set attributes here so if duplicate decl, will have proper attributes. */
4885 cplus_decl_attributes (&decl
, attributes
, flags
);
4887 /* Dllimported symbols cannot be defined. Static data members (which
4888 can be initialized in-class and dllimported) go through grokfield,
4889 not here, so we don't need to exclude those decls when checking for
4891 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4893 error ("definition of %q#D is marked %<dllimport%>", decl
);
4894 DECL_DLLIMPORT_P (decl
) = 0;
4897 /* If #pragma weak was used, mark the decl weak now. */
4898 if (!processing_template_decl
)
4899 maybe_apply_pragma_weak (decl
);
4901 if (TREE_CODE (decl
) == FUNCTION_DECL
4902 && DECL_DECLARED_INLINE_P (decl
)
4903 && DECL_UNINLINABLE (decl
)
4904 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4905 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4906 "inline function %qD given attribute noinline", decl
);
4908 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4910 bool this_tmpl
= (processing_template_decl
4911 > template_class_depth (context
));
4914 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4915 if (field
== NULL_TREE
4916 || !(VAR_P (field
) || variable_template_p (field
)))
4917 error ("%q+#D is not a static data member of %q#T", decl
, context
);
4918 else if (variable_template_p (field
) && !this_tmpl
)
4920 if (DECL_LANG_SPECIFIC (decl
)
4921 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4922 /* OK, specialization was already checked. */;
4925 error_at (DECL_SOURCE_LOCATION (decl
),
4926 "non-member-template declaration of %qD", decl
);
4927 inform (DECL_SOURCE_LOCATION (field
), "does not match "
4928 "member template declaration here");
4929 return error_mark_node
;
4934 if (variable_template_p (field
))
4935 field
= DECL_TEMPLATE_RESULT (field
);
4937 if (DECL_CONTEXT (field
) != context
)
4939 if (!same_type_p (DECL_CONTEXT (field
), context
))
4940 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4941 "to be defined as %<%T::%D%>",
4942 DECL_CONTEXT (field
), DECL_NAME (decl
),
4943 context
, DECL_NAME (decl
));
4944 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4946 /* Static data member are tricky; an in-class initialization
4947 still doesn't provide a definition, so the in-class
4948 declaration will have DECL_EXTERNAL set, but will have an
4949 initialization. Thus, duplicate_decls won't warn
4950 about this situation, and so we check here. */
4951 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4952 error ("duplicate initialization of %qD", decl
);
4953 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4955 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4956 && !DECL_DECLARED_CONSTEXPR_P (field
))
4957 error ("%qD declared %<constexpr%> outside its class", field
);
4962 tree field
= check_classfn (context
, decl
,
4964 ? current_template_parms
4966 if (field
&& field
!= error_mark_node
4967 && duplicate_decls (decl
, field
,
4968 /*newdecl_is_friend=*/false))
4972 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4973 DECL_IN_AGGR_P (decl
) = 0;
4974 /* Do not mark DECL as an explicit specialization if it was not
4975 already marked as an instantiation; a declaration should
4976 never be marked as a specialization unless we know what
4977 template is being specialized. */
4978 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4980 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4981 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4982 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
4983 && DECL_DECLARED_INLINE_P (decl
));
4985 DECL_COMDAT (decl
) = false;
4987 /* [temp.expl.spec] An explicit specialization of a static data
4988 member of a template is a definition if the declaration
4989 includes an initializer; otherwise, it is a declaration.
4991 We check for processing_specialization so this only applies
4992 to the new specialization syntax. */
4993 if (!initialized
&& processing_specialization
)
4994 DECL_EXTERNAL (decl
) = 1;
4997 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4998 /* Aliases are definitions. */
5000 permerror (input_location
, "declaration of %q#D outside of class is not definition",
5004 was_public
= TREE_PUBLIC (decl
);
5006 /* Enter this declaration into the symbol table. Don't push the plain
5007 VAR_DECL for a variable template. */
5008 if (!template_parm_scope_p ()
5010 decl
= maybe_push_decl (decl
);
5012 if (processing_template_decl
)
5013 decl
= push_template_decl (decl
);
5014 if (decl
== error_mark_node
)
5015 return error_mark_node
;
5018 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
5019 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
5021 /* This is a const variable with implicit 'static'. Set
5022 DECL_THIS_STATIC so we can tell it from variables that are
5023 !TREE_PUBLIC because of the anonymous namespace. */
5024 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
5025 DECL_THIS_STATIC (decl
) = 1;
5028 if (current_function_decl
&& VAR_P (decl
)
5029 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
5032 if (CP_DECL_THREAD_LOCAL_P (decl
))
5033 error ("%qD declared %<thread_local%> in %<constexpr%> function",
5035 else if (TREE_STATIC (decl
))
5036 error ("%qD declared %<static%> in %<constexpr%> function", decl
);
5040 cp_function_chain
->invalid_constexpr
= true;
5043 if (!processing_template_decl
&& VAR_P (decl
))
5044 start_decl_1 (decl
, initialized
);
5049 /* Process the declaration of a variable DECL. INITIALIZED is true
5050 iff DECL is explicitly initialized. (INITIALIZED is false if the
5051 variable is initialized via an implicitly-called constructor.)
5052 This function must be called for ordinary variables (including, for
5053 example, implicit instantiations of templates), but must not be
5054 called for template declarations. */
5057 start_decl_1 (tree decl
, bool initialized
)
5061 bool aggregate_definition_p
;
5063 gcc_assert (!processing_template_decl
);
5065 if (error_operand_p (decl
))
5068 gcc_assert (VAR_P (decl
));
5070 type
= TREE_TYPE (decl
);
5071 complete_p
= COMPLETE_TYPE_P (type
);
5072 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5074 /* If an explicit initializer is present, or if this is a definition
5075 of an aggregate, then we need a complete type at this point.
5076 (Scalars are always complete types, so there is nothing to
5077 check.) This code just sets COMPLETE_P; errors (if necessary)
5078 are issued below. */
5079 if ((initialized
|| aggregate_definition_p
)
5081 && COMPLETE_TYPE_P (complete_type (type
)))
5084 /* We will not yet have set TREE_READONLY on DECL if the type
5085 was "const", but incomplete, before this point. But, now, we
5086 have a complete type, so we can try again. */
5087 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5091 /* Is it valid for this decl to have an initializer at all? */
5093 /* Don't allow initializations for incomplete types except for
5094 arrays which might be completed by the initialization. */
5096 ; /* A complete type is ok. */
5097 else if (type_uses_auto (type
))
5098 ; /* An auto type is ok. */
5099 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5101 error ("variable %q#D has initializer but incomplete type", decl
);
5102 type
= TREE_TYPE (decl
) = error_mark_node
;
5104 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5106 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5107 error ("elements of array %q#D have incomplete type", decl
);
5108 /* else we already gave an error in start_decl. */
5111 else if (aggregate_definition_p
&& !complete_p
)
5113 if (type_uses_auto (type
))
5114 error ("declaration of %q#D has no initializer", decl
);
5116 error ("aggregate %q#D has incomplete type and cannot be defined",
5118 /* Change the type so that assemble_variable will give
5119 DECL an rtl we can live with: (mem (const_int 0)). */
5120 type
= TREE_TYPE (decl
) = error_mark_node
;
5123 /* Create a new scope to hold this declaration if necessary.
5124 Whether or not a new scope is necessary cannot be determined
5125 until after the type has been completed; if the type is a
5126 specialization of a class template it is not until after
5127 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5128 will be set correctly. */
5129 maybe_push_cleanup_level (type
);
5132 /* Handle initialization of references. DECL, TYPE, and INIT have the
5133 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5134 but will be set to a new CLEANUP_STMT if a temporary is created
5135 that must be destroyed subsequently.
5137 Returns an initializer expression to use to initialize DECL, or
5138 NULL if the initialization can be performed statically.
5140 Quotes on semantics can be found in ARM 8.4.3. */
5143 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5145 if (init
== NULL_TREE
)
5147 if ((DECL_LANG_SPECIFIC (decl
) == 0
5148 || DECL_IN_AGGR_P (decl
) == 0)
5149 && ! DECL_THIS_EXTERN (decl
))
5150 error ("%qD declared as reference but not initialized", decl
);
5154 if (TREE_CODE (init
) == TREE_LIST
)
5155 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5156 tf_warning_or_error
);
5158 tree ttype
= TREE_TYPE (type
);
5159 if (TREE_CODE (ttype
) != ARRAY_TYPE
5160 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5161 /* Note: default conversion is only called in very special cases. */
5162 init
= decay_conversion (init
, tf_warning_or_error
);
5164 /* check_initializer handles this for non-reference variables, but for
5165 references we need to do it here or the initializer will get the
5166 incomplete array type and confuse later calls to
5167 cp_complete_array_type. */
5168 if (TREE_CODE (ttype
) == ARRAY_TYPE
5169 && TYPE_DOMAIN (ttype
) == NULL_TREE
5170 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5171 || TREE_CODE (init
) == STRING_CST
))
5173 cp_complete_array_type (&ttype
, init
, false);
5174 if (ttype
!= TREE_TYPE (type
))
5175 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5178 /* Convert INIT to the reference type TYPE. This may involve the
5179 creation of a temporary, whose lifetime must be the same as that
5180 of the reference. If so, a DECL_EXPR for the temporary will be
5181 added just after the DECL_EXPR for DECL. That's why we don't set
5182 DECL_INITIAL for local references (instead assigning to them
5183 explicitly); we need to allow the temporary to be initialized
5185 return initialize_reference (type
, init
, flags
,
5186 tf_warning_or_error
);
5189 /* Designated initializers in arrays are not supported in GNU C++.
5190 The parser cannot detect this error since it does not know whether
5191 a given brace-enclosed initializer is for a class type or for an
5192 array. This function checks that CE does not use a designated
5193 initializer. If it does, an error is issued. Returns true if CE
5194 is valid, i.e., does not have a designated initializer. */
5197 check_array_designated_initializer (constructor_elt
*ce
,
5198 unsigned HOST_WIDE_INT index
)
5200 /* Designated initializers for array elements are not supported. */
5203 /* The parser only allows identifiers as designated
5205 if (ce
->index
== error_mark_node
)
5207 error ("name used in a GNU-style designated "
5208 "initializer for an array");
5211 else if (identifier_p (ce
->index
))
5213 error ("name %qD used in a GNU-style designated "
5214 "initializer for an array", ce
->index
);
5218 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5221 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5222 && (TREE_CODE (ce_index
= maybe_constant_value (ce_index
))
5225 /* A C99 designator is OK if it matches the current index. */
5226 if (wi::eq_p (ce_index
, index
))
5229 sorry ("non-trivial designated initializers not supported");
5232 error ("C99 designator %qE is not an integral constant-expression",
5241 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5242 array until we finish parsing the initializer. If that's the
5243 situation we're in, update DECL accordingly. */
5246 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5248 tree type
= TREE_TYPE (decl
);
5250 if (TREE_CODE (type
) == ARRAY_TYPE
5251 && TYPE_DOMAIN (type
) == NULL_TREE
5252 && TREE_CODE (decl
) != TYPE_DECL
)
5254 /* do_default is really a C-ism to deal with tentative definitions.
5255 But let's leave it here to ease the eventual merge. */
5256 int do_default
= !DECL_EXTERNAL (decl
);
5257 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5260 /* Check that there are no designated initializers in INIT, as
5261 those are not supported in GNU C++, and as the middle-end
5262 will crash if presented with a non-numeric designated
5264 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5266 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5267 constructor_elt
*ce
;
5269 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5270 if (!check_array_designated_initializer (ce
, i
))
5276 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5280 error_at (EXPR_LOC_OR_LOC (initializer
,
5281 DECL_SOURCE_LOCATION (decl
)),
5282 "initializer fails to determine size of %qD", decl
);
5284 else if (failure
== 2)
5288 error_at (DECL_SOURCE_LOCATION (decl
),
5289 "array size missing in %qD", decl
);
5291 /* If a `static' var's size isn't known, make it extern as
5292 well as static, so it does not get allocated. If it's not
5293 `static', then don't mark it extern; finish_incomplete_decl
5294 will give it a default size and it will get allocated. */
5295 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5296 DECL_EXTERNAL (decl
) = 1;
5298 else if (failure
== 3)
5300 error_at (DECL_SOURCE_LOCATION (decl
),
5301 "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_or_array_type_p (type
))
5333 layout_decl (decl
, 0);
5335 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5337 /* An automatic variable with an incomplete type: that is an error.
5338 Don't talk about array types here, since we took care of that
5339 message in grokdeclarator. */
5340 error_at (DECL_SOURCE_LOCATION (decl
),
5341 "storage size of %qD isn%'t known", decl
);
5342 TREE_TYPE (decl
) = error_mark_node
;
5345 /* Keep this code around in case we later want to control debug info
5346 based on whether a type is "used". (jason 1999-11-11) */
5348 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5349 /* Let debugger know it should output info for this type. */
5350 note_debug_info_needed (ttype
);
5352 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5353 note_debug_info_needed (DECL_CONTEXT (decl
));
5356 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5357 && DECL_SIZE (decl
) != NULL_TREE
5358 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5360 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5361 constant_expression_warning (DECL_SIZE (decl
));
5364 error_at (DECL_SOURCE_LOCATION (decl
),
5365 "storage size of %qD isn%'t constant", decl
);
5366 TREE_TYPE (decl
) = error_mark_node
;
5371 /* If a local static variable is declared in an inline function, or if
5372 we have a weak definition, we must endeavor to create only one
5373 instance of the variable at link-time. */
5376 maybe_commonize_var (tree decl
)
5378 /* Static data in a function with comdat linkage also has comdat
5380 if (TREE_STATIC (decl
)
5381 /* Don't mess with __FUNCTION__. */
5382 && ! DECL_ARTIFICIAL (decl
)
5383 && DECL_FUNCTION_SCOPE_P (decl
)
5384 && vague_linkage_p (DECL_CONTEXT (decl
)))
5388 /* With weak symbols, we simply make the variable COMDAT;
5389 that will cause copies in multiple translations units to
5391 comdat_linkage (decl
);
5395 if (DECL_INITIAL (decl
) == NULL_TREE
5396 || DECL_INITIAL (decl
) == error_mark_node
)
5398 /* Without weak symbols, we can use COMMON to merge
5399 uninitialized variables. */
5400 TREE_PUBLIC (decl
) = 1;
5401 DECL_COMMON (decl
) = 1;
5405 /* While for initialized variables, we must use internal
5406 linkage -- which means that multiple copies will not
5408 TREE_PUBLIC (decl
) = 0;
5409 DECL_COMMON (decl
) = 0;
5410 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5411 "sorry: semantics of inline function static "
5412 "data %q#D are wrong (you%'ll wind up "
5413 "with multiple copies)", decl
))
5414 inform (DECL_SOURCE_LOCATION (decl
),
5415 "you can work around this by removing the initializer");
5421 /* Issue an error message if DECL is an uninitialized const variable. */
5424 check_for_uninitialized_const_var (tree decl
)
5426 tree type
= strip_array_types (TREE_TYPE (decl
));
5428 /* ``Unless explicitly declared extern, a const object does not have
5429 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5432 && TREE_CODE (type
) != REFERENCE_TYPE
5433 && (CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5434 && !DECL_INITIAL (decl
))
5436 tree field
= default_init_uninitialized_part (type
);
5440 if (CP_TYPE_CONST_P (type
))
5441 permerror (DECL_SOURCE_LOCATION (decl
),
5442 "uninitialized const %qD", decl
);
5445 error_at (DECL_SOURCE_LOCATION (decl
),
5446 "uninitialized variable %qD in %<constexpr%> function",
5448 cp_function_chain
->invalid_constexpr
= true;
5451 if (CLASS_TYPE_P (type
))
5453 tree defaulted_ctor
;
5455 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5456 "%q#T has no user-provided default constructor", type
);
5457 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5459 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5460 "constructor is not user-provided because it is "
5461 "explicitly defaulted in the class body");
5462 inform (DECL_SOURCE_LOCATION (field
),
5463 "and the implicitly-defined constructor does not "
5464 "initialize %q#D", field
);
5469 /* Structure holding the current initializer being processed by reshape_init.
5470 CUR is a pointer to the current element being processed, END is a pointer
5471 after the last element present in the initializer. */
5474 constructor_elt
*cur
;
5475 constructor_elt
*end
;
5478 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5480 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5481 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5482 initialized. If there are no more such fields, the return value
5486 next_initializable_field (tree field
)
5489 && (TREE_CODE (field
) != FIELD_DECL
5490 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5491 || DECL_ARTIFICIAL (field
)))
5492 field
= DECL_CHAIN (field
);
5497 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5498 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5499 INTEGER_CST representing the size of the array minus one (the maximum index),
5500 or NULL_TREE if the array was declared without specifying the size. D is
5501 the iterator within the constructor. */
5504 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5505 tsubst_flags_t complain
)
5508 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5509 unsigned HOST_WIDE_INT max_index_cst
= 0;
5510 unsigned HOST_WIDE_INT index
;
5512 /* The initializer for an array is always a CONSTRUCTOR. */
5513 new_init
= build_constructor (init_list_type_node
, NULL
);
5517 /* Minus 1 is used for zero sized arrays. */
5518 if (integer_all_onesp (max_index
))
5521 if (tree_fits_uhwi_p (max_index
))
5522 max_index_cst
= tree_to_uhwi (max_index
);
5523 /* sizetype is sign extended, not zero extended. */
5525 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5528 /* Loop until there are no more initializers. */
5530 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5534 constructor_elt
*old_cur
= d
->cur
;
5536 check_array_designated_initializer (d
->cur
, index
);
5537 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5539 if (elt_init
== error_mark_node
)
5540 return error_mark_node
;
5541 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5542 size_int (index
), elt_init
);
5543 if (!TREE_CONSTANT (elt_init
))
5544 TREE_CONSTANT (new_init
) = false;
5546 /* This can happen with an invalid initializer (c++/54501). */
5547 if (d
->cur
== old_cur
&& !sized_array_p
)
5554 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5555 Parameters are the same of reshape_init_r. */
5558 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5560 tree max_index
= NULL_TREE
;
5562 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5564 if (TYPE_DOMAIN (type
))
5565 max_index
= array_type_nelts (type
);
5567 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5570 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5571 Parameters are the same of reshape_init_r. */
5574 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5576 tree max_index
= NULL_TREE
;
5578 gcc_assert (VECTOR_TYPE_P (type
));
5580 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5582 tree value
= d
->cur
->value
;
5583 if (!same_type_p (TREE_TYPE (value
), type
))
5585 if (complain
& tf_error
)
5586 error ("invalid type %qT as initializer for a vector of type %qT",
5587 TREE_TYPE (d
->cur
->value
), type
);
5588 value
= error_mark_node
;
5594 /* For a vector, we initialize it as an array of the appropriate size. */
5595 if (VECTOR_TYPE_P (type
))
5596 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5598 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5601 /* Subroutine of reshape_init_r, processes the initializers for classes
5602 or union. Parameters are the same of reshape_init_r. */
5605 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5606 tsubst_flags_t complain
)
5611 gcc_assert (CLASS_TYPE_P (type
));
5613 /* The initializer for a class is always a CONSTRUCTOR. */
5614 new_init
= build_constructor (init_list_type_node
, NULL
);
5615 field
= next_initializable_field (TYPE_FIELDS (type
));
5621 An initializer for an aggregate member that is an
5622 empty class shall have the form of an empty
5623 initializer-list {}. */
5624 if (!first_initializer_p
)
5626 if (complain
& tf_error
)
5627 error ("initializer for %qT must be brace-enclosed", type
);
5628 return error_mark_node
;
5633 /* Loop through the initializable fields, gathering initializers. */
5634 while (d
->cur
!= d
->end
)
5637 constructor_elt
*old_cur
= d
->cur
;
5639 /* Handle designated initializers, as an extension. */
5642 if (d
->cur
->index
== error_mark_node
)
5643 return error_mark_node
;
5645 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5646 /* We already reshaped this. */
5647 gcc_assert (d
->cur
->index
== field
);
5648 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5649 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5652 if (complain
& tf_error
)
5653 error ("%<[%E] =%> used in a GNU-style designated initializer"
5654 " for class %qT", d
->cur
->index
, type
);
5655 return error_mark_node
;
5658 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5660 if (complain
& tf_error
)
5661 error ("%qT has no non-static data member named %qD", type
,
5663 return error_mark_node
;
5667 /* If we processed all the member of the class, we are done. */
5671 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5672 /*first_initializer_p=*/false, complain
);
5673 if (field_init
== error_mark_node
)
5674 return error_mark_node
;
5676 if (d
->cur
== old_cur
&& d
->cur
->index
)
5678 /* This can happen with an invalid initializer for a flexible
5679 array member (c++/54441). */
5680 if (complain
& tf_error
)
5681 error ("invalid initializer for %q#D", field
);
5682 return error_mark_node
;
5685 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5689 When a union is initialized with a brace-enclosed
5690 initializer, the braces shall only contain an
5691 initializer for the first member of the union. */
5692 if (TREE_CODE (type
) == UNION_TYPE
)
5695 field
= next_initializable_field (DECL_CHAIN (field
));
5701 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5702 designators are not valid; either complain or return true to indicate
5703 that reshape_init_r should return error_mark_node. */
5706 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5710 if (complain
& tf_error
)
5711 error ("C99 designator %qE outside aggregate initializer",
5719 /* Subroutine of reshape_init, which processes a single initializer (part of
5720 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5721 iterator within the CONSTRUCTOR which points to the initializer to process.
5722 FIRST_INITIALIZER_P is true if this is the first initializer of the
5723 outermost CONSTRUCTOR node. */
5726 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5727 tsubst_flags_t complain
)
5729 tree init
= d
->cur
->value
;
5731 if (error_operand_p (init
))
5732 return error_mark_node
;
5734 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5735 && has_designator_problem (d
, complain
))
5736 return error_mark_node
;
5738 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5740 /* A complex type can be initialized from one or two initializers,
5741 but braces are not elided. */
5743 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5745 if (CONSTRUCTOR_NELTS (init
) > 2)
5747 if (complain
& tf_error
)
5748 error ("too many initializers for %qT", type
);
5750 return error_mark_node
;
5753 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5755 vec
<constructor_elt
, va_gc
> *v
= 0;
5756 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5757 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5758 if (has_designator_problem (d
, complain
))
5759 return error_mark_node
;
5761 init
= build_constructor (init_list_type_node
, v
);
5766 /* A non-aggregate type is always initialized with a single
5768 if (!CP_AGGREGATE_TYPE_P (type
))
5770 /* It is invalid to initialize a non-aggregate type with a
5771 brace-enclosed initializer before C++0x.
5772 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5773 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5774 a CONSTRUCTOR (with a record type). */
5775 if (TREE_CODE (init
) == CONSTRUCTOR
5776 /* Don't complain about a capture-init. */
5777 && !CONSTRUCTOR_IS_DIRECT_INIT (init
)
5778 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5780 if (SCALAR_TYPE_P (type
))
5782 if (cxx_dialect
< cxx11
5783 /* Isn't value-initialization. */
5784 || CONSTRUCTOR_NELTS (init
) > 0)
5786 if (complain
& tf_error
)
5787 error ("braces around scalar initializer for type %qT",
5789 init
= error_mark_node
;
5793 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5800 /* "If T is a class type and the initializer list has a single element of
5801 type cv U, where U is T or a class derived from T, the object is
5802 initialized from that element." Even if T is an aggregate. */
5803 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5804 && first_initializer_p
5805 && d
->end
- d
->cur
== 1
5806 && reference_related_p (type
, TREE_TYPE (init
)))
5814 All implicit type conversions (clause _conv_) are considered when
5815 initializing the aggregate member with an initializer from an
5816 initializer-list. If the initializer can initialize a member,
5817 the member is initialized. Otherwise, if the member is itself a
5818 non-empty subaggregate, brace elision is assumed and the
5819 initializer is considered for the initialization of the first
5820 member of the subaggregate. */
5821 if (TREE_CODE (init
) != CONSTRUCTOR
5822 /* But don't try this for the first initializer, since that would be
5823 looking through the outermost braces; A a2 = { a1 }; is not a
5824 valid aggregate initialization. */
5825 && !first_initializer_p
5826 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5827 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5834 /* [dcl.init.string]
5836 A char array (whether plain char, signed char, or unsigned char)
5837 can be initialized by a string-literal (optionally enclosed in
5838 braces); a wchar_t array can be initialized by a wide
5839 string-literal (optionally enclosed in braces). */
5840 if (TREE_CODE (type
) == ARRAY_TYPE
5841 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5843 tree str_init
= init
;
5845 /* Strip one level of braces if and only if they enclose a single
5846 element (as allowed by [dcl.init.string]). */
5847 if (!first_initializer_p
5848 && TREE_CODE (str_init
) == CONSTRUCTOR
5849 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5851 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5854 /* If it's a string literal, then it's the initializer for the array
5855 as a whole. Otherwise, continue with normal initialization for
5856 array types (one value per array element). */
5857 if (TREE_CODE (str_init
) == STRING_CST
)
5859 if (has_designator_problem (d
, complain
))
5860 return error_mark_node
;
5866 /* The following cases are about aggregates. If we are not within a full
5867 initializer already, and there is not a CONSTRUCTOR, it means that there
5868 is a missing set of braces (that is, we are processing the case for
5869 which reshape_init exists). */
5870 if (!first_initializer_p
)
5872 if (TREE_CODE (init
) == CONSTRUCTOR
)
5874 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5875 /* There is no need to reshape pointer-to-member function
5876 initializers, as they are always constructed correctly
5877 by the front end. */
5879 else if (COMPOUND_LITERAL_P (init
))
5880 /* For a nested compound literal, there is no need to reshape since
5881 brace elision is not allowed. Even if we decided to allow it,
5882 we should add a call to reshape_init in finish_compound_literal,
5883 before calling digest_init, so changing this code would still
5884 not be necessary. */
5885 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5889 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5890 return reshape_init (type
, init
, complain
);
5894 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5898 /* Dispatch to specialized routines. */
5899 if (CLASS_TYPE_P (type
))
5900 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5901 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5902 return reshape_init_array (type
, d
, complain
);
5903 else if (VECTOR_TYPE_P (type
))
5904 return reshape_init_vector (type
, d
, complain
);
5909 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5910 brace-enclosed aggregate initializer.
5912 INIT is the CONSTRUCTOR containing the list of initializers describing
5913 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5914 It may not presently match the shape of the TYPE; for example:
5916 struct S { int a; int b; };
5917 struct S a[] = { 1, 2, 3, 4 };
5919 Here INIT will hold a vector of four elements, rather than a
5920 vector of two elements, each itself a vector of two elements. This
5921 routine transforms INIT from the former form into the latter. The
5922 revised CONSTRUCTOR node is returned. */
5925 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5927 vec
<constructor_elt
, va_gc
> *v
;
5931 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5933 v
= CONSTRUCTOR_ELTS (init
);
5935 /* An empty constructor does not need reshaping, and it is always a valid
5937 if (vec_safe_is_empty (v
))
5940 /* Recurse on this CONSTRUCTOR. */
5942 d
.end
= d
.cur
+ v
->length ();
5944 new_init
= reshape_init_r (type
, &d
, true, complain
);
5945 if (new_init
== error_mark_node
)
5946 return error_mark_node
;
5948 /* Make sure all the element of the constructor were used. Otherwise,
5949 issue an error about exceeding initializers. */
5952 if (complain
& tf_error
)
5953 error ("too many initializers for %qT", type
);
5955 return error_mark_node
;
5961 /* Verify array initializer. Returns true if errors have been reported. */
5964 check_array_initializer (tree decl
, tree type
, tree init
)
5966 tree element_type
= TREE_TYPE (type
);
5968 /* The array type itself need not be complete, because the
5969 initializer may tell us how many elements are in the array.
5970 But, the elements of the array must be complete. */
5971 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5974 error_at (DECL_SOURCE_LOCATION (decl
),
5975 "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_at (DECL_SOURCE_LOCATION (decl
),
6040 "%q#D has incomplete type", decl
);
6041 TREE_TYPE (decl
) = error_mark_node
;
6045 /* There is no way to make a variable-sized class type in GNU C++. */
6046 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
6048 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
6050 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
6051 if (SCALAR_TYPE_P (type
))
6055 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6056 init
= build_zero_init (type
, NULL_TREE
, false);
6058 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6060 error_at (EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (decl
)),
6061 "scalar object %qD requires one element in "
6062 "initializer", decl
);
6063 TREE_TYPE (decl
) = error_mark_node
;
6069 if (TREE_CODE (decl
) == CONST_DECL
)
6071 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
6073 DECL_INITIAL (decl
) = init
;
6075 gcc_assert (init
!= NULL_TREE
);
6078 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6080 else if (init
|| type_build_ctor_call (type
)
6081 || TREE_CODE (type
) == REFERENCE_TYPE
)
6083 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6085 init
= grok_reference_init (decl
, type
, init
, flags
);
6086 flags
|= LOOKUP_ALREADY_DIGESTED
;
6089 check_for_uninitialized_const_var (decl
);
6090 /* Do not reshape constructors of vectors (they don't need to be
6092 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6094 if (is_std_init_list (type
))
6096 init
= perform_implicit_conversion (type
, init
,
6097 tf_warning_or_error
);
6098 flags
|= LOOKUP_ALREADY_DIGESTED
;
6100 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6102 /* Don't reshape if the class has constructors. */
6103 if (cxx_dialect
== cxx98
)
6104 error_at (EXPR_LOC_OR_LOC (init
, DECL_SOURCE_LOCATION (decl
)),
6105 "in C++98 %qD must be initialized by "
6106 "constructor, not by %<{...}%>",
6109 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6111 error ("opaque vector types cannot be initialized");
6112 init
= error_mark_node
;
6116 init
= reshape_init (type
, init
, tf_warning_or_error
);
6117 flags
|= LOOKUP_NO_NARROWING
;
6120 else if (TREE_CODE (init
) == TREE_LIST
6121 && TREE_TYPE (init
) != unknown_type_node
6122 && !MAYBE_CLASS_TYPE_P (type
))
6124 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6126 /* We get here with code like `int a (2);' */
6127 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6128 tf_warning_or_error
);
6131 /* If DECL has an array type without a specific bound, deduce the
6132 array size from the initializer. */
6133 maybe_deduce_size_from_array_init (decl
, init
);
6134 type
= TREE_TYPE (decl
);
6135 if (type
== error_mark_node
)
6138 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6139 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6140 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6141 && CP_AGGREGATE_TYPE_P (type
)
6142 && (CLASS_TYPE_P (type
)
6143 || !TYPE_NEEDS_CONSTRUCTING (type
)
6144 || type_has_extended_temps (type
))))
6146 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6148 /* A constructor call is a non-trivial initializer even if
6149 it isn't explicitly written. */
6150 if (TREE_SIDE_EFFECTS (init_code
))
6151 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6153 /* If this is a constexpr initializer, expand_default_init will
6154 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6155 case, pull the initializer back out and pass it down into
6156 store_init_value. */
6157 while (TREE_CODE (init_code
) == EXPR_STMT
6158 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6159 init_code
= TREE_OPERAND (init_code
, 0);
6160 if (TREE_CODE (init_code
) == INIT_EXPR
)
6162 init
= TREE_OPERAND (init_code
, 1);
6163 init_code
= NULL_TREE
;
6164 /* Don't call digest_init; it's unnecessary and will complain
6165 about aggregate initialization of non-aggregate classes. */
6166 flags
|= LOOKUP_ALREADY_DIGESTED
;
6168 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6170 /* Declared constexpr, but no suitable initializer; massage
6171 init appropriately so we can pass it into store_init_value
6173 if (CLASS_TYPE_P (type
)
6174 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6176 init
= build_functional_cast (type
, init
, tf_none
);
6177 if (TREE_CODE (init
) == TARGET_EXPR
)
6178 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6180 init_code
= NULL_TREE
;
6186 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6188 /* In aggregate initialization of a variable, each element
6189 initialization is a full-expression because there is no
6190 enclosing expression. */
6191 gcc_assert (stmts_are_full_exprs_p ());
6193 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6195 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6196 && DECL_INITIAL (decl
)
6197 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6198 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6199 warning_at (EXPR_LOC_OR_LOC (DECL_INITIAL (decl
),
6200 DECL_SOURCE_LOCATION (decl
)),
6201 0, "array %qD initialized by parenthesized "
6202 "string literal %qE",
6203 decl
, DECL_INITIAL (decl
));
6209 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6210 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6211 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6212 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6215 check_for_uninitialized_const_var (decl
);
6218 if (init
&& init
!= error_mark_node
)
6219 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6223 /* We might have set these in cp_finish_decl. */
6224 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6225 TREE_CONSTANT (decl
) = false;
6228 if (init_code
&& DECL_IN_AGGR_P (decl
))
6230 static int explained
= 0;
6232 if (cxx_dialect
< cxx11
)
6233 error ("initializer invalid for static member with constructor");
6235 error ("non-constant in-class initialization invalid for static "
6236 "member %qD", decl
);
6239 inform (input_location
,
6240 "(an out of class initialization is required)");
6249 /* If DECL is not a local variable, give it RTL. */
6252 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6254 int toplev
= toplevel_bindings_p ();
6257 /* Set the DECL_ASSEMBLER_NAME for the object. */
6260 /* The `register' keyword, when used together with an
6261 asm-specification, indicates that the variable should be
6262 placed in a particular register. */
6263 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6265 set_user_assembler_name (decl
, asmspec
);
6266 DECL_HARD_REGISTER (decl
) = 1;
6270 if (TREE_CODE (decl
) == FUNCTION_DECL
6271 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6272 set_builtin_user_assembler_name (decl
, asmspec
);
6273 set_user_assembler_name (decl
, asmspec
);
6277 /* Handle non-variables up front. */
6280 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6284 /* If we see a class member here, it should be a static data
6286 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6288 gcc_assert (TREE_STATIC (decl
));
6289 /* An in-class declaration of a static data member should be
6290 external; it is only a declaration, and not a definition. */
6291 if (init
== NULL_TREE
)
6292 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
6295 /* We don't create any RTL for local variables. */
6296 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6299 /* We defer emission of local statics until the corresponding
6300 DECL_EXPR is expanded. But with constexpr its function might never
6301 be expanded, so go ahead and tell cgraph about the variable now. */
6302 defer_p
= ((DECL_FUNCTION_SCOPE_P (decl
)
6303 && !DECL_DECLARED_CONSTEXPR_P (DECL_CONTEXT (decl
)))
6304 || DECL_VIRTUAL_P (decl
));
6306 /* Defer template instantiations. */
6307 if (DECL_LANG_SPECIFIC (decl
)
6308 && DECL_IMPLICIT_INSTANTIATION (decl
))
6311 /* If we're not deferring, go ahead and assemble the variable. */
6313 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6316 /* walk_tree helper for wrap_temporary_cleanups, below. */
6319 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6321 /* Stop at types or full-expression boundaries. */
6322 if (TYPE_P (*stmt_p
)
6323 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6329 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6331 tree guard
= (tree
)data
;
6332 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6334 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6335 /* Tell honor_protect_cleanup_actions to handle this as a separate
6337 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6339 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6345 /* We're initializing a local variable which has a cleanup GUARD. If there
6346 are any temporaries used in the initializer INIT of this variable, we
6347 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6348 variable will be cleaned up properly if one of them throws.
6350 Unfortunately, there's no way to express this properly in terms of
6351 nesting, as the regions for the temporaries overlap the region for the
6352 variable itself; if there are two temporaries, the variable needs to be
6353 the first thing destroyed if either of them throws. However, we only
6354 want to run the variable's cleanup if it actually got constructed. So
6355 we need to guard the temporary cleanups with the variable's cleanup if
6356 they are run on the normal path, but not if they are run on the
6357 exceptional path. We implement this by telling
6358 honor_protect_cleanup_actions to strip the variable cleanup from the
6359 exceptional path. */
6362 wrap_temporary_cleanups (tree init
, tree guard
)
6364 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6367 /* Generate code to initialize DECL (a local variable). */
6370 initialize_local_var (tree decl
, tree init
)
6372 tree type
= TREE_TYPE (decl
);
6376 gcc_assert (VAR_P (decl
)
6377 || TREE_CODE (decl
) == RESULT_DECL
);
6378 gcc_assert (!TREE_STATIC (decl
));
6380 if (DECL_SIZE (decl
) == NULL_TREE
)
6382 /* If we used it already as memory, it must stay in memory. */
6383 DECL_INITIAL (decl
) = NULL_TREE
;
6384 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6388 if (type
== error_mark_node
)
6391 /* Compute and store the initial value. */
6392 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6393 if (TREE_USED (type
))
6394 DECL_READ_P (decl
) = 1;
6396 /* Generate a cleanup, if necessary. */
6397 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6399 /* Perform the initialization. */
6402 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6403 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6404 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6406 /* Stick simple initializers in DECL_INITIAL so that
6407 -Wno-init-self works (c++/34772). */
6408 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6409 DECL_INITIAL (decl
) = rinit
;
6411 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6415 warning_at (DECL_SOURCE_LOCATION (decl
),
6417 "reference %qD is initialized with itself", decl
);
6422 int saved_stmts_are_full_exprs_p
;
6424 /* If we're only initializing a single object, guard the
6425 destructors of any temporaries used in its initializer with
6426 its destructor. This isn't right for arrays because each
6427 element initialization is a full-expression. */
6428 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6429 wrap_temporary_cleanups (init
, cleanup
);
6431 gcc_assert (building_stmt_list_p ());
6432 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6433 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6434 finish_expr_stmt (init
);
6435 current_stmt_tree ()->stmts_are_full_exprs_p
=
6436 saved_stmts_are_full_exprs_p
;
6440 /* Set this to 0 so we can tell whether an aggregate which was
6441 initialized was ever used. Don't do this if it has a
6442 destructor, so we don't complain about the 'resource
6443 allocation is initialization' idiom. Now set
6444 attribute((unused)) on types so decls of that type will be
6445 marked used. (see TREE_USED, above.) */
6446 if (TYPE_NEEDS_CONSTRUCTING (type
)
6448 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6449 && DECL_NAME (decl
))
6450 TREE_USED (decl
) = 0;
6451 else if (already_used
)
6452 TREE_USED (decl
) = 1;
6455 finish_decl_cleanup (decl
, cleanup
);
6458 /* DECL is a VAR_DECL for a compiler-generated variable with static
6459 storage duration (like a virtual table) whose initializer is a
6460 compile-time constant. Initialize the variable and provide it to the
6464 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6467 gcc_assert (DECL_ARTIFICIAL (decl
));
6468 init
= build_constructor (TREE_TYPE (decl
), v
);
6469 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6470 DECL_INITIAL (decl
) = init
;
6471 DECL_INITIALIZED_P (decl
) = 1;
6472 determine_visibility (decl
);
6473 layout_var_decl (decl
);
6474 maybe_commonize_var (decl
);
6475 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6478 /* INIT is the initializer for a variable, as represented by the
6479 parser. Returns true iff INIT is type-dependent. */
6482 type_dependent_init_p (tree init
)
6484 if (TREE_CODE (init
) == TREE_LIST
)
6485 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6486 return any_type_dependent_elements_p (init
);
6487 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6488 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6490 vec
<constructor_elt
, va_gc
> *elts
;
6494 elts
= CONSTRUCTOR_ELTS (init
);
6495 nelts
= vec_safe_length (elts
);
6496 for (i
= 0; i
< nelts
; ++i
)
6497 if (type_dependent_init_p ((*elts
)[i
].value
))
6501 /* It must be a simple expression, e.g., int i = 3; */
6502 return type_dependent_expression_p (init
);
6507 /* INIT is the initializer for a variable, as represented by the
6508 parser. Returns true iff INIT is value-dependent. */
6511 value_dependent_init_p (tree init
)
6513 if (TREE_CODE (init
) == TREE_LIST
)
6514 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6515 return any_value_dependent_elements_p (init
);
6516 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6517 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6519 vec
<constructor_elt
, va_gc
> *elts
;
6523 elts
= CONSTRUCTOR_ELTS (init
);
6524 nelts
= vec_safe_length (elts
);
6525 for (i
= 0; i
< nelts
; ++i
)
6526 if (value_dependent_init_p ((*elts
)[i
].value
))
6530 /* It must be a simple expression, e.g., int i = 3; */
6531 return value_dependent_expression_p (init
);
6536 // Returns true if a DECL is VAR_DECL with the concept specifier.
6538 is_concept_var (tree decl
)
6540 return (VAR_P (decl
)
6541 // Not all variables have DECL_LANG_SPECIFIC.
6542 && DECL_LANG_SPECIFIC (decl
)
6543 && DECL_DECLARED_CONCEPT_P (decl
));
6546 /* A helper function to be called via walk_tree. If any label exists
6547 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6550 notice_forced_label_r (tree
*tp
, int *walk_subtrees
, void *)
6554 if (TREE_CODE (*tp
) == LABEL_DECL
)
6555 cfun
->has_forced_label_in_static
= 1;
6559 /* Finish processing of a declaration;
6560 install its line number and initial value.
6561 If the length of an array type is not known before,
6562 it must be determined now, from the initial value, or it is an error.
6564 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6565 true, then INIT is an integral constant expression.
6567 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6568 if the (init) syntax was used. */
6571 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6572 tree asmspec_tree
, int flags
)
6575 vec
<tree
, va_gc
> *cleanups
= NULL
;
6576 const char *asmspec
= NULL
;
6577 int was_readonly
= 0;
6578 bool var_definition_p
= false;
6581 if (decl
== error_mark_node
)
6586 error ("assignment (not initialization) in declaration");
6590 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6591 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6592 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6594 type
= TREE_TYPE (decl
);
6595 if (type
== error_mark_node
)
6598 /* If a name was specified, get the string. */
6599 if (at_namespace_scope_p ())
6600 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6601 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6602 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6604 if (current_class_type
6605 && CP_DECL_CONTEXT (decl
) == current_class_type
6606 && TYPE_BEING_DEFINED (current_class_type
)
6607 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6608 && (DECL_INITIAL (decl
) || init
))
6609 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6611 if (TREE_CODE (decl
) != FUNCTION_DECL
6612 && (auto_node
= type_uses_auto (type
)))
6615 if (init
== NULL_TREE
)
6617 if (DECL_LANG_SPECIFIC (decl
)
6618 && DECL_TEMPLATE_INSTANTIATION (decl
)
6619 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6621 /* init is null because we're deferring instantiating the
6622 initializer until we need it. Well, we need it now. */
6623 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6627 error ("declaration of %q#D has no initializer", decl
);
6628 TREE_TYPE (decl
) = error_mark_node
;
6632 if (TREE_CODE (d_init
) == TREE_LIST
)
6633 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6634 tf_warning_or_error
);
6635 d_init
= resolve_nondeduced_context (d_init
, tf_warning_or_error
);
6636 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6638 tf_warning_or_error
,
6640 if (type
== error_mark_node
)
6642 if (TREE_CODE (type
) == FUNCTION_TYPE
)
6644 error ("initializer for %<decltype(auto) %D%> has function type "
6645 "(did you forget the %<()%> ?)", decl
);
6646 TREE_TYPE (decl
) = error_mark_node
;
6649 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6652 if (!ensure_literal_type_for_constexpr_object (decl
))
6653 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6656 && DECL_CLASS_SCOPE_P (decl
)
6657 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6658 check_static_variable_definition (decl
, type
);
6660 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6663 if (init
== ridpointers
[(int)RID_DELETE
])
6665 /* FIXME check this is 1st decl. */
6666 DECL_DELETED_FN (decl
) = 1;
6667 DECL_DECLARED_INLINE_P (decl
) = 1;
6668 DECL_INITIAL (decl
) = error_mark_node
;
6669 FOR_EACH_CLONE (clone
, decl
)
6671 DECL_DELETED_FN (clone
) = 1;
6672 DECL_DECLARED_INLINE_P (clone
) = 1;
6673 DECL_INITIAL (clone
) = error_mark_node
;
6677 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6679 if (defaultable_fn_check (decl
))
6680 DECL_DEFAULTED_FN (decl
) = 1;
6682 DECL_INITIAL (decl
) = NULL_TREE
;
6686 if (init
&& VAR_P (decl
))
6688 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6689 /* If DECL is a reference, then we want to know whether init is a
6690 reference constant; init_const_expr_p as passed tells us whether
6691 it's an rvalue constant. */
6692 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6693 init_const_expr_p
= potential_constant_expression (init
);
6694 if (init_const_expr_p
)
6696 /* Set these flags now for templates. We'll update the flags in
6697 store_init_value for instantiations. */
6698 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6699 if (decl_maybe_constant_var_p (decl
))
6700 TREE_CONSTANT (decl
) = 1;
6704 if (processing_template_decl
)
6706 bool type_dependent_p
;
6708 /* Add this declaration to the statement-tree. */
6709 if (at_function_scope_p ())
6710 add_decl_expr (decl
);
6712 type_dependent_p
= dependent_type_p (type
);
6714 if (check_for_bare_parameter_packs (init
))
6717 DECL_INITIAL (decl
) = NULL_TREE
;
6720 /* Generally, initializers in templates are expanded when the
6721 template is instantiated. But, if DECL is a variable constant
6722 then it can be used in future constant expressions, so its value
6723 must be available. */
6725 if (!VAR_P (decl
) || type_dependent_p
)
6726 /* We can't do anything if the decl has dependent type. */;
6728 && init_const_expr_p
6729 && TREE_CODE (type
) != REFERENCE_TYPE
6730 && decl_maybe_constant_var_p (decl
)
6731 && !type_dependent_init_p (init
)
6732 && !value_dependent_init_p (init
))
6734 /* This variable seems to be a non-dependent constant, so process
6735 its initializer. If check_initializer returns non-null the
6736 initialization wasn't constant after all. */
6738 cleanups
= make_tree_vector ();
6739 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6740 if (init_code
== NULL_TREE
)
6742 release_tree_vector (cleanups
);
6744 else if (!init
&& is_concept_var (decl
))
6745 error ("variable concept has no initializer");
6746 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6748 /* Deduce array size even if the initializer is dependent. */
6749 maybe_deduce_size_from_array_init (decl
, init
);
6750 /* And complain about multiple initializers. */
6751 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6752 && !MAYBE_CLASS_TYPE_P (type
))
6753 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6754 tf_warning_or_error
);
6758 DECL_INITIAL (decl
) = init
;
6762 /* Just store non-static data member initializers for later. */
6763 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6764 DECL_INITIAL (decl
) = init
;
6766 /* Take care of TYPE_DECLs up front. */
6767 if (TREE_CODE (decl
) == TYPE_DECL
)
6769 if (type
!= error_mark_node
6770 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6772 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6773 warning (0, "shadowing previous type declaration of %q#D", decl
);
6774 set_identifier_type_value (DECL_NAME (decl
), decl
);
6777 /* If we have installed this as the canonical typedef for this
6778 type, and that type has not been defined yet, delay emitting
6779 the debug information for it, as we will emit it later. */
6780 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6781 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6782 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6784 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6789 /* A reference will be modified here, as it is initialized. */
6790 if (! DECL_EXTERNAL (decl
)
6791 && TREE_READONLY (decl
)
6792 && TREE_CODE (type
) == REFERENCE_TYPE
)
6795 TREE_READONLY (decl
) = 0;
6800 /* If this is a local variable that will need a mangled name,
6801 register it now. We must do this before processing the
6802 initializer for the variable, since the initialization might
6803 require a guard variable, and since the mangled name of the
6804 guard variable will depend on the mangled name of this
6806 if (DECL_FUNCTION_SCOPE_P (decl
)
6807 && TREE_STATIC (decl
)
6808 && !DECL_ARTIFICIAL (decl
))
6810 push_local_name (decl
);
6811 /* Normally has_forced_label_in_static is set during GIMPLE
6812 lowering, but [cd]tors are never actually compiled directly.
6813 We need to set this early so we can deal with the label
6814 address extension. */
6815 if ((DECL_CONSTRUCTOR_P (current_function_decl
)
6816 || DECL_DESTRUCTOR_P (current_function_decl
))
6819 walk_tree (&init
, notice_forced_label_r
, NULL
, NULL
);
6820 add_local_decl (cfun
, decl
);
6822 /* And make sure it's in the symbol table for
6823 c_parse_final_cleanups to find. */
6824 varpool_node::get_create (decl
);
6827 /* Convert the initializer to the type of DECL, if we have not
6828 already initialized DECL. */
6829 if (!DECL_INITIALIZED_P (decl
)
6830 /* If !DECL_EXTERNAL then DECL is being defined. In the
6831 case of a static data member initialized inside the
6832 class-specifier, there can be an initializer even if DECL
6833 is *not* defined. */
6834 && (!DECL_EXTERNAL (decl
) || init
))
6836 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6839 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6840 /* Allow libjava/prims.cc define primitive classes. */
6841 if (init
!= NULL_TREE
6842 || jclass
== NULL_TREE
6843 || TREE_CODE (jclass
) != TYPE_DECL
6844 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6845 || !same_type_ignoring_top_level_qualifiers_p
6846 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6847 error ("Java object %qD not allocated with %<new%>", decl
);
6850 cleanups
= make_tree_vector ();
6851 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6857 The memory occupied by any object of static storage
6858 duration is zero-initialized at program startup before
6859 any other initialization takes place.
6861 We cannot create an appropriate initializer until after
6862 the type of DECL is finalized. If DECL_INITIAL is set,
6863 then the DECL is statically initialized, and any
6864 necessary zero-initialization has already been performed. */
6865 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6866 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6867 /*nelts=*/NULL_TREE
,
6868 /*static_storage_p=*/true);
6869 /* Remember that the initialization for this variable has
6871 DECL_INITIALIZED_P (decl
) = 1;
6872 /* This declaration is the definition of this variable,
6873 unless we are initializing a static data member within
6874 the class specifier. */
6875 if (!DECL_EXTERNAL (decl
))
6876 var_definition_p
= true;
6878 /* If the variable has an array type, lay out the type, even if
6879 there is no initializer. It is valid to index through the
6880 array, and we must get TYPE_ALIGN set correctly on the array
6882 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6885 if (TREE_STATIC (decl
)
6886 && !at_function_scope_p ()
6887 && current_function_decl
== NULL
)
6888 /* So decl is a global variable or a static member of a
6889 non local class. Record the types it uses
6890 so that we can decide later to emit debug info for them. */
6891 record_types_used_by_current_var_decl (decl
);
6893 else if (TREE_CODE (decl
) == FIELD_DECL
6894 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6895 error ("non-static data member %qD has Java class type", decl
);
6897 /* Add this declaration to the statement-tree. This needs to happen
6898 after the call to check_initializer so that the DECL_EXPR for a
6899 reference temp is added before the DECL_EXPR for the reference itself. */
6900 if (DECL_FUNCTION_SCOPE_P (decl
))
6902 /* If we're building a variable sized type, and we might be
6903 reachable other than via the top of the current binding
6904 level, then create a new BIND_EXPR so that we deallocate
6905 the object at the right time. */
6908 && !TREE_CONSTANT (DECL_SIZE (decl
))
6909 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
6912 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6913 TREE_SIDE_EFFECTS (bind
) = 1;
6915 BIND_EXPR_BODY (bind
) = push_stmt_list ();
6917 add_decl_expr (decl
);
6920 /* Let the middle end know about variables and functions -- but not
6921 static data members in uninstantiated class templates. */
6922 if (VAR_OR_FUNCTION_DECL_P (decl
))
6926 layout_var_decl (decl
);
6927 maybe_commonize_var (decl
);
6930 /* This needs to happen after the linkage is set. */
6931 determine_visibility (decl
);
6933 if (var_definition_p
&& TREE_STATIC (decl
))
6935 /* If a TREE_READONLY variable needs initialization
6936 at runtime, it is no longer readonly and we need to
6937 avoid MEM_READONLY_P being set on RTL created for it. */
6940 if (TREE_READONLY (decl
))
6941 TREE_READONLY (decl
) = 0;
6944 else if (was_readonly
)
6945 TREE_READONLY (decl
) = 1;
6947 /* Likewise if it needs destruction. */
6948 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6949 TREE_READONLY (decl
) = 0;
6952 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6954 /* Check for abstractness of the type. Notice that there is no
6955 need to strip array types here since the check for those types
6956 is already done within create_array_type_for_decl. */
6957 abstract_virtuals_error (decl
, type
);
6959 if (TREE_TYPE (decl
) == error_mark_node
)
6960 /* No initialization required. */
6962 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6966 if (init
== ridpointers
[(int)RID_DEFAULT
])
6968 /* An out-of-class default definition is defined at
6969 the point where it is explicitly defaulted. */
6970 if (DECL_DELETED_FN (decl
))
6971 maybe_explain_implicit_delete (decl
);
6972 else if (DECL_INITIAL (decl
) == error_mark_node
)
6973 synthesize_method (decl
);
6976 error ("function %q#D is initialized like a variable", decl
);
6978 /* else no initialization required. */
6980 else if (DECL_EXTERNAL (decl
)
6981 && ! (DECL_LANG_SPECIFIC (decl
)
6982 && DECL_NOT_REALLY_EXTERN (decl
)))
6985 DECL_INITIAL (decl
) = init
;
6987 /* A variable definition. */
6988 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6989 /* Initialize the local variable. */
6990 initialize_local_var (decl
, init
);
6992 /* If a variable is defined, and then a subsequent
6993 definition with external linkage is encountered, we will
6994 get here twice for the same variable. We want to avoid
6995 calling expand_static_init more than once. For variables
6996 that are not static data members, we can call
6997 expand_static_init only when we actually process the
6998 initializer. It is not legal to redeclare a static data
6999 member, so this issue does not arise in that case. */
7000 else if (var_definition_p
&& TREE_STATIC (decl
))
7001 expand_static_init (decl
, init
);
7004 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7005 reference, insert it in the statement-tree now. */
7009 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
7010 push_cleanup (decl
, t
, false);
7011 release_tree_vector (cleanups
);
7015 TREE_READONLY (decl
) = 1;
7017 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
7020 /* Returns a declaration for a VAR_DECL as if:
7022 extern "C" TYPE NAME;
7024 had been seen. Used to create compiler-generated global
7028 declare_global_var (tree name
, tree type
)
7032 push_to_top_level ();
7033 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7034 TREE_PUBLIC (decl
) = 1;
7035 DECL_EXTERNAL (decl
) = 1;
7036 DECL_ARTIFICIAL (decl
) = 1;
7037 /* If the user has explicitly declared this variable (perhaps
7038 because the code we are compiling is part of a low-level runtime
7039 library), then it is possible that our declaration will be merged
7040 with theirs by pushdecl. */
7041 decl
= pushdecl (decl
);
7042 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
7043 pop_from_top_level ();
7048 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7049 if "__cxa_atexit" is not being used) corresponding to the function
7050 to be called when the program exits. */
7053 get_atexit_fn_ptr_type (void)
7057 if (!atexit_fn_ptr_type_node
)
7060 if (flag_use_cxa_atexit
7061 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7062 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
7063 arg_type
= ptr_type_node
;
7065 /* The parameter to "atexit" is "void (*)(void)". */
7066 arg_type
= NULL_TREE
;
7068 fn_type
= build_function_type_list (void_type_node
,
7069 arg_type
, NULL_TREE
);
7070 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
7073 return atexit_fn_ptr_type_node
;
7076 /* Returns a pointer to the `atexit' function. Note that if
7077 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
7078 `__cxa_atexit' function specified in the IA64 C++ ABI. */
7081 get_atexit_node (void)
7087 bool use_aeabi_atexit
;
7092 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7094 /* The declaration for `__cxa_atexit' is:
7096 int __cxa_atexit (void (*)(void *), void *, void *)
7098 We build up the argument types and then the function type
7100 tree argtype0
, argtype1
, argtype2
;
7102 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
7103 /* First, build the pointer-to-function type for the first
7105 fn_ptr_type
= get_atexit_fn_ptr_type ();
7106 /* Then, build the rest of the argument types. */
7107 argtype2
= ptr_type_node
;
7108 if (use_aeabi_atexit
)
7110 argtype1
= fn_ptr_type
;
7111 argtype0
= ptr_type_node
;
7115 argtype1
= ptr_type_node
;
7116 argtype0
= fn_ptr_type
;
7118 /* And the final __cxa_atexit type. */
7119 fn_type
= build_function_type_list (integer_type_node
,
7120 argtype0
, argtype1
, argtype2
,
7122 if (use_aeabi_atexit
)
7123 name
= "__aeabi_atexit";
7125 name
= "__cxa_atexit";
7129 /* The declaration for `atexit' is:
7131 int atexit (void (*)());
7133 We build up the argument types and then the function type
7135 fn_ptr_type
= get_atexit_fn_ptr_type ();
7136 /* Build the final atexit type. */
7137 fn_type
= build_function_type_list (integer_type_node
,
7138 fn_ptr_type
, NULL_TREE
);
7142 /* Now, build the function declaration. */
7143 push_lang_context (lang_name_c
);
7144 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
7145 mark_used (atexit_fndecl
);
7146 pop_lang_context ();
7147 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7152 /* Like get_atexit_node, but for thread-local cleanups. */
7155 get_thread_atexit_node (void)
7157 /* The declaration for `__cxa_thread_atexit' is:
7159 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
7160 tree fn_type
= build_function_type_list (integer_type_node
,
7161 get_atexit_fn_ptr_type (),
7162 ptr_type_node
, ptr_type_node
,
7165 /* Now, build the function declaration. */
7166 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
7167 ECF_LEAF
| ECF_NOTHROW
);
7168 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7171 /* Returns the __dso_handle VAR_DECL. */
7174 get_dso_handle_node (void)
7176 if (dso_handle_node
)
7177 return dso_handle_node
;
7179 /* Declare the variable. */
7180 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
7183 #ifdef HAVE_GAS_HIDDEN
7184 if (dso_handle_node
!= error_mark_node
)
7186 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
7187 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
7191 return dso_handle_node
;
7194 /* Begin a new function with internal linkage whose job will be simply
7195 to destroy some particular variable. */
7197 static GTY(()) int start_cleanup_cnt
;
7200 start_cleanup_fn (void)
7205 bool use_cxa_atexit
= flag_use_cxa_atexit
7206 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
7208 push_to_top_level ();
7210 /* No need to mangle this. */
7211 push_lang_context (lang_name_c
);
7213 /* Build the name of the function. */
7214 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
7215 /* Build the function declaration. */
7216 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
7217 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
7218 /* It's a function with internal linkage, generated by the
7220 TREE_PUBLIC (fndecl
) = 0;
7221 DECL_ARTIFICIAL (fndecl
) = 1;
7222 /* Make the function `inline' so that it is only emitted if it is
7223 actually needed. It is unlikely that it will be inlined, since
7224 it is only called via a function pointer, but we avoid unnecessary
7225 emissions this way. */
7226 DECL_DECLARED_INLINE_P (fndecl
) = 1;
7227 DECL_INTERFACE_KNOWN (fndecl
) = 1;
7228 /* Build the parameter. */
7233 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
7234 DECL_CONTEXT (parmdecl
) = fndecl
;
7235 TREE_USED (parmdecl
) = 1;
7236 DECL_READ_P (parmdecl
) = 1;
7237 DECL_ARGUMENTS (fndecl
) = parmdecl
;
7241 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
7243 pop_lang_context ();
7245 return current_function_decl
;
7248 /* Finish the cleanup function begun by start_cleanup_fn. */
7251 end_cleanup_fn (void)
7253 expand_or_defer_fn (finish_function (0));
7255 pop_from_top_level ();
7258 /* Generate code to handle the destruction of DECL, an object with
7259 static storage duration. */
7262 register_dtor_fn (tree decl
)
7269 bool ob_parm
, dso_parm
, use_dtor
;
7270 tree arg0
, arg1
, arg2
;
7273 type
= TREE_TYPE (decl
);
7274 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7277 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7278 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7279 destructor to "__cxa_atexit"; we don't have to build a temporary
7280 function to do the cleanup. */
7281 dso_parm
= (flag_use_cxa_atexit
7282 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7283 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7284 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7289 /* Find the destructor. */
7290 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
7291 gcc_assert (idx
>= 0);
7292 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
7293 /* Make sure it is accessible. */
7294 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7295 tf_warning_or_error
);
7299 /* Call build_cleanup before we enter the anonymous function so
7300 that any access checks will be done relative to the current
7301 scope, rather than the scope of the anonymous function. */
7302 build_cleanup (decl
);
7304 /* Now start the function. */
7305 cleanup
= start_cleanup_fn ();
7307 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7308 to the original function, rather than the anonymous one. That
7309 will make the back end think that nested functions are in use,
7310 which causes confusion. */
7311 push_deferring_access_checks (dk_no_check
);
7312 fcall
= build_cleanup (decl
);
7313 pop_deferring_access_checks ();
7315 /* Create the body of the anonymous function. */
7316 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7317 finish_expr_stmt (fcall
);
7318 finish_compound_stmt (compound_stmt
);
7322 /* Call atexit with the cleanup function. */
7323 mark_used (cleanup
);
7324 cleanup
= build_address (cleanup
);
7326 if (CP_DECL_THREAD_LOCAL_P (decl
))
7327 atex_node
= get_thread_atexit_node ();
7329 atex_node
= get_atexit_node ();
7333 /* We must convert CLEANUP to the type that "__cxa_atexit"
7335 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7336 /* "__cxa_atexit" will pass the address of DECL to the
7337 cleanup function. */
7339 addr
= build_address (decl
);
7340 /* The declared type of the parameter to "__cxa_atexit" is
7341 "void *". For plain "T*", we could just let the
7342 machinery in cp_build_function_call convert it -- but if the
7343 type is "cv-qualified T *", then we need to convert it
7344 before passing it in, to avoid spurious errors. */
7345 addr
= build_nop (ptr_type_node
, addr
);
7348 /* Since the cleanup functions we build ignore the address
7349 they're given, there's no reason to pass the actual address
7350 in, and, in general, it's cheaper to pass NULL than any
7352 addr
= null_pointer_node
;
7355 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7356 tf_warning_or_error
);
7358 /* Just pass NULL to the dso handle parm if we don't actually
7359 have a DSO handle on this target. */
7360 arg2
= null_pointer_node
;
7366 if (!CP_DECL_THREAD_LOCAL_P (decl
)
7367 && targetm
.cxx
.use_aeabi_atexit ())
7383 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7384 arg0
, arg1
, arg2
, NULL_TREE
);
7387 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7388 is its initializer. Generate code to handle the construction
7389 and destruction of DECL. */
7392 expand_static_init (tree decl
, tree init
)
7394 gcc_assert (VAR_P (decl
));
7395 gcc_assert (TREE_STATIC (decl
));
7397 /* Some variables require no dynamic initialization. */
7398 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7400 /* Make sure the destructor is callable. */
7401 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7406 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7407 && !DECL_FUNCTION_SCOPE_P (decl
))
7410 error ("non-local variable %qD declared %<__thread%> "
7411 "needs dynamic initialization", decl
);
7413 error ("non-local variable %qD declared %<__thread%> "
7414 "has a non-trivial destructor", decl
);
7415 static bool informed
;
7418 inform (DECL_SOURCE_LOCATION (decl
),
7419 "C++11 %<thread_local%> allows dynamic initialization "
7426 if (DECL_FUNCTION_SCOPE_P (decl
))
7428 /* Emit code to perform this initialization but once. */
7429 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7430 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7431 tree guard
, guard_addr
;
7433 /* We don't need thread-safety code for thread-local vars. */
7434 bool thread_guard
= (flag_threadsafe_statics
7435 && !CP_DECL_THREAD_LOCAL_P (decl
));
7437 /* Emit code to perform this initialization but once. This code
7440 static <type> guard;
7441 if (!__atomic_load (guard.first_byte)) {
7442 if (__cxa_guard_acquire (&guard)) {
7445 // Do initialization.
7446 flag = true; __cxa_guard_release (&guard);
7447 // Register variable for destruction at end of program.
7449 if (!flag) __cxa_guard_abort (&guard);
7453 Note that the `flag' variable is only set to 1 *after* the
7454 initialization is complete. This ensures that an exception,
7455 thrown during the construction, will cause the variable to
7456 reinitialized when we pass through this code again, as per:
7460 If the initialization exits by throwing an exception, the
7461 initialization is not complete, so it will be tried again
7462 the next time control enters the declaration.
7464 This process should be thread-safe, too; multiple threads
7465 should not be able to initialize the variable more than
7468 /* Create the guard variable. */
7469 guard
= get_guard (decl
);
7471 /* Begin the conditional initialization. */
7472 if_stmt
= begin_if_stmt ();
7474 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
7475 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7479 tree vfntype
= NULL_TREE
;
7480 tree acquire_name
, release_name
, abort_name
;
7481 tree acquire_fn
, release_fn
, abort_fn
;
7482 guard_addr
= build_address (guard
);
7484 acquire_name
= get_identifier ("__cxa_guard_acquire");
7485 release_name
= get_identifier ("__cxa_guard_release");
7486 abort_name
= get_identifier ("__cxa_guard_abort");
7487 acquire_fn
= identifier_global_value (acquire_name
);
7488 release_fn
= identifier_global_value (release_name
);
7489 abort_fn
= identifier_global_value (abort_name
);
7491 acquire_fn
= push_library_fn
7492 (acquire_name
, build_function_type_list (integer_type_node
,
7493 TREE_TYPE (guard_addr
),
7495 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7496 if (!release_fn
|| !abort_fn
)
7497 vfntype
= build_function_type_list (void_type_node
,
7498 TREE_TYPE (guard_addr
),
7501 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7502 ECF_NOTHROW
| ECF_LEAF
);
7504 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7505 ECF_NOTHROW
| ECF_LEAF
);
7507 inner_if_stmt
= begin_if_stmt ();
7508 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7511 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7512 begin
= get_target_expr (boolean_false_node
);
7513 flag
= TARGET_EXPR_SLOT (begin
);
7515 TARGET_EXPR_CLEANUP (begin
)
7516 = build3 (COND_EXPR
, void_type_node
, flag
,
7518 build_call_n (abort_fn
, 1, guard_addr
));
7519 CLEANUP_EH_ONLY (begin
) = 1;
7521 /* Do the initialization itself. */
7522 init
= add_stmt_to_compound (begin
, init
);
7523 init
= add_stmt_to_compound
7524 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7525 init
= add_stmt_to_compound
7526 (init
, build_call_n (release_fn
, 1, guard_addr
));
7529 init
= add_stmt_to_compound (init
, set_guard (guard
));
7531 /* Use atexit to register a function for destroying this static
7533 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7535 finish_expr_stmt (init
);
7539 finish_compound_stmt (inner_then_clause
);
7540 finish_then_clause (inner_if_stmt
);
7541 finish_if_stmt (inner_if_stmt
);
7544 finish_compound_stmt (then_clause
);
7545 finish_then_clause (if_stmt
);
7546 finish_if_stmt (if_stmt
);
7548 else if (CP_DECL_THREAD_LOCAL_P (decl
))
7549 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7551 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7555 /* Make TYPE a complete type based on INITIAL_VALUE.
7556 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7557 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7558 3 if the initializer list is empty (in pedantic mode). */
7561 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7564 tree type
, elt_type
;
7566 /* Don't get confused by a CONSTRUCTOR for some other type. */
7567 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
7568 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
)
7569 && TREE_CODE (TREE_TYPE (initial_value
)) != ARRAY_TYPE
)
7574 unsigned HOST_WIDE_INT i
;
7577 /* An array of character type can be initialized from a
7578 brace-enclosed string constant.
7580 FIXME: this code is duplicated from reshape_init. Probably
7581 we should just call reshape_init here? */
7582 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7583 && TREE_CODE (initial_value
) == CONSTRUCTOR
7584 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7586 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7587 tree value
= (*v
)[0].value
;
7589 if (TREE_CODE (value
) == STRING_CST
7590 && v
->length () == 1)
7591 initial_value
= value
;
7594 /* If any of the elements are parameter packs, we can't actually
7595 complete this type now because the array size is dependent. */
7596 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7598 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7601 if (PACK_EXPANSION_P (value
))
7607 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7609 /* We can create the array before the element type is complete, which
7610 means that we didn't have these two bits set in the original type
7611 either. In completing the type, we are expected to propagate these
7612 bits. See also complete_type which does the same thing for arrays
7615 if (TYPE_DOMAIN (type
))
7617 elt_type
= TREE_TYPE (type
);
7618 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7619 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7620 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7626 /* As above, but either give an error or reject zero-size arrays, depending
7630 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7631 bool do_default
, tsubst_flags_t complain
)
7634 bool sfinae
= !(complain
& tf_error
);
7635 /* In SFINAE context we can't be lenient about zero-size arrays. */
7638 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7644 /* Not an error. */;
7645 else if (failure
== 1)
7646 error ("initializer fails to determine size of %qT", *ptype
);
7647 else if (failure
== 2)
7650 error ("array size missing in %qT", *ptype
);
7652 else if (failure
== 3)
7653 error ("zero-size array %qT", *ptype
);
7654 *ptype
= error_mark_node
;
7659 /* Return zero if something is declared to be a member of type
7660 CTYPE when in the context of CUR_TYPE. STRING is the error
7661 message to print in that case. Otherwise, quietly return 1. */
7664 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7666 if (ctype
&& ctype
!= cur_type
)
7668 if (flags
== DTOR_FLAG
)
7669 error ("destructor for alien class %qT cannot be a member", ctype
);
7671 error ("constructor for alien class %qT cannot be a member", ctype
);
7677 /* Subroutine of `grokdeclarator'. */
7679 /* Generate errors possibly applicable for a given set of specifiers.
7680 This is for ARM $7.1.2. */
7683 bad_specifiers (tree object
,
7684 enum bad_spec_place type
,
7695 error ("%qD declared as a %<virtual%> variable", object
);
7697 error ("%qD declared as an %<inline%> variable", object
);
7699 error ("%<const%> and %<volatile%> function specifiers on "
7700 "%qD invalid in variable declaration", object
);
7704 error ("%qD declared as a %<virtual%> parameter", object
);
7706 error ("%qD declared as an %<inline%> parameter", object
);
7708 error ("%<const%> and %<volatile%> function specifiers on "
7709 "%qD invalid in parameter declaration", object
);
7713 error ("%qD declared as a %<virtual%> type", object
);
7715 error ("%qD declared as an %<inline%> type", object
);
7717 error ("%<const%> and %<volatile%> function specifiers on "
7718 "%qD invalid in type declaration", object
);
7722 error ("%qD declared as a %<virtual%> field", object
);
7724 error ("%qD declared as an %<inline%> field", object
);
7726 error ("%<const%> and %<volatile%> function specifiers on "
7727 "%qD invalid in field declaration", object
);
7733 error ("%q+D declared as a friend", object
);
7735 && (TREE_CODE (object
) == TYPE_DECL
7736 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7737 && !TYPE_REFFN_P (TREE_TYPE (object
))
7738 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7739 error ("%q+D declared with an exception specification", object
);
7742 /* DECL is a member function or static data member and is presently
7743 being defined. Check that the definition is taking place in a
7747 check_class_member_definition_namespace (tree decl
)
7749 /* These checks only apply to member functions and static data
7751 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7752 /* We check for problems with specializations in pt.c in
7753 check_specialization_namespace, where we can issue better
7755 if (processing_specialization
)
7757 /* There are no restrictions on the placement of
7758 explicit instantiations. */
7759 if (processing_explicit_instantiation
)
7763 A member function definition that appears outside of the
7764 class definition shall appear in a namespace scope enclosing
7765 the class definition.
7769 The definition for a static data member shall appear in a
7770 namespace scope enclosing the member's class definition. */
7771 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7772 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7773 decl
, DECL_CONTEXT (decl
));
7776 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7777 METHOD_TYPE for a non-static member function; QUALS are the
7778 cv-qualifiers that apply to the function. */
7781 build_this_parm (tree type
, cp_cv_quals quals
)
7786 cp_cv_quals this_quals
;
7788 if (CLASS_TYPE_P (type
))
7791 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7792 this_type
= build_pointer_type (this_type
);
7795 this_type
= type_of_this_parm (type
);
7796 /* The `this' parameter is implicitly `const'; it cannot be
7798 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7799 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7800 parm
= build_artificial_parm (this_identifier
, qual_type
);
7801 cp_apply_type_quals_to_decl (this_quals
, parm
);
7805 /* DECL is a static member function. Complain if it was declared
7806 with function-cv-quals. */
7809 check_static_quals (tree decl
, cp_cv_quals quals
)
7811 if (quals
!= TYPE_UNQUALIFIED
)
7812 error ("static member function %q#D declared with type qualifiers",
7816 // Check that FN takes no arguments and returns bool.
7818 check_concept_fn (tree fn
)
7820 // A constraint is nullary.
7821 if (DECL_ARGUMENTS (fn
))
7822 error ("concept %q#D declared with function parameters", fn
);
7824 // The declared return type of the concept shall be bool, and
7825 // it shall not be deduced from it definition.
7826 tree type
= TREE_TYPE (TREE_TYPE (fn
));
7828 error ("concept %q#D declared with a deduced return type", fn
);
7829 else if (type
!= boolean_type_node
)
7830 error ("concept %q#D with non-%<bool%> return type %qT", fn
, type
);
7833 /* Helper function. Replace the temporary this parameter injected
7834 during cp_finish_omp_declare_simd with the real this parameter. */
7837 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7839 tree this_parm
= (tree
) data
;
7840 if (TREE_CODE (*tp
) == PARM_DECL
7841 && DECL_NAME (*tp
) == this_identifier
7842 && *tp
!= this_parm
)
7844 else if (TYPE_P (*tp
))
7849 /* CTYPE is class type, or null if non-class.
7850 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7852 DECLARATOR is the function's name.
7853 PARMS is a chain of PARM_DECLs for the function.
7854 VIRTUALP is truthvalue of whether the function is virtual or not.
7855 FLAGS are to be passed through to `grokclassfn'.
7856 QUALS are qualifiers indicating whether the function is `const'
7858 RAISES is a list of exceptions that this function can raise.
7859 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7860 not look, and -1 if we should not call `grokclassfn' at all.
7862 SFK is the kind of special function (if any) for the new function.
7864 Returns `NULL_TREE' if something goes wrong, after issuing
7865 applicable error messages. */
7868 grokfndecl (tree ctype
,
7872 tree orig_declarator
,
7875 enum overload_flags flags
,
7877 cp_ref_qualifier rqual
,
7884 special_function_kind sfk
,
7889 location_t location
)
7892 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7895 // Was the concept specifier present?
7896 bool concept_p
= inlinep
& 4;
7898 // Concept declarations must have a corresponding definition.
7899 if (concept_p
&& !funcdef_flag
)
7901 error ("concept %qD has no definition", declarator
);
7906 type
= build_ref_qualified_type (type
, rqual
);
7908 type
= build_exception_variant (type
, raises
);
7910 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7912 /* Set the constraints on the declaration. */
7915 tree tmpl_reqs
= NULL_TREE
;
7916 if (processing_template_decl
> template_class_depth (ctype
))
7917 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
7919 /* Adjust the required expression into a constraint. */
7921 decl_reqs
= make_predicate_constraint (decl_reqs
);
7923 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
7924 set_constraints (decl
, ci
);
7927 /* If we have an explicit location, use it, otherwise use whatever
7928 build_lang_decl used (probably input_location). */
7929 if (location
!= UNKNOWN_LOCATION
)
7930 DECL_SOURCE_LOCATION (decl
) = location
;
7932 if (TREE_CODE (type
) == METHOD_TYPE
)
7935 parm
= build_this_parm (type
, quals
);
7936 DECL_CHAIN (parm
) = parms
;
7939 /* Allocate space to hold the vptr bit if needed. */
7940 SET_DECL_ALIGN (decl
, MINIMUM_METHOD_BOUNDARY
);
7942 DECL_ARGUMENTS (decl
) = parms
;
7943 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7944 DECL_CONTEXT (t
) = decl
;
7945 /* Propagate volatile out from type to decl. */
7946 if (TYPE_VOLATILE (type
))
7947 TREE_THIS_VOLATILE (decl
) = 1;
7949 /* Setup decl according to sfk. */
7952 case sfk_constructor
:
7953 case sfk_copy_constructor
:
7954 case sfk_move_constructor
:
7955 DECL_CONSTRUCTOR_P (decl
) = 1;
7957 case sfk_destructor
:
7958 DECL_DESTRUCTOR_P (decl
) = 1;
7965 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7969 ("defining explicit specialization %qD in friend declaration",
7973 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7974 tree args
= TREE_OPERAND (orig_declarator
, 1);
7976 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7978 /* Something like `template <class T> friend void f<T>()'. */
7979 error ("invalid use of template-id %qD in declaration "
7980 "of primary template",
7986 /* A friend declaration of the form friend void f<>(). Record
7987 the information in the TEMPLATE_ID_EXPR. */
7988 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7990 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7991 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7993 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7994 if (TREE_PURPOSE (t
)
7995 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7997 error ("default arguments are not allowed in declaration "
7998 "of friend template specialization %qD",
8005 error ("%<inline%> is not allowed in declaration of friend "
8006 "template specialization %qD",
8013 /* If this decl has namespace scope, set that up. */
8015 set_decl_namespace (decl
, in_namespace
, friendp
);
8017 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
8019 /* `main' and builtins have implicit 'C' linkage. */
8020 if ((MAIN_NAME_P (declarator
)
8021 || (IDENTIFIER_LENGTH (declarator
) > 10
8022 && IDENTIFIER_POINTER (declarator
)[0] == '_'
8023 && IDENTIFIER_POINTER (declarator
)[1] == '_'
8024 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
8025 || (targetcm
.cxx_implicit_extern_c
8026 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
8027 && current_lang_name
== lang_name_cplusplus
8028 && ctype
== NULL_TREE
8029 && DECL_FILE_SCOPE_P (decl
))
8030 SET_DECL_LANGUAGE (decl
, lang_c
);
8032 /* Should probably propagate const out from type to decl I bet (mrs). */
8035 DECL_STATIC_FUNCTION_P (decl
) = 1;
8036 DECL_CONTEXT (decl
) = ctype
;
8040 DECL_DELETED_FN (decl
) = 1;
8044 DECL_CONTEXT (decl
) = ctype
;
8046 check_class_member_definition_namespace (decl
);
8049 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8051 if (PROCESSING_REAL_TEMPLATE_DECL_P())
8052 error ("cannot declare %<::main%> to be a template");
8054 error ("cannot declare %<::main%> to be inline");
8056 error ("cannot declare %<::main%> to be constexpr");
8058 error ("cannot declare %<::main%> to be static");
8063 /* Members of anonymous types and local classes have no linkage; make
8064 them internal. If a typedef is made later, this will be changed. */
8065 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
8066 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
8069 if (publicp
&& cxx_dialect
== cxx98
)
8071 /* [basic.link]: A name with no linkage (notably, the name of a class
8072 or enumeration declared in a local scope) shall not be used to
8073 declare an entity with linkage.
8075 DR 757 relaxes this restriction for C++0x. */
8076 no_linkage_error (decl
);
8079 TREE_PUBLIC (decl
) = publicp
;
8082 DECL_INTERFACE_KNOWN (decl
) = 1;
8083 DECL_NOT_REALLY_EXTERN (decl
) = 1;
8086 /* If the declaration was declared inline, mark it as such. */
8089 DECL_DECLARED_INLINE_P (decl
) = 1;
8091 DECL_COMDAT (decl
) = 1;
8094 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
8096 // If the concept declaration specifier was found, check
8097 // that the declaration satisfies the necessary requirements.
8100 DECL_DECLARED_CONCEPT_P (decl
) = true;
8101 check_concept_fn (decl
);
8104 DECL_EXTERNAL (decl
) = 1;
8105 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8108 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
8115 ? G_("static member function %qD cannot have cv-qualifier")
8116 : G_("non-member function %qD cannot have cv-qualifier"),
8118 quals
= TYPE_UNQUALIFIED
;
8124 ? G_("static member function %qD cannot have ref-qualifier")
8125 : G_("non-member function %qD cannot have ref-qualifier"),
8127 rqual
= REF_QUAL_NONE
;
8131 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
8132 && !grok_op_properties (decl
, /*complain=*/true))
8134 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
8136 bool long_long_unsigned_p
;
8138 const char *suffix
= NULL
;
8139 /* [over.literal]/6: Literal operators shall not have C linkage. */
8140 if (DECL_LANGUAGE (decl
) == lang_c
)
8142 error ("literal operator with C linkage");
8146 if (DECL_NAMESPACE_SCOPE_P (decl
))
8148 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
8151 error ("%qD has invalid argument list", decl
);
8155 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
8156 if (long_long_unsigned_p
)
8158 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
8159 warning (0, "integer suffix %<%s%>"
8160 " shadowed by implementation", suffix
);
8162 else if (long_double_p
)
8164 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
8165 warning (0, "floating point suffix %<%s%>"
8166 " shadowed by implementation", suffix
);
8171 error ("%qD must be a non-member function", decl
);
8177 /* Make the init_value nonzero so pushdecl knows this is not
8178 tentative. error_mark_node is replaced later with the BLOCK. */
8179 DECL_INITIAL (decl
) = error_mark_node
;
8181 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8182 TREE_NOTHROW (decl
) = 1;
8184 if (flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
8186 /* Adjust "omp declare simd" attributes. */
8187 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
8191 for (attr
= ods
; attr
;
8192 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
8194 if (TREE_CODE (type
) == METHOD_TYPE
)
8195 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
8196 DECL_ARGUMENTS (decl
), NULL
);
8197 if (TREE_VALUE (attr
) != NULL_TREE
)
8199 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
8200 cl
= c_omp_declare_simd_clauses_to_numbers
8201 (DECL_ARGUMENTS (decl
), cl
);
8203 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
8205 TREE_VALUE (attr
) = NULL_TREE
;
8211 /* Caller will do the rest of this. */
8215 if (ctype
!= NULL_TREE
)
8216 grokclassfn (ctype
, decl
, flags
);
8219 if (cxx_dialect
>= cxx11
8220 && DECL_DESTRUCTOR_P (decl
)
8221 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
8222 && !processing_template_decl
)
8223 deduce_noexcept_on_destructor (decl
);
8225 decl
= check_explicit_specialization (orig_declarator
, decl
,
8228 4 * (friendp
!= 0) +
8230 if (decl
== error_mark_node
)
8233 if (DECL_STATIC_FUNCTION_P (decl
))
8234 check_static_quals (decl
, quals
);
8238 cplus_decl_attributes (&decl
, *attrlist
, 0);
8239 *attrlist
= NULL_TREE
;
8242 /* Check main's type after attributes have been applied. */
8243 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8245 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8248 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8250 error ("%<::main%> must return %<int%>");
8251 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
8252 TREE_TYPE (decl
) = newtype
;
8255 check_main_parameter_types (decl
);
8258 if (ctype
!= NULL_TREE
8259 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8262 tree old_decl
= check_classfn (ctype
, decl
,
8263 (processing_template_decl
8264 > template_class_depth (ctype
))
8265 ? current_template_parms
8268 if (old_decl
== error_mark_node
)
8276 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8277 /* Because grokfndecl is always supposed to return a
8278 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8279 here. We depend on our callers to figure out that its
8280 really a template that's being returned. */
8281 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8283 if (DECL_STATIC_FUNCTION_P (old_decl
)
8284 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8286 /* Remove the `this' parm added by grokclassfn. */
8287 revert_static_member_fn (decl
);
8288 check_static_quals (decl
, quals
);
8290 if (DECL_ARTIFICIAL (old_decl
))
8292 error ("definition of implicitly-declared %qD", old_decl
);
8295 else if (DECL_DEFAULTED_FN (old_decl
))
8297 error ("definition of explicitly-defaulted %q+D", decl
);
8298 error ("%q+#D explicitly defaulted here", old_decl
);
8302 /* Since we've smashed OLD_DECL to its
8303 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8304 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8305 decl
= DECL_TEMPLATE_RESULT (decl
);
8307 /* Attempt to merge the declarations. This can fail, in
8308 the case of some invalid specialization declarations. */
8309 pushed_scope
= push_scope (ctype
);
8310 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8312 pop_scope (pushed_scope
);
8315 error ("no %q#D member function declared in class %qT",
8319 if (ok
== error_mark_node
)
8325 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8328 if (ctype
== NULL_TREE
|| check
)
8332 DECL_VIRTUAL_P (decl
) = 1;
8337 /* decl is a FUNCTION_DECL.
8338 specifiers are the parsed virt-specifiers.
8340 Set flags to reflect the virt-specifiers.
8345 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8347 if (decl
== NULL_TREE
)
8349 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8350 DECL_OVERRIDE_P (decl
) = 1;
8351 if (specifiers
& VIRT_SPEC_FINAL
)
8352 DECL_FINAL_P (decl
) = 1;
8356 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8357 the linkage that DECL will receive in the object file. */
8360 set_linkage_for_static_data_member (tree decl
)
8362 /* A static data member always has static storage duration and
8363 external linkage. Note that static data members are forbidden in
8364 local classes -- the only situation in which a class has
8365 non-external linkage. */
8366 TREE_PUBLIC (decl
) = 1;
8367 TREE_STATIC (decl
) = 1;
8368 /* For non-template classes, static data members are always put
8369 out in exactly those files where they are defined, just as
8370 with ordinary namespace-scope variables. */
8371 if (!processing_template_decl
)
8372 DECL_INTERFACE_KNOWN (decl
) = 1;
8375 /* Create a VAR_DECL named NAME with the indicated TYPE.
8377 If SCOPE is non-NULL, it is the class type or namespace containing
8378 the variable. If SCOPE is NULL, the variable should is created in
8379 the innermost enclosing scope. */
8382 grokvardecl (tree type
,
8384 tree orig_declarator
,
8385 const cp_decl_specifier_seq
*declspecs
,
8392 tree explicit_scope
;
8394 gcc_assert (!name
|| identifier_p (name
));
8396 bool constp
= flags
&1;
8397 bool conceptp
= flags
&2;
8399 /* Compute the scope in which to place the variable, but remember
8400 whether or not that scope was explicitly specified by the user. */
8401 explicit_scope
= scope
;
8404 /* An explicit "extern" specifier indicates a namespace-scope
8406 if (declspecs
->storage_class
== sc_extern
)
8407 scope
= current_decl_namespace ();
8408 else if (!at_function_scope_p ())
8409 scope
= current_scope ();
8413 && (/* If the variable is a namespace-scope variable declared in a
8414 template, we need DECL_LANG_SPECIFIC. */
8415 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8416 /* Similarly for namespace-scope variables with language linkage
8418 || (TREE_CODE (scope
) == NAMESPACE_DECL
8419 && current_lang_name
!= lang_name_cplusplus
)
8420 /* Similarly for static data members. */
8422 /* Similarly for explicit specializations. */
8424 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8425 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8427 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8429 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8430 set_decl_namespace (decl
, explicit_scope
, 0);
8432 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
8434 if (declspecs
->storage_class
== sc_extern
)
8436 DECL_THIS_EXTERN (decl
) = 1;
8437 DECL_EXTERNAL (decl
) = !initialized
;
8440 if (DECL_CLASS_SCOPE_P (decl
))
8442 set_linkage_for_static_data_member (decl
);
8443 /* This function is only called with out-of-class definitions. */
8444 DECL_EXTERNAL (decl
) = 0;
8445 check_class_member_definition_namespace (decl
);
8447 /* At top level, either `static' or no s.c. makes a definition
8448 (perhaps tentative), and absence of `static' makes it public. */
8449 else if (toplevel_bindings_p ())
8451 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
8452 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8453 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8455 /* Not at top level, only `static' makes a static definition. */
8458 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
8459 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8462 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
8464 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
8466 CP_DECL_THREAD_LOCAL_P (decl
) = true;
8467 if (!processing_template_decl
)
8468 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
8470 if (declspecs
->gnu_thread_keyword_p
)
8471 SET_DECL_GNU_TLS_P (decl
);
8474 /* If the type of the decl has no linkage, make sure that we'll
8475 notice that in mark_used. */
8476 if (cxx_dialect
> cxx98
8477 && decl_linkage (decl
) != lk_none
8478 && DECL_LANG_SPECIFIC (decl
) == NULL
8479 && !DECL_EXTERN_C_P (decl
)
8480 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
8481 retrofit_lang_decl (decl
);
8483 if (TREE_PUBLIC (decl
))
8485 /* [basic.link]: A name with no linkage (notably, the name of a class
8486 or enumeration declared in a local scope) shall not be used to
8487 declare an entity with linkage.
8489 DR 757 relaxes this restriction for C++0x. */
8490 if (cxx_dialect
< cxx11
)
8491 no_linkage_error (decl
);
8494 DECL_INTERFACE_KNOWN (decl
) = 1;
8496 if (DECL_NAME (decl
)
8497 && MAIN_NAME_P (DECL_NAME (decl
))
8498 && scope
== global_namespace
)
8499 error ("cannot declare %<::main%> to be a global variable");
8501 /* Check that the variable can be safely declared as a concept.
8502 Note that this also forbids explicit specializations. */
8505 if (!processing_template_decl
)
8507 error ("a non-template variable cannot be %<concept%>");
8511 DECL_DECLARED_CONCEPT_P (decl
) = true;
8512 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
8513 error_at (declspecs
->locations
[ds_type_spec
],
8514 "concept must have type %<bool%>");
8516 else if (flag_concepts
8517 && processing_template_decl
> template_class_depth (scope
))
8519 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8520 tree ci
= build_constraints (reqs
, NULL_TREE
);
8521 set_constraints (decl
, ci
);
8524 // Handle explicit specializations and instantiations of variable templates.
8525 if (orig_declarator
)
8526 decl
= check_explicit_specialization (orig_declarator
, decl
,
8527 template_count
, conceptp
* 8);
8529 return decl
!= error_mark_node
? decl
: NULL_TREE
;
8532 /* Create and return a canonical pointer to member function type, for
8533 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8536 build_ptrmemfunc_type (tree type
)
8541 if (type
== error_mark_node
)
8544 /* Make sure that we always have the unqualified pointer-to-member
8546 if (cp_cv_quals quals
= cp_type_quals (type
))
8548 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8549 return cp_build_qualified_type (unqual
, quals
);
8552 /* If a canonical type already exists for this type, use it. We use
8553 this method instead of type_hash_canon, because it only does a
8554 simple equality check on the list of field members. */
8556 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8559 t
= make_node (RECORD_TYPE
);
8561 /* Let the front end know this is a pointer to member function. */
8562 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8564 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8567 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8569 DECL_CHAIN (field
) = fields
;
8572 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8574 /* Zap out the name so that the back end will give us the debugging
8575 information for this anonymous RECORD_TYPE. */
8576 TYPE_NAME (t
) = NULL_TREE
;
8578 /* Cache this pointer-to-member type so that we can find it again
8580 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8582 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8583 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8584 else if (TYPE_CANONICAL (type
) != type
)
8585 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8590 /* Create and return a pointer to data member type. */
8593 build_ptrmem_type (tree class_type
, tree member_type
)
8595 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8597 cp_cv_quals quals
= type_memfn_quals (member_type
);
8598 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8599 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8600 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8604 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8605 return build_offset_type (class_type
, member_type
);
8609 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8610 Check to see that the definition is valid. Issue appropriate error
8611 messages. Return 1 if the definition is particularly bad, or 0
8615 check_static_variable_definition (tree decl
, tree type
)
8617 /* Avoid redundant diagnostics on out-of-class definitions. */
8618 if (!current_class_type
|| !TYPE_BEING_DEFINED (current_class_type
))
8620 /* Can't check yet if we don't know the type. */
8621 if (dependent_type_p (type
))
8623 /* If DECL is declared constexpr, we'll do the appropriate checks
8624 in check_initializer. */
8625 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8627 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8629 if (!COMPLETE_TYPE_P (type
))
8630 error_at (DECL_SOURCE_LOCATION (decl
),
8631 "in-class initialization of static data member %q#D of "
8632 "incomplete type", decl
);
8633 else if (literal_type_p (type
))
8634 permerror (DECL_SOURCE_LOCATION (decl
),
8635 "%<constexpr%> needed for in-class initialization of "
8636 "static data member %q#D of non-integral type", decl
);
8638 error_at (DECL_SOURCE_LOCATION (decl
),
8639 "in-class initialization of static data member %q#D of "
8640 "non-literal type", decl
);
8644 /* Motion 10 at San Diego: If a static const integral data member is
8645 initialized with an integral constant expression, the initializer
8646 may appear either in the declaration (within the class), or in
8647 the definition, but not both. If it appears in the class, the
8648 member is a member constant. The file-scope definition is always
8650 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8652 error_at (DECL_SOURCE_LOCATION (decl
),
8653 "invalid in-class initialization of static data member "
8654 "of non-integral type %qT",
8658 else if (!CP_TYPE_CONST_P (type
))
8659 error_at (DECL_SOURCE_LOCATION (decl
),
8660 "ISO C++ forbids in-class initialization of non-const "
8661 "static member %qD",
8663 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8664 pedwarn (DECL_SOURCE_LOCATION (decl
), OPT_Wpedantic
,
8665 "ISO C++ forbids initialization of member constant "
8666 "%qD of non-integral type %qT", decl
, type
);
8671 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8672 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8673 expressions out into temporary variables so that walk_tree doesn't
8674 step into them (c++/15764). */
8677 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8679 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
8680 tree expr
= *expr_p
;
8681 if (TREE_CODE (expr
) == SAVE_EXPR
)
8683 tree op
= TREE_OPERAND (expr
, 0);
8684 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8685 if (TREE_SIDE_EFFECTS (op
))
8686 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8689 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8694 /* Entry point for the above. */
8697 stabilize_vla_size (tree size
)
8699 hash_set
<tree
> pset
;
8700 /* Break out any function calls into temporary variables. */
8701 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
8704 /* Reduce a SIZEOF_EXPR to its value. */
8707 fold_sizeof_expr (tree t
)
8710 if (SIZEOF_EXPR_TYPE_P (t
))
8711 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
8712 SIZEOF_EXPR
, false);
8713 else if (TYPE_P (TREE_OPERAND (t
, 0)))
8714 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8717 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8719 if (r
== error_mark_node
)
8724 /* Given the SIZE (i.e., number of elements) in an array, compute
8725 an appropriate index type for the array. If non-NULL, NAME is
8726 the name of the entity being declared. */
8729 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8734 if (error_operand_p (size
))
8735 return error_mark_node
;
8737 if (!type_dependent_expression_p (size
))
8739 tree type
= TREE_TYPE (size
);
8741 mark_rvalue_use (size
);
8743 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8744 && TREE_SIDE_EFFECTS (size
))
8745 /* In C++98, we mark a non-constant array bound with a magic
8746 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8749 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
8751 if (CLASS_TYPE_P (type
)
8752 && CLASSTYPE_LITERAL_P (type
))
8754 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8757 if (!(complain
& tf_error
))
8758 return error_mark_node
;
8760 error ("size of array %qD has non-integral type %qT",
8763 error ("size of array has non-integral type %qT", type
);
8764 size
= integer_one_node
;
8766 if (size
== error_mark_node
)
8767 return error_mark_node
;
8768 type
= TREE_TYPE (size
);
8771 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8772 size
= maybe_constant_value (size
);
8774 if (!TREE_CONSTANT (size
))
8778 if (error_operand_p (size
))
8779 return error_mark_node
;
8781 /* The array bound must be an integer type. */
8782 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8784 if (!(complain
& tf_error
))
8785 return error_mark_node
;
8787 error ("size of array %qD has non-integral type %qT", name
, type
);
8789 error ("size of array has non-integral type %qT", type
);
8790 size
= integer_one_node
;
8791 type
= TREE_TYPE (size
);
8795 /* A type is dependent if it is...an array type constructed from any
8796 dependent type or whose size is specified by a constant expression
8797 that is value-dependent. */
8798 /* We can only call value_dependent_expression_p on integral constant
8799 expressions; treat non-constant expressions as dependent, too. */
8800 if (processing_template_decl
8801 && (type_dependent_expression_p (size
)
8802 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8804 /* We cannot do any checking for a SIZE that isn't known to be
8805 constant. Just build the index type and mark that it requires
8806 structural equality checks. */
8807 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8808 size
, size_one_node
));
8809 TYPE_DEPENDENT_P (itype
) = 1;
8810 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8811 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8815 if (TREE_CODE (size
) != INTEGER_CST
)
8817 tree folded
= cp_fully_fold (size
);
8818 if (TREE_CODE (folded
) == INTEGER_CST
)
8819 pedwarn (location_of (size
), OPT_Wpedantic
,
8820 "size of array is not an integral constant-expression");
8821 /* Use the folded result for VLAs, too; it will have resolved
8826 /* Normally, the array-bound will be a constant. */
8827 if (TREE_CODE (size
) == INTEGER_CST
)
8829 /* Check to see if the array bound overflowed. Make that an
8830 error, no matter how generous we're being. */
8831 constant_expression_error (size
);
8833 /* An array must have a positive number of elements. */
8834 if (tree_int_cst_lt (size
, integer_zero_node
))
8836 if (!(complain
& tf_error
))
8837 return error_mark_node
;
8839 error ("size of array %qD is negative", name
);
8841 error ("size of array is negative");
8842 size
= integer_one_node
;
8844 /* As an extension we allow zero-sized arrays. */
8845 else if (integer_zerop (size
))
8847 if (!(complain
& tf_error
))
8848 /* We must fail if performing argument deduction (as
8849 indicated by the state of complain), so that
8850 another substitution can be found. */
8851 return error_mark_node
;
8852 else if (in_system_header_at (input_location
))
8853 /* Allow them in system headers because glibc uses them. */;
8855 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8857 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8860 else if (TREE_CONSTANT (size
)
8861 /* We don't allow VLAs at non-function scopes, or during
8862 tentative template substitution. */
8863 || !at_function_scope_p ()
8864 || !(complain
& tf_error
))
8866 if (!(complain
& tf_error
))
8867 return error_mark_node
;
8868 /* `(int) &fn' is not a valid array bound. */
8870 error ("size of array %qD is not an integral constant-expression",
8873 error ("size of array is not an integral constant-expression");
8874 size
= integer_one_node
;
8876 else if (pedantic
&& warn_vla
!= 0)
8879 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8881 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8883 else if (warn_vla
> 0)
8887 "variable length array %qD is used", name
);
8890 "variable length array is used");
8893 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8894 /* A variable sized array. */
8895 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8898 HOST_WIDE_INT saved_processing_template_decl
;
8900 /* Compute the index of the largest element in the array. It is
8901 one less than the number of elements in the array. We save
8902 and restore PROCESSING_TEMPLATE_DECL so that computations in
8903 cp_build_binary_op will be appropriately folded. */
8904 saved_processing_template_decl
= processing_template_decl
;
8905 processing_template_decl
= 0;
8906 itype
= cp_build_binary_op (input_location
,
8908 cp_convert (ssizetype
, size
, complain
),
8909 cp_convert (ssizetype
, integer_one_node
,
8912 itype
= maybe_constant_value (itype
);
8913 processing_template_decl
= saved_processing_template_decl
;
8915 if (!TREE_CONSTANT (itype
))
8917 /* A variable sized array. */
8918 itype
= variable_size (itype
);
8920 stabilize_vla_size (itype
);
8922 if (flag_sanitize
& SANITIZE_VLA
8923 && do_ubsan_in_current_function ())
8925 /* We have to add 1 -- in the ubsan routine we generate
8926 LE_EXPR rather than LT_EXPR. */
8927 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8928 build_one_cst (TREE_TYPE (itype
)));
8929 t
= ubsan_instrument_vla (input_location
, t
);
8930 finish_expr_stmt (t
);
8933 /* Make sure that there was no overflow when creating to a signed
8934 index type. (For example, on a 32-bit machine, an array with
8935 size 2^32 - 1 is too big.) */
8936 else if (TREE_CODE (itype
) == INTEGER_CST
8937 && TREE_OVERFLOW (itype
))
8939 if (!(complain
& tf_error
))
8940 return error_mark_node
;
8941 error ("overflow in array dimension");
8942 TREE_OVERFLOW (itype
) = 0;
8946 /* Create and return the appropriate index type. */
8947 itype
= build_index_type (itype
);
8949 /* If the index type were dependent, we would have returned early, so
8950 remember that it isn't. */
8951 TYPE_DEPENDENT_P (itype
) = 0;
8952 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8956 /* Returns the scope (if any) in which the entity declared by
8957 DECLARATOR will be located. If the entity was declared with an
8958 unqualified name, NULL_TREE is returned. */
8961 get_scope_of_declarator (const cp_declarator
*declarator
)
8963 while (declarator
&& declarator
->kind
!= cdk_id
)
8964 declarator
= declarator
->declarator
;
8966 /* If the declarator-id is a SCOPE_REF, the scope in which the
8967 declaration occurs is the first operand. */
8969 && declarator
->u
.id
.qualifying_scope
)
8970 return declarator
->u
.id
.qualifying_scope
;
8972 /* Otherwise, the declarator is not a qualified name; the entity will
8973 be declared in the current scope. */
8977 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8978 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8982 create_array_type_for_decl (tree name
, tree type
, tree size
)
8984 tree itype
= NULL_TREE
;
8986 /* If things have already gone awry, bail now. */
8987 if (type
== error_mark_node
|| size
== error_mark_node
)
8988 return error_mark_node
;
8990 /* 8.3.4/1: If the type of the identifier of D contains the auto
8991 type-specifier, the program is ill-formed. */
8992 if (type_uses_auto (type
))
8994 error ("%qD declared as array of %qT", name
, type
);
8995 return error_mark_node
;
8998 /* If there are some types which cannot be array elements,
8999 issue an error-message and return. */
9000 switch (TREE_CODE (type
))
9004 error ("declaration of %qD as array of void", name
);
9006 error ("creating array of void");
9007 return error_mark_node
;
9011 error ("declaration of %qD as array of functions", name
);
9013 error ("creating array of functions");
9014 return error_mark_node
;
9016 case REFERENCE_TYPE
:
9018 error ("declaration of %qD as array of references", name
);
9020 error ("creating array of references");
9021 return error_mark_node
;
9025 error ("declaration of %qD as array of function members", name
);
9027 error ("creating array of function members");
9028 return error_mark_node
;
9036 The constant expressions that specify the bounds of the arrays
9037 can be omitted only for the first member of the sequence. */
9038 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
9041 error ("declaration of %qD as multidimensional array must "
9042 "have bounds for all dimensions except the first",
9045 error ("multidimensional array must have bounds for all "
9046 "dimensions except the first");
9048 return error_mark_node
;
9051 /* Figure out the index type for the array. */
9053 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
9056 T is called the array element type; this type shall not be [...] an
9057 abstract class type. */
9058 abstract_virtuals_error (name
, type
);
9060 return build_cplus_array_type (type
, itype
);
9063 /* Returns the smallest location != UNKNOWN_LOCATION among the
9064 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
9065 and LOCATIONS[ds_restrict]. */
9068 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
9070 location_t loc
= UNKNOWN_LOCATION
;
9072 if (type_quals
& TYPE_QUAL_CONST
)
9073 loc
= locations
[ds_const
];
9075 if ((type_quals
& TYPE_QUAL_VOLATILE
)
9076 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_volatile
] < loc
))
9077 loc
= locations
[ds_volatile
];
9079 if ((type_quals
& TYPE_QUAL_RESTRICT
)
9080 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_restrict
] < loc
))
9081 loc
= locations
[ds_restrict
];
9086 /* Check that it's OK to declare a function with the indicated TYPE
9087 and TYPE_QUALS. SFK indicates the kind of special function (if any)
9088 that this function is. OPTYPE is the type given in a conversion
9089 operator declaration, or the class type for a constructor/destructor.
9090 Returns the actual return type of the function; that may be different
9091 than TYPE if an error occurs, or for certain special functions. */
9094 check_special_function_return_type (special_function_kind sfk
,
9098 const location_t
* locations
)
9102 case sfk_constructor
:
9104 error ("return type specification for constructor invalid");
9105 else if (type_quals
!= TYPE_UNQUALIFIED
)
9106 error_at (smallest_type_quals_location (type_quals
, locations
),
9107 "qualifiers are not allowed on constructor declaration");
9109 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9110 type
= build_pointer_type (optype
);
9112 type
= void_type_node
;
9115 case sfk_destructor
:
9117 error ("return type specification for destructor invalid");
9118 else if (type_quals
!= TYPE_UNQUALIFIED
)
9119 error_at (smallest_type_quals_location (type_quals
, locations
),
9120 "qualifiers are not allowed on destructor declaration");
9122 /* We can't use the proper return type here because we run into
9123 problems with ambiguous bases and covariant returns.
9124 Java classes are left unchanged because (void *) isn't a valid
9125 Java type, and we don't want to change the Java ABI. */
9126 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9127 type
= build_pointer_type (void_type_node
);
9129 type
= void_type_node
;
9132 case sfk_conversion
:
9134 error ("return type specified for %<operator %T%>", optype
);
9135 else if (type_quals
!= TYPE_UNQUALIFIED
)
9136 error_at (smallest_type_quals_location (type_quals
, locations
),
9137 "qualifiers are not allowed on declaration of "
9138 "%<operator %T%>", optype
);
9150 /* A variable or data member (whose unqualified name is IDENTIFIER)
9151 has been declared with the indicated TYPE. If the TYPE is not
9152 acceptable, issue an error message and return a type to use for
9153 error-recovery purposes. */
9156 check_var_type (tree identifier
, tree type
)
9158 if (VOID_TYPE_P (type
))
9161 error ("unnamed variable or field declared void");
9162 else if (identifier_p (identifier
))
9164 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
9165 error ("variable or field %qE declared void", identifier
);
9168 error ("variable or field declared void");
9169 type
= error_mark_node
;
9175 /* Given declspecs and a declarator (abstract or otherwise), determine
9176 the name and type of the object declared and construct a DECL node
9179 DECLSPECS points to the representation of declaration-specifier
9180 sequence that precedes declarator.
9182 DECL_CONTEXT says which syntactic context this declaration is in:
9183 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9184 FUNCDEF for a function definition. Like NORMAL but a few different
9185 error messages in each case. Return value may be zero meaning
9186 this definition is too screwy to try to parse.
9187 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9188 handle member functions (which have FIELD context).
9189 Return value may be zero meaning this definition is too screwy to
9191 PARM for a parameter declaration (either within a function prototype
9192 or before a function body). Make a PARM_DECL, or return void_type_node.
9193 TPARM for a template parameter declaration.
9194 CATCHPARM for a parameter declaration before a catch clause.
9195 TYPENAME if for a typename (in a cast or sizeof).
9196 Don't make a DECL node; just return the ..._TYPE node.
9197 FIELD for a struct or union field; make a FIELD_DECL.
9198 BITFIELD for a field with specified width.
9200 INITIALIZED is as for start_decl.
9202 ATTRLIST is a pointer to the list of attributes, which may be NULL
9203 if there are none; *ATTRLIST may be modified if attributes from inside
9204 the declarator should be applied to the declaration.
9206 When this function is called, scoping variables (such as
9207 CURRENT_CLASS_TYPE) should reflect the scope in which the
9208 declaration occurs, not the scope in which the new declaration will
9209 be placed. For example, on:
9213 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9216 Returns a DECL (if a declarator is present), a TYPE (if there is no
9217 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
9221 grokdeclarator (const cp_declarator
*declarator
,
9222 cp_decl_specifier_seq
*declspecs
,
9223 enum decl_context decl_context
,
9227 tree type
= NULL_TREE
;
9229 int explicit_intN
= 0;
9230 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9231 int explicit_int
= 0;
9232 int explicit_char
= 0;
9233 int defaulted_int
= 0;
9235 tree typedef_decl
= NULL_TREE
;
9236 const char *name
= NULL
;
9237 tree typedef_type
= NULL_TREE
;
9238 /* True if this declarator is a function definition. */
9239 bool funcdef_flag
= false;
9240 cp_declarator_kind innermost_code
= cdk_error
;
9243 /* See the code below that used this. */
9244 tree decl_attr
= NULL_TREE
;
9247 /* Keep track of what sort of function is being processed
9248 so that we can warn about default return values, or explicit
9249 return values which do not match prescribed defaults. */
9250 special_function_kind sfk
= sfk_none
;
9252 tree dname
= NULL_TREE
;
9253 tree ctor_return_type
= NULL_TREE
;
9254 enum overload_flags flags
= NO_SPECIAL
;
9255 /* cv-qualifiers that apply to the declarator, for a declaration of
9256 a member function. */
9257 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
9258 /* virt-specifiers that apply to the declarator, for a declaration of
9259 a member function. */
9260 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
9261 /* ref-qualifier that applies to the declarator, for a declaration of
9262 a member function. */
9263 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
9264 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
9265 int type_quals
= TYPE_UNQUALIFIED
;
9266 tree raises
= NULL_TREE
;
9267 int template_count
= 0;
9268 tree returned_attrs
= NULL_TREE
;
9269 tree parms
= NULL_TREE
;
9270 const cp_declarator
*id_declarator
;
9271 /* The unqualified name of the declarator; either an
9272 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
9273 tree unqualified_id
;
9274 /* The class type, if any, in which this entity is located,
9275 or NULL_TREE if none. Note that this value may be different from
9276 the current class type; for example if an attempt is made to declare
9277 "A::f" inside "B", this value will be "A". */
9278 tree ctype
= current_class_type
;
9279 /* The NAMESPACE_DECL for the namespace in which this entity is
9280 located. If an unqualified name is used to declare the entity,
9281 this value will be NULL_TREE, even if the entity is located at
9283 tree in_namespace
= NULL_TREE
;
9284 cp_storage_class storage_class
;
9285 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
9286 bool type_was_error_mark_node
= false;
9287 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
9288 bool template_type_arg
= false;
9289 bool template_parm_flag
= false;
9290 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
9291 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
9292 bool late_return_type_p
= false;
9293 bool array_parameter_p
= false;
9294 source_location saved_loc
= input_location
;
9295 tree reqs
= NULL_TREE
;
9297 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
9298 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
9299 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
9300 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
9301 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
9302 explicit_intN
= declspecs
->explicit_intN_p
;
9303 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
9305 // Was concept_p specified? Note that ds_concept
9306 // implies ds_constexpr!
9307 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
9311 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9312 type_quals
|= TYPE_QUAL_CONST
;
9313 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9314 type_quals
|= TYPE_QUAL_VOLATILE
;
9315 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9316 type_quals
|= TYPE_QUAL_RESTRICT
;
9318 if (decl_context
== FUNCDEF
)
9319 funcdef_flag
= true, decl_context
= NORMAL
;
9320 else if (decl_context
== MEMFUNCDEF
)
9321 funcdef_flag
= true, decl_context
= FIELD
;
9322 else if (decl_context
== BITFIELD
)
9323 bitfield
= 1, decl_context
= FIELD
;
9324 else if (decl_context
== TEMPLATE_TYPE_ARG
)
9325 template_type_arg
= true, decl_context
= TYPENAME
;
9326 else if (decl_context
== TPARM
)
9327 template_parm_flag
= true, decl_context
= PARM
;
9329 if (initialized
> 1)
9330 funcdef_flag
= true;
9332 /* Look inside a declarator for the name being declared
9333 and get it as a string, for an error message. */
9334 for (id_declarator
= declarator
;
9336 id_declarator
= id_declarator
->declarator
)
9338 if (id_declarator
->kind
!= cdk_id
)
9339 innermost_code
= id_declarator
->kind
;
9341 switch (id_declarator
->kind
)
9344 if (id_declarator
->declarator
9345 && id_declarator
->declarator
->kind
== cdk_id
)
9347 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
9348 if (sfk
== sfk_destructor
)
9355 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
9356 tree decl
= id_declarator
->u
.id
.unqualified_name
;
9359 if (qualifying_scope
)
9361 if (at_function_scope_p ())
9365 A declarator-id shall not be qualified except
9368 None of the cases are permitted in block
9370 if (qualifying_scope
== global_namespace
)
9371 error ("invalid use of qualified-name %<::%D%>",
9373 else if (TYPE_P (qualifying_scope
))
9374 error ("invalid use of qualified-name %<%T::%D%>",
9375 qualifying_scope
, decl
);
9377 error ("invalid use of qualified-name %<%D::%D%>",
9378 qualifying_scope
, decl
);
9379 return error_mark_node
;
9381 else if (TYPE_P (qualifying_scope
))
9383 ctype
= qualifying_scope
;
9384 if (!MAYBE_CLASS_TYPE_P (ctype
))
9386 error ("%q#T is not a class or a namespace", ctype
);
9389 else if (innermost_code
!= cdk_function
9390 && current_class_type
9391 && !uniquely_derived_from_p (ctype
,
9392 current_class_type
))
9394 error ("invalid use of qualified-name %<%T::%D%>",
9395 qualifying_scope
, decl
);
9396 return error_mark_node
;
9399 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
9400 in_namespace
= qualifying_scope
;
9402 switch (TREE_CODE (decl
))
9408 if (innermost_code
!= cdk_function
)
9410 error ("declaration of %qD as non-function", decl
);
9411 return error_mark_node
;
9413 else if (!qualifying_scope
9414 && !(current_class_type
&& at_class_scope_p ()))
9416 error ("declaration of %qD as non-member", decl
);
9417 return error_mark_node
;
9420 type
= TREE_OPERAND (decl
, 0);
9422 type
= constructor_name (type
);
9423 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
9428 case TEMPLATE_ID_EXPR
:
9430 tree fns
= TREE_OPERAND (decl
, 0);
9433 if (!identifier_p (dname
))
9435 if (variable_template_p (dname
))
9436 dname
= DECL_NAME (dname
);
9439 gcc_assert (is_overloaded_fn (dname
));
9440 dname
= DECL_NAME (get_first_fn (dname
));
9446 case IDENTIFIER_NODE
:
9447 if (identifier_p (decl
))
9450 if (C_IS_RESERVED_WORD (dname
))
9452 error ("declarator-id missing; using reserved word %qD",
9454 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9456 else if (!IDENTIFIER_TYPENAME_P (dname
))
9457 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9460 gcc_assert (flags
== NO_SPECIAL
);
9461 flags
= TYPENAME_FLAG
;
9462 ctor_return_type
= TREE_TYPE (dname
);
9463 sfk
= sfk_conversion
;
9464 if (is_typename_at_global_scope (dname
))
9465 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9467 name
= "<invalid operator>";
9484 return error_mark_node
;
9489 if (id_declarator
->kind
== cdk_id
)
9495 The declarator in a function-definition shall have the form
9496 D1 ( parameter-declaration-clause) ... */
9497 if (funcdef_flag
&& innermost_code
!= cdk_function
)
9499 error ("function definition does not declare parameters");
9500 return error_mark_node
;
9503 if (flags
== TYPENAME_FLAG
9504 && innermost_code
!= cdk_function
9505 && ! (ctype
&& !declspecs
->any_specifiers_p
))
9507 error ("declaration of %qD as non-function", dname
);
9508 return error_mark_node
;
9512 && identifier_p (dname
)
9513 && UDLIT_OPER_P (dname
)
9514 && innermost_code
!= cdk_function
)
9516 error ("declaration of %qD as non-function", dname
);
9517 return error_mark_node
;
9520 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9524 error ("declaration of %qD as %<typedef%>", dname
);
9525 return error_mark_node
;
9527 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9529 error ("declaration of %qD as parameter", dname
);
9530 return error_mark_node
;
9534 /* Anything declared one level down from the top level
9535 must be one of the parameters of a function
9536 (because the body is at least two levels down). */
9538 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9539 by not allowing C++ class definitions to specify their parameters
9540 with xdecls (must be spec.d in the parmlist).
9542 Since we now wait to push a class scope until we are sure that
9543 we are in a legitimate method context, we must set oldcname
9544 explicitly (since current_class_name is not yet alive).
9546 We also want to avoid calling this a PARM if it is in a namespace. */
9548 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9550 cp_binding_level
*b
= current_binding_level
;
9551 current_binding_level
= b
->level_chain
;
9552 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9553 decl_context
= PARM
;
9554 current_binding_level
= b
;
9558 name
= decl_context
== PARM
? "parameter" : "type name";
9560 if (concept_p
&& typedef_p
)
9562 error ("%<concept%> cannot appear in a typedef declaration");
9563 return error_mark_node
;
9566 if (constexpr_p
&& typedef_p
)
9568 error ("%<constexpr%> cannot appear in a typedef declaration");
9569 return error_mark_node
;
9572 /* If there were multiple types specified in the decl-specifier-seq,
9573 issue an error message. */
9574 if (declspecs
->multiple_types_p
)
9576 error ("two or more data types in declaration of %qs", name
);
9577 return error_mark_node
;
9580 if (declspecs
->conflicting_specifiers_p
)
9582 error ("conflicting specifiers in declaration of %qs", name
);
9583 return error_mark_node
;
9586 /* Extract the basic type from the decl-specifier-seq. */
9587 type
= declspecs
->type
;
9588 if (type
== error_mark_node
)
9591 type_was_error_mark_node
= true;
9593 /* If the entire declaration is itself tagged as deprecated then
9594 suppress reports of deprecated items. */
9595 if (type
&& TREE_DEPRECATED (type
)
9596 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9597 warn_deprecated_use (type
, NULL_TREE
);
9598 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9600 typedef_decl
= type
;
9601 type
= TREE_TYPE (typedef_decl
);
9602 if (TREE_DEPRECATED (type
)
9603 && DECL_ARTIFICIAL (typedef_decl
)
9604 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9605 warn_deprecated_use (type
, NULL_TREE
);
9607 /* No type at all: default to `int', and set DEFAULTED_INT
9608 because it was not a user-defined typedef. */
9609 if (type
== NULL_TREE
)
9611 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
9613 /* These imply 'int'. */
9614 type
= integer_type_node
;
9617 /* If we just have "complex", it is equivalent to "complex double". */
9618 else if (!longlong
&& !explicit_intN
9619 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9621 type
= double_type_node
;
9622 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
9623 "ISO C++ does not support plain %<complex%> meaning "
9624 "%<double complex%>");
9628 explicit_int
= declspecs
->explicit_int_p
;
9629 explicit_char
= declspecs
->explicit_char_p
;
9632 /* See the code below that used this. */
9634 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9636 typedef_type
= type
;
9639 if (sfk
!= sfk_conversion
)
9640 ctor_return_type
= ctype
;
9642 if (sfk
!= sfk_none
)
9644 type
= check_special_function_return_type (sfk
, type
,
9647 declspecs
->locations
);
9648 type_quals
= TYPE_UNQUALIFIED
;
9650 else if (type
== NULL_TREE
)
9656 /* We handle `main' specially here, because 'main () { }' is so
9657 common. With no options, it is allowed. With -Wreturn-type,
9658 it is a warning. It is only an error with -pedantic-errors. */
9659 is_main
= (funcdef_flag
9660 && dname
&& identifier_p (dname
)
9661 && MAIN_NAME_P (dname
)
9662 && ctype
== NULL_TREE
9663 && in_namespace
== NULL_TREE
9664 && current_namespace
== global_namespace
);
9666 if (type_was_error_mark_node
)
9667 /* We've already issued an error, don't complain more. */;
9668 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9669 /* Allow it, sigh. */;
9671 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9673 pedwarn (input_location
, OPT_Wpedantic
,
9674 "ISO C++ forbids declaration of %qs with no type", name
);
9676 warning (OPT_Wreturn_type
,
9677 "ISO C++ forbids declaration of %qs with no type", name
);
9679 if (type_was_error_mark_node
&& template_parm_flag
)
9680 /* FIXME we should be able to propagate the error_mark_node as is
9681 for other contexts too. */
9682 type
= error_mark_node
;
9684 type
= integer_type_node
;
9691 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
9693 error ("%<__int%d%> is not supported by this target",
9694 int_n_data
[declspecs
->int_n_idx
].bitsize
);
9695 explicit_intN
= false;
9697 else if (pedantic
&& ! in_system_header_at (input_location
))
9698 pedwarn (input_location
, OPT_Wpedantic
,
9699 "ISO C++ does not support %<__int%d%> for %qs",
9700 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
9703 /* Now process the modifiers that were specified
9704 and check for invalid combinations. */
9706 /* Long double is a special combination. */
9707 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9710 type
= cp_build_qualified_type (long_double_type_node
,
9711 cp_type_quals (type
));
9714 /* Check all other uses of type modifiers. */
9716 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9720 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9721 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9722 else if (signed_p
&& unsigned_p
)
9723 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9724 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9725 error ("%<long long%> invalid for %qs", name
);
9726 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9727 error ("%<long%> invalid for %qs", name
);
9728 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9729 error ("%<short%> invalid for %qs", name
);
9730 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9731 error ("%<long%> or %<short%> invalid for %qs", name
);
9732 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
9733 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9734 else if ((long_p
|| short_p
) && explicit_char
)
9735 error ("%<long%> or %<short%> specified with char for %qs", name
);
9736 else if (long_p
&& short_p
)
9737 error ("%<long%> and %<short%> specified together for %qs", name
);
9738 else if (type
== char16_type_node
|| type
== char32_type_node
)
9740 if (signed_p
|| unsigned_p
)
9741 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9742 else if (short_p
|| long_p
)
9743 error ("%<short%> or %<long%> invalid for %qs", name
);
9748 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
9750 pedwarn (input_location
, OPT_Wpedantic
,
9751 "long, short, signed or unsigned used invalidly for %qs",
9753 if (flag_pedantic_errors
)
9758 /* Discard the type modifiers if they are invalid. */
9769 /* Decide whether an integer type is signed or not.
9770 Optionally treat bitfields as signed by default. */
9774 It is implementation-defined whether a plain (neither
9775 explicitly signed or unsigned) char, short, int, or long
9776 bit-field is signed or unsigned.
9778 Naturally, we extend this to long long as well. Note that
9779 this does not include wchar_t. */
9780 || (bitfield
&& !flag_signed_bitfields
9782 /* A typedef for plain `int' without `signed' can be
9783 controlled just like plain `int', but a typedef for
9784 `signed int' cannot be so controlled. */
9786 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9787 && TREE_CODE (type
) == INTEGER_TYPE
9788 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9791 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
9793 type
= long_long_unsigned_type_node
;
9795 type
= long_unsigned_type_node
;
9797 type
= short_unsigned_type_node
;
9798 else if (type
== char_type_node
)
9799 type
= unsigned_char_type_node
;
9800 else if (typedef_decl
)
9801 type
= unsigned_type_for (type
);
9803 type
= unsigned_type_node
;
9805 else if (signed_p
&& type
== char_type_node
)
9806 type
= signed_char_type_node
;
9807 else if (explicit_intN
)
9808 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
9810 type
= long_long_integer_type_node
;
9812 type
= long_integer_type_node
;
9814 type
= short_integer_type_node
;
9816 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9818 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9819 error ("complex invalid for %qs", name
);
9820 /* If a modifier is specified, the resulting complex is the complex
9821 form of TYPE. E.g, "complex short" is "complex short int". */
9822 else if (type
== integer_type_node
)
9823 type
= complex_integer_type_node
;
9824 else if (type
== float_type_node
)
9825 type
= complex_float_type_node
;
9826 else if (type
== double_type_node
)
9827 type
= complex_double_type_node
;
9828 else if (type
== long_double_type_node
)
9829 type
= complex_long_double_type_node
;
9831 type
= build_complex_type (type
);
9834 /* If we're using the injected-class-name to form a compound type or a
9835 declaration, replace it with the underlying class so we don't get
9836 redundant typedefs in the debug output. But if we are returning the
9837 type unchanged, leave it alone so that it's available to
9838 maybe_get_template_decl_from_type_decl. */
9839 if (CLASS_TYPE_P (type
)
9840 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9841 && type
== TREE_TYPE (TYPE_NAME (type
))
9842 && (declarator
|| type_quals
))
9843 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9845 type_quals
|= cp_type_quals (type
);
9846 type
= cp_build_qualified_type_real
9847 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
9848 || declspecs
->decltype_p
)
9849 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9850 /* We might have ignored or rejected some of the qualifiers. */
9851 type_quals
= cp_type_quals (type
);
9854 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9855 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9856 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9858 storage_class
= declspecs
->storage_class
;
9859 if (storage_class
== sc_static
)
9860 staticp
= 1 + (decl_context
== FIELD
);
9866 error ("member %qD cannot be declared both %<virtual%> "
9867 "and %<static%>", dname
);
9868 storage_class
= sc_none
;
9872 error ("member %qD cannot be declared both %<virtual%> "
9873 "and %<constexpr%>", dname
);
9875 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9877 /* Issue errors about use of storage classes for parameters. */
9878 if (decl_context
== PARM
)
9882 error ("typedef declaration invalid in parameter declaration");
9883 return error_mark_node
;
9885 else if (template_parm_flag
&& storage_class
!= sc_none
)
9887 error ("storage class specified for template parameter %qs", name
);
9888 return error_mark_node
;
9890 else if (storage_class
== sc_static
9891 || storage_class
== sc_extern
9893 error ("storage class specifiers invalid in parameter declarations");
9895 /* Function parameters cannot be concept. */
9897 error ("a parameter cannot be declared %<concept%>");
9898 /* Function parameters cannot be constexpr. If we saw one, moan
9899 and pretend it wasn't there. */
9900 else if (constexpr_p
)
9902 error ("a parameter cannot be declared %<constexpr%>");
9907 /* Give error if `virtual' is used outside of class declaration. */
9909 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9911 error_at (declspecs
->locations
[ds_virtual
],
9912 "%<virtual%> outside class declaration");
9916 /* Static anonymous unions are dealt with here. */
9917 if (staticp
&& decl_context
== TYPENAME
9919 && ANON_AGGR_TYPE_P (declspecs
->type
))
9920 decl_context
= FIELD
;
9922 /* Warn about storage classes that are invalid for certain
9923 kinds of declarations (parameters, typenames, etc.). */
9926 && storage_class
!= sc_extern
9927 && storage_class
!= sc_static
)
9930 error ("multiple storage classes in declaration of %qs", name
);
9933 if (decl_context
!= NORMAL
9934 && ((storage_class
!= sc_none
9935 && storage_class
!= sc_mutable
)
9938 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9939 && (storage_class
== sc_register
9940 || storage_class
== sc_auto
))
9944 else if (decl_context
== FIELD
9945 /* C++ allows static class elements. */
9946 && storage_class
== sc_static
)
9947 /* C++ also allows inlines and signed and unsigned elements,
9948 but in those cases we don't come in here. */
9952 if (decl_context
== FIELD
)
9953 error ("storage class specified for %qs", name
);
9956 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9957 error ("storage class specified for parameter %qs", name
);
9959 error ("storage class specified for typename");
9961 if (storage_class
== sc_register
9962 || storage_class
== sc_auto
9963 || storage_class
== sc_extern
9965 storage_class
= sc_none
;
9968 else if (storage_class
== sc_extern
&& funcdef_flag
9969 && ! toplevel_bindings_p ())
9970 error ("nested function %qs declared %<extern%>", name
);
9971 else if (toplevel_bindings_p ())
9973 if (storage_class
== sc_auto
)
9974 error ("top-level declaration of %qs specifies %<auto%>", name
);
9977 && storage_class
!= sc_extern
9978 && storage_class
!= sc_static
)
9980 if (declspecs
->gnu_thread_keyword_p
)
9981 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9982 "declared %<__thread%>", name
);
9984 /* When thread_local is applied to a variable of block scope the
9985 storage-class-specifier static is implied if it does not appear
9987 storage_class
= declspecs
->storage_class
= sc_static
;
9991 if (storage_class
&& friendp
)
9993 error ("storage class specifiers invalid in friend function declarations");
9994 storage_class
= sc_none
;
9999 unqualified_id
= NULL_TREE
;
10002 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
10003 switch (TREE_CODE (unqualified_id
))
10006 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
10007 if (TYPE_P (unqualified_id
))
10008 unqualified_id
= constructor_name (unqualified_id
);
10011 case IDENTIFIER_NODE
:
10012 case TEMPLATE_ID_EXPR
:
10016 gcc_unreachable ();
10020 if (declspecs
->std_attributes
)
10022 /* Apply the c++11 attributes to the type preceding them. */
10023 input_location
= declspecs
->locations
[ds_std_attribute
];
10024 decl_attributes (&type
, declspecs
->std_attributes
, 0);
10025 input_location
= saved_loc
;
10028 /* Determine the type of the entity declared by recurring on the
10030 for (; declarator
; declarator
= declarator
->declarator
)
10032 const cp_declarator
*inner_declarator
;
10035 if (type
== error_mark_node
)
10036 return error_mark_node
;
10038 attrs
= declarator
->attributes
;
10044 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
10045 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
10046 if (declarator
->kind
== cdk_function
)
10047 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
10048 if (declarator
->kind
== cdk_array
)
10049 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
10050 returned_attrs
= decl_attributes (&type
,
10051 chainon (returned_attrs
, attrs
),
10055 if (declarator
->kind
== cdk_id
)
10058 inner_declarator
= declarator
->declarator
;
10060 switch (declarator
->kind
)
10063 type
= create_array_type_for_decl (dname
, type
,
10064 declarator
->u
.array
.bounds
);
10065 if (!valid_array_size_p (input_location
, type
, dname
))
10066 type
= error_mark_node
;
10068 if (declarator
->std_attributes
)
10071 The optional attribute-specifier-seq appertains to the
10073 returned_attrs
= chainon (returned_attrs
,
10074 declarator
->std_attributes
);
10082 /* Declaring a function type.
10083 Make sure we have a valid type for the function to return. */
10085 if (type_quals
!= TYPE_UNQUALIFIED
)
10087 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
10088 warning (OPT_Wignored_qualifiers
,
10089 "type qualifiers ignored on function return type");
10090 /* We now know that the TYPE_QUALS don't apply to the
10091 decl, but to its return type. */
10092 type_quals
= TYPE_UNQUALIFIED
;
10095 /* Error about some types functions can't return. */
10097 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10099 error ("%qs declared as function returning a function", name
);
10100 return error_mark_node
;
10102 if (TREE_CODE (type
) == ARRAY_TYPE
)
10104 error ("%qs declared as function returning an array", name
);
10105 return error_mark_node
;
10108 input_location
= declspecs
->locations
[ds_type_spec
];
10109 abstract_virtuals_error (ACU_RETURN
, type
);
10110 input_location
= saved_loc
;
10112 /* Pick up type qualifiers which should be applied to `this'. */
10113 memfn_quals
= declarator
->u
.function
.qualifiers
;
10114 /* Pick up virt-specifiers. */
10115 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
10116 /* And ref-qualifier, too */
10117 rqual
= declarator
->u
.function
.ref_qualifier
;
10118 /* And tx-qualifier. */
10119 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
10120 /* Pick up the exception specifications. */
10121 raises
= declarator
->u
.function
.exception_specification
;
10122 /* If the exception-specification is ill-formed, let's pretend
10123 there wasn't one. */
10124 if (raises
== error_mark_node
)
10125 raises
= NULL_TREE
;
10128 error_at (location_of (reqs
), "requires-clause on return type");
10129 reqs
= declarator
->u
.function
.requires_clause
;
10131 /* Say it's a definition only for the CALL_EXPR
10132 closest to the identifier. */
10133 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
10135 /* Handle a late-specified return type. */
10138 if (type_uses_auto (type
))
10140 if (!declarator
->u
.function
.late_return_type
)
10142 if (current_class_type
10143 && LAMBDA_TYPE_P (current_class_type
))
10144 /* OK for C++11 lambdas. */;
10145 else if (cxx_dialect
< cxx14
)
10147 error ("%qs function uses "
10148 "%<auto%> type specifier without trailing "
10149 "return type", name
);
10150 inform (input_location
, "deduced return type "
10151 "only available with -std=c++14 or "
10156 error ("virtual function cannot "
10157 "have deduced return type");
10161 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
10163 error ("%qs function with trailing return type has"
10164 " %qT as its type rather than plain %<auto%>",
10166 return error_mark_node
;
10169 else if (declarator
->u
.function
.late_return_type
10170 && sfk
!= sfk_conversion
)
10172 if (cxx_dialect
< cxx11
)
10173 /* Not using maybe_warn_cpp0x because this should
10174 always be an error. */
10175 error ("trailing return type only available with "
10176 "-std=c++11 or -std=gnu++11");
10178 error ("%qs function with trailing return type not "
10179 "declared with %<auto%> type specifier", name
);
10180 return error_mark_node
;
10183 type
= splice_late_return_type
10184 (type
, declarator
->u
.function
.late_return_type
);
10185 if (type
== error_mark_node
)
10186 return error_mark_node
;
10188 if (declarator
->u
.function
.late_return_type
)
10189 late_return_type_p
= true;
10191 if (ctype
== NULL_TREE
10192 && decl_context
== FIELD
10195 ctype
= current_class_type
;
10197 if (ctype
&& (sfk
== sfk_constructor
10198 || sfk
== sfk_destructor
))
10200 /* We are within a class's scope. If our declarator name
10201 is the same as the class name, and we are defining
10202 a function, then it is a constructor/destructor, and
10203 therefore returns a void type. */
10205 /* ISO C++ 12.4/2. A destructor may not be declared
10206 const or volatile. A destructor may not be static.
10207 A destructor may not be declared with ref-qualifier.
10209 ISO C++ 12.1. A constructor may not be declared
10210 const or volatile. A constructor may not be
10211 virtual. A constructor may not be static.
10212 A constructor may not be declared with ref-qualifier. */
10214 error ((flags
== DTOR_FLAG
)
10215 ? G_("destructor cannot be static member function")
10216 : G_("constructor cannot be static member function"));
10219 error ((flags
== DTOR_FLAG
)
10220 ? G_("destructors may not be cv-qualified")
10221 : G_("constructors may not be cv-qualified"));
10222 memfn_quals
= TYPE_UNQUALIFIED
;
10227 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
10228 error ((flags
== DTOR_FLAG
)
10229 ? "destructors may not be ref-qualified"
10230 : "constructors may not be ref-qualified");
10231 rqual
= REF_QUAL_NONE
;
10234 if (decl_context
== FIELD
10235 && !member_function_or_else (ctype
,
10236 current_class_type
,
10238 return error_mark_node
;
10240 if (flags
!= DTOR_FLAG
)
10242 /* It's a constructor. */
10243 if (explicitp
== 1)
10247 permerror (input_location
,
10248 "constructors cannot be declared %<virtual%>");
10251 if (decl_context
== FIELD
10252 && sfk
!= sfk_constructor
)
10253 return error_mark_node
;
10255 if (decl_context
== FIELD
)
10262 /* Cannot be both friend and virtual. */
10263 error ("virtual functions cannot be friends");
10266 if (decl_context
== NORMAL
)
10267 error ("friend declaration not in class definition");
10268 if (current_function_decl
&& funcdef_flag
)
10269 error ("can%'t define friend function %qs in a local "
10270 "class definition",
10273 else if (ctype
&& sfk
== sfk_conversion
)
10275 if (explicitp
== 1)
10277 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
10280 if (late_return_type_p
)
10281 error ("a conversion function cannot have a trailing return type");
10284 arg_types
= grokparms (declarator
->u
.function
.parameters
,
10287 if (inner_declarator
10288 && inner_declarator
->kind
== cdk_id
10289 && inner_declarator
->u
.id
.sfk
== sfk_destructor
10290 && arg_types
!= void_list_node
)
10292 error ("destructors may not have parameters");
10293 arg_types
= void_list_node
;
10297 type
= build_function_type (type
, arg_types
);
10299 tree attrs
= declarator
->std_attributes
;
10302 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
10303 /* transaction_safe applies to the type, but
10304 transaction_safe_dynamic applies to the function. */
10305 if (is_attribute_p ("transaction_safe", tx_qual
))
10306 attrs
= chainon (attrs
, att
);
10308 returned_attrs
= chainon (returned_attrs
, att
);
10313 The optional attribute-specifier-seq appertains to
10314 the function type. */
10315 decl_attributes (&type
, attrs
, 0);
10320 case cdk_reference
:
10322 /* Filter out pointers-to-references and references-to-references.
10323 We can get these if a TYPE_DECL is used. */
10325 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10327 if (declarator
->kind
!= cdk_reference
)
10329 error ("cannot declare pointer to %q#T", type
);
10330 type
= TREE_TYPE (type
);
10333 /* In C++0x, we allow reference to reference declarations
10334 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
10335 and template type arguments [14.3.1/4 temp.arg.type]. The
10336 check for direct reference to reference declarations, which
10337 are still forbidden, occurs below. Reasoning behind the change
10338 can be found in DR106, DR540, and the rvalue reference
10340 else if (cxx_dialect
== cxx98
)
10342 error ("cannot declare reference to %q#T", type
);
10343 type
= TREE_TYPE (type
);
10346 else if (VOID_TYPE_P (type
))
10348 if (declarator
->kind
== cdk_reference
)
10349 error ("cannot declare reference to %q#T", type
);
10350 else if (declarator
->kind
== cdk_ptrmem
)
10351 error ("cannot declare pointer to %q#T member", type
);
10354 /* We now know that the TYPE_QUALS don't apply to the decl,
10355 but to the target of the pointer. */
10356 type_quals
= TYPE_UNQUALIFIED
;
10358 /* This code used to handle METHOD_TYPE, but I don't think it's
10359 possible to get it here anymore. */
10360 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
10361 if (declarator
->kind
== cdk_ptrmem
10362 && TREE_CODE (type
) == FUNCTION_TYPE
)
10364 memfn_quals
|= type_memfn_quals (type
);
10365 type
= build_memfn_type (type
,
10366 declarator
->u
.pointer
.class_type
,
10369 if (type
== error_mark_node
)
10370 return error_mark_node
;
10372 rqual
= REF_QUAL_NONE
;
10373 memfn_quals
= TYPE_UNQUALIFIED
;
10376 if (TREE_CODE (type
) == FUNCTION_TYPE
10377 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
10378 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
10379 error (declarator
->kind
== cdk_reference
10380 ? G_("cannot declare reference to qualified function type %qT")
10381 : G_("cannot declare pointer to qualified function type %qT"),
10384 /* When the pointed-to type involves components of variable size,
10385 care must be taken to ensure that the size evaluation code is
10386 emitted early enough to dominate all the possible later uses
10387 and late enough for the variables on which it depends to have
10390 This is expected to happen automatically when the pointed-to
10391 type has a name/declaration of it's own, but special attention
10392 is required if the type is anonymous.
10394 We handle the NORMAL and FIELD contexts here by inserting a
10395 dummy statement that just evaluates the size at a safe point
10396 and ensures it is not deferred until e.g. within a deeper
10397 conditional context (c++/43555).
10399 We expect nothing to be needed here for PARM or TYPENAME.
10400 Evaluating the size at this point for TYPENAME would
10401 actually be incorrect, as we might be in the middle of an
10402 expression with side effects on the pointed-to type size
10403 "arguments" prior to the pointer declaration point and the
10404 size evaluation could end up prior to the side effects. */
10406 if (!TYPE_NAME (type
)
10407 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
10408 && at_function_scope_p ()
10409 && variably_modified_type_p (type
, NULL_TREE
))
10411 TYPE_NAME (type
) = build_decl (UNKNOWN_LOCATION
, TYPE_DECL
,
10413 add_decl_expr (TYPE_NAME (type
));
10416 if (declarator
->kind
== cdk_reference
)
10418 /* In C++0x, the type we are creating a reference to might be
10419 a typedef which is itself a reference type. In that case,
10420 we follow the reference collapsing rules in
10421 [7.1.3/8 dcl.typedef] to create the final reference type:
10423 "If a typedef TD names a type that is a reference to a type
10424 T, an attempt to create the type 'lvalue reference to cv TD'
10425 creates the type 'lvalue reference to T,' while an attempt
10426 to create the type "rvalue reference to cv TD' creates the
10429 if (VOID_TYPE_P (type
))
10430 /* We already gave an error. */;
10431 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10433 if (declarator
->u
.reference
.rvalue_ref
)
10434 /* Leave type alone. */;
10436 type
= cp_build_reference_type (TREE_TYPE (type
), false);
10439 type
= cp_build_reference_type
10440 (type
, declarator
->u
.reference
.rvalue_ref
);
10442 /* In C++0x, we need this check for direct reference to
10443 reference declarations, which are forbidden by
10444 [8.3.2/5 dcl.ref]. Reference to reference declarations
10445 are only allowed indirectly through typedefs and template
10446 type arguments. Example:
10448 void foo(int & &); // invalid ref-to-ref decl
10450 typedef int & int_ref;
10451 void foo(int_ref &); // valid ref-to-ref decl
10453 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
10454 error ("cannot declare reference to %q#T, which is not "
10455 "a typedef or a template type argument", type
);
10457 else if (TREE_CODE (type
) == METHOD_TYPE
)
10458 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10459 else if (declarator
->kind
== cdk_ptrmem
)
10461 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
10462 != NAMESPACE_DECL
);
10463 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
10464 /* We will already have complained. */
10465 type
= error_mark_node
;
10467 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
10471 type
= build_pointer_type (type
);
10473 /* Process a list of type modifier keywords (such as
10474 const or volatile) that were given inside the `*' or `&'. */
10476 if (declarator
->u
.pointer
.qualifiers
)
10479 = cp_build_qualified_type (type
,
10480 declarator
->u
.pointer
.qualifiers
);
10481 type_quals
= cp_type_quals (type
);
10484 /* Apply C++11 attributes to the pointer, and not to the
10485 type pointed to. This is unlike what is done for GNU
10486 attributes above. It is to comply with [dcl.ptr]/1:
10488 [the optional attribute-specifier-seq (7.6.1) appertains
10489 to the pointer and not to the object pointed to]. */
10490 if (declarator
->std_attributes
)
10491 decl_attributes (&type
, declarator
->std_attributes
,
10501 gcc_unreachable ();
10505 /* A `constexpr' specifier used in an object declaration declares
10506 the object as `const'. */
10507 if (constexpr_p
&& innermost_code
!= cdk_function
)
10509 /* DR1688 says that a `constexpr' specifier in combination with
10510 `volatile' is valid. */
10512 if (TREE_CODE (type
) != REFERENCE_TYPE
)
10514 type_quals
|= TYPE_QUAL_CONST
;
10515 type
= cp_build_qualified_type (type
, type_quals
);
10519 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
10520 && TREE_CODE (type
) != FUNCTION_TYPE
10521 && TREE_CODE (type
) != METHOD_TYPE
10522 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
10524 error ("template-id %qD used as a declarator",
10526 unqualified_id
= dname
;
10529 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10530 qualified with a class-name, turn it into a METHOD_TYPE, unless
10531 we know that the function is static. We take advantage of this
10532 opportunity to do other processing that pertains to entities
10533 explicitly declared to be class members. Note that if DECLARATOR
10534 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10535 would not have exited the loop above. */
10537 && declarator
->u
.id
.qualifying_scope
10538 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
10540 ctype
= declarator
->u
.id
.qualifying_scope
;
10541 ctype
= TYPE_MAIN_VARIANT (ctype
);
10542 template_count
= num_template_headers_for_class (ctype
);
10544 if (ctype
== current_class_type
)
10548 permerror (input_location
, "member functions are implicitly friends of their class");
10552 permerror (declarator
->id_loc
,
10553 "extra qualification %<%T::%> on member %qs",
10556 else if (/* If the qualifying type is already complete, then we
10557 can skip the following checks. */
10558 !COMPLETE_TYPE_P (ctype
)
10559 && (/* If the function is being defined, then
10560 qualifying type must certainly be complete. */
10562 /* A friend declaration of "T::f" is OK, even if
10563 "T" is a template parameter. But, if this
10564 function is not a friend, the qualifying type
10565 must be a class. */
10566 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10567 /* For a declaration, the type need not be
10568 complete, if either it is dependent (since there
10569 is no meaningful definition of complete in that
10570 case) or the qualifying class is currently being
10572 || !(dependent_type_p (ctype
)
10573 || currently_open_class (ctype
)))
10574 /* Check that the qualifying type is complete. */
10575 && !complete_type_or_else (ctype
, NULL_TREE
))
10576 return error_mark_node
;
10577 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10579 if (current_class_type
10580 && (!friendp
|| funcdef_flag
))
10582 error (funcdef_flag
10583 ? G_("cannot define member function %<%T::%s%> "
10585 : G_("cannot declare member function %<%T::%s%> "
10587 ctype
, name
, current_class_type
);
10588 return error_mark_node
;
10591 else if (typedef_p
&& current_class_type
)
10593 error ("cannot declare member %<%T::%s%> within %qT",
10594 ctype
, name
, current_class_type
);
10595 return error_mark_node
;
10599 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10600 ctype
= current_class_type
;
10602 /* Now TYPE has the actual type. */
10604 if (returned_attrs
)
10607 *attrlist
= chainon (returned_attrs
, *attrlist
);
10609 attrlist
= &returned_attrs
;
10613 && declarator
->kind
== cdk_id
10614 && declarator
->std_attributes
)
10615 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10616 a declarator-id appertains to the entity that is declared. */
10617 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10619 /* Handle parameter packs. */
10620 if (parameter_pack_p
)
10622 if (decl_context
== PARM
)
10623 /* Turn the type into a pack expansion.*/
10624 type
= make_pack_expansion (type
);
10626 error ("non-parameter %qs cannot be a parameter pack", name
);
10629 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10630 && !processing_template_decl
10631 && variably_modified_type_p (type
, NULL_TREE
))
10633 if (decl_context
== FIELD
)
10634 error ("data member may not have variably modified type %qT", type
);
10636 error ("parameter may not have variably modified type %qT", type
);
10637 type
= error_mark_node
;
10640 if (explicitp
== 1 || (explicitp
&& friendp
))
10642 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10643 in the declaration of a constructor or conversion function within
10644 a class definition. */
10645 if (!current_class_type
)
10646 error_at (declspecs
->locations
[ds_explicit
],
10647 "%<explicit%> outside class declaration");
10649 error_at (declspecs
->locations
[ds_explicit
],
10650 "%<explicit%> in friend declaration");
10652 error_at (declspecs
->locations
[ds_explicit
],
10653 "only declarations of constructors and conversion operators "
10654 "can be %<explicit%>");
10658 if (storage_class
== sc_mutable
)
10660 if (decl_context
!= FIELD
|| friendp
)
10662 error ("non-member %qs cannot be declared %<mutable%>", name
);
10663 storage_class
= sc_none
;
10665 else if (decl_context
== TYPENAME
|| typedef_p
)
10667 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10668 storage_class
= sc_none
;
10670 else if (TREE_CODE (type
) == FUNCTION_TYPE
10671 || TREE_CODE (type
) == METHOD_TYPE
)
10673 error ("function %qs cannot be declared %<mutable%>", name
);
10674 storage_class
= sc_none
;
10678 error ("static %qs cannot be declared %<mutable%>", name
);
10679 storage_class
= sc_none
;
10681 else if (type_quals
& TYPE_QUAL_CONST
)
10683 error ("const %qs cannot be declared %<mutable%>", name
);
10684 storage_class
= sc_none
;
10686 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10688 permerror (input_location
, "reference %qs cannot be declared "
10689 "%<mutable%>", name
);
10690 storage_class
= sc_none
;
10694 /* If this is declaring a typedef name, return a TYPE_DECL. */
10695 if (typedef_p
&& decl_context
!= TYPENAME
)
10699 /* Note that the grammar rejects storage classes
10700 in typenames, fields or parameters. */
10701 if (current_lang_name
== lang_name_java
)
10702 TYPE_FOR_JAVA (type
) = 1;
10704 /* This declaration:
10706 typedef void f(int) const;
10708 declares a function type which is not a member of any
10709 particular class, but which is cv-qualified; for
10710 example "f S::*" declares a pointer to a const-qualified
10711 member function of S. We record the cv-qualification in the
10713 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10715 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10717 /* We have now dealt with these qualifiers. */
10718 memfn_quals
= TYPE_UNQUALIFIED
;
10719 rqual
= REF_QUAL_NONE
;
10722 if (type_uses_auto (type
))
10724 error ("typedef declared %<auto%>");
10725 type
= error_mark_node
;
10729 error_at (location_of (reqs
), "requires-clause on typedef");
10731 if (decl_context
== FIELD
)
10732 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10734 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10735 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10736 error_at (DECL_SOURCE_LOCATION (decl
),
10737 "typedef name may not be a nested-name-specifier");
10738 TREE_TYPE (decl
) = error_mark_node
;
10741 if (decl_context
!= FIELD
)
10743 if (!current_function_decl
)
10744 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10745 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10746 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10747 (current_function_decl
)))
10748 /* The TYPE_DECL is "abstract" because there will be
10749 clones of this constructor/destructor, and there will
10750 be copies of this TYPE_DECL generated in those
10751 clones. The decloning optimization (for space) may
10752 revert this subsequently if it determines that
10753 the clones should share a common implementation. */
10754 DECL_ABSTRACT_P (decl
) = true;
10756 else if (current_class_type
10757 && constructor_name_p (unqualified_id
, current_class_type
))
10758 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10759 "as enclosing class",
10762 /* If the user declares "typedef struct {...} foo" then the
10763 struct will have an anonymous name. Fill that name in now.
10764 Nothing can refer to it, so nothing needs know about the name
10766 if (type
!= error_mark_node
10768 && TYPE_NAME (type
)
10769 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10770 && TYPE_ANONYMOUS_P (type
)
10771 && declspecs
->type_definition_p
10772 && attributes_naming_typedef_ok (*attrlist
)
10773 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10777 /* Replace the anonymous name with the real name everywhere. */
10778 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10780 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
10781 /* We do not rename the debug info representing the
10782 anonymous tagged type because the standard says in
10783 [dcl.typedef] that the naming applies only for
10784 linkage purposes. */
10785 /*debug_hooks->set_name (t, decl);*/
10786 TYPE_NAME (t
) = decl
;
10789 if (TYPE_LANG_SPECIFIC (type
))
10790 TYPE_WAS_ANONYMOUS (type
) = 1;
10792 /* If this is a typedef within a template class, the nested
10793 type is a (non-primary) template. The name for the
10794 template needs updating as well. */
10795 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10796 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10797 = TYPE_IDENTIFIER (type
);
10799 /* Adjust linkage now that we aren't anonymous anymore. */
10800 reset_type_linkage (type
);
10802 /* FIXME remangle member functions; member functions of a
10803 type with external linkage have external linkage. */
10807 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10808 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10810 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10811 memfn_quals
!= TYPE_UNQUALIFIED
,
10812 inlinep
, friendp
, raises
!= NULL_TREE
);
10814 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10815 /* Acknowledge that this was written:
10816 `using analias = atype;'. */
10817 TYPE_DECL_ALIAS_P (decl
) = 1;
10822 /* Detect the case of an array type of unspecified size
10823 which came, as such, direct from a typedef name.
10824 We must copy the type, so that the array's domain can be
10825 individually set by the object's initializer. */
10827 if (type
&& typedef_type
10828 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10829 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10830 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10832 /* Detect where we're using a typedef of function type to declare a
10833 function. PARMS will not be set, so we must create it now. */
10835 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10837 tree decls
= NULL_TREE
;
10840 for (args
= TYPE_ARG_TYPES (type
);
10841 args
&& args
!= void_list_node
;
10842 args
= TREE_CHAIN (args
))
10844 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10846 DECL_CHAIN (decl
) = decls
;
10850 parms
= nreverse (decls
);
10852 if (decl_context
!= TYPENAME
)
10854 /* The qualifiers on the function type become the qualifiers on
10855 the non-static member function. */
10856 memfn_quals
|= type_memfn_quals (type
);
10857 rqual
= type_memfn_rqual (type
);
10858 type_quals
= TYPE_UNQUALIFIED
;
10862 /* If this is a type name (such as, in a cast or sizeof),
10863 compute the type and return it now. */
10865 if (decl_context
== TYPENAME
)
10867 /* Note that here we don't care about type_quals. */
10869 /* Special case: "friend class foo" looks like a TYPENAME context. */
10874 error ("%<inline%> specified for friend class declaration");
10880 /* Don't allow friend declaration without a class-key. */
10881 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10882 permerror (input_location
, "template parameters cannot be friends");
10883 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10884 permerror (input_location
, "friend declaration requires class-key, "
10885 "i.e. %<friend class %T::%D%>",
10886 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10888 permerror (input_location
, "friend declaration requires class-key, "
10889 "i.e. %<friend %#T%>",
10893 /* Only try to do this stuff if we didn't already give up. */
10894 if (type
!= integer_type_node
)
10896 /* A friendly class? */
10897 if (current_class_type
)
10898 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10899 /*complain=*/true);
10901 error ("trying to make class %qT a friend of global scope",
10904 type
= void_type_node
;
10907 else if (memfn_quals
|| rqual
)
10909 if (ctype
== NULL_TREE
10910 && TREE_CODE (type
) == METHOD_TYPE
)
10911 ctype
= TYPE_METHOD_BASETYPE (type
);
10914 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10915 /* Core issue #547: need to allow this in template type args.
10916 Allow it in general in C++11 for alias-declarations. */
10917 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10918 && TREE_CODE (type
) == FUNCTION_TYPE
)
10919 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10921 error ("invalid qualifiers on non-member function type");
10925 error_at (location_of (reqs
), "requires-clause on type-id");
10929 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10930 && decl_context
!= CATCHPARM
10931 && TREE_CODE (type
) != UNION_TYPE
10934 error ("abstract declarator %qT used as declaration", type
);
10935 return error_mark_node
;
10938 /* Only functions may be declared using an operator-function-id. */
10940 && IDENTIFIER_OPNAME_P (unqualified_id
)
10941 && TREE_CODE (type
) != FUNCTION_TYPE
10942 && TREE_CODE (type
) != METHOD_TYPE
)
10944 error ("declaration of %qD as non-function", unqualified_id
);
10945 return error_mark_node
;
10949 && TREE_CODE (type
) != FUNCTION_TYPE
10950 && TREE_CODE (type
) != METHOD_TYPE
)
10951 error_at (location_of (reqs
),
10952 "requires-clause on declaration of non-function type %qT",
10955 /* We don't check parameter types here because we can emit a better
10956 error message later. */
10957 if (decl_context
!= PARM
)
10959 type
= check_var_type (unqualified_id
, type
);
10960 if (type
== error_mark_node
)
10961 return error_mark_node
;
10964 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10965 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10967 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10969 if (ctype
|| in_namespace
)
10970 error ("cannot use %<::%> in parameter declaration");
10972 if (type_uses_auto (type
))
10974 if (cxx_dialect
>= cxx14
)
10975 error ("%<auto%> parameter not permitted in this context");
10977 error ("parameter declared %<auto%>");
10978 type
= error_mark_node
;
10981 /* A parameter declared as an array of T is really a pointer to T.
10982 One declared as a function is really a pointer to a function.
10983 One declared as a member is really a pointer to member. */
10985 if (TREE_CODE (type
) == ARRAY_TYPE
)
10987 /* Transfer const-ness of array into that of type pointed to. */
10988 type
= build_pointer_type (TREE_TYPE (type
));
10989 type_quals
= TYPE_UNQUALIFIED
;
10990 array_parameter_p
= true;
10992 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10993 type
= build_pointer_type (type
);
10996 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10997 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10999 cp_cv_quals real_quals
= memfn_quals
;
11000 if (cxx_dialect
< cxx14
&& constexpr_p
11001 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
11002 real_quals
|= TYPE_QUAL_CONST
;
11003 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
11007 tree decl
= NULL_TREE
;
11009 if (decl_context
== PARM
)
11011 decl
= cp_build_parm_decl (unqualified_id
, type
);
11012 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
11014 bad_specifiers (decl
, BSP_PARM
, virtualp
,
11015 memfn_quals
!= TYPE_UNQUALIFIED
,
11016 inlinep
, friendp
, raises
!= NULL_TREE
);
11018 else if (decl_context
== FIELD
)
11020 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
11021 && type_uses_auto (type
))
11023 error ("non-static data member declared %<auto%>");
11024 type
= error_mark_node
;
11027 /* The C99 flexible array extension. */
11028 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
11029 && TYPE_DOMAIN (type
) == NULL_TREE
)
11032 && (TREE_CODE (ctype
) == UNION_TYPE
11033 || TREE_CODE (ctype
) == QUAL_UNION_TYPE
))
11035 error ("flexible array member in union");
11036 type
= error_mark_node
;
11040 /* Flexible array member has a null domain. */
11041 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
11045 if (type
== error_mark_node
)
11047 /* Happens when declaring arrays of sizes which
11048 are error_mark_node, for example. */
11051 else if (in_namespace
&& !friendp
)
11053 /* Something like struct S { int N::j; }; */
11054 error ("invalid use of %<::%>");
11055 return error_mark_node
;
11057 else if (TREE_CODE (type
) == FUNCTION_TYPE
11058 || TREE_CODE (type
) == METHOD_TYPE
)
11061 tree function_context
;
11065 /* This should never happen in pure C++ (the check
11066 could be an assert). It could happen in
11067 Objective-C++ if someone writes invalid code that
11068 uses a function declaration for an instance
11069 variable or property (instance variables and
11070 properties are parsed as FIELD_DECLs, but they are
11071 part of an Objective-C class, not a C++ class).
11072 That code is invalid and is caught by this
11076 error ("declaration of function %qD in invalid context",
11078 return error_mark_node
;
11081 /* ``A union may [ ... ] not [ have ] virtual functions.''
11083 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
11085 error ("function %qD declared %<virtual%> inside a union",
11087 return error_mark_node
;
11090 if (NEW_DELETE_OPNAME_P (unqualified_id
))
11094 error ("%qD cannot be declared %<virtual%>, since it "
11095 "is always static",
11102 /* Check that the name used for a destructor makes sense. */
11103 if (sfk
== sfk_destructor
)
11105 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
11109 gcc_assert (friendp
);
11110 error ("expected qualified name in friend declaration "
11111 "for destructor %qD", uqname
);
11112 return error_mark_node
;
11115 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
11117 error ("declaration of %qD as member of %qT",
11119 return error_mark_node
;
11123 error ("a destructor cannot be %<concept%>");
11124 return error_mark_node
;
11128 error ("a destructor cannot be %<constexpr%>");
11129 return error_mark_node
;
11132 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
11134 error ("expected qualified name in friend declaration "
11135 "for constructor %qD",
11136 id_declarator
->u
.id
.unqualified_name
);
11137 return error_mark_node
;
11139 if (sfk
== sfk_constructor
)
11142 error ("a constructor cannot be %<concept%>");
11143 return error_mark_node
;
11147 error ("a concept cannot be a member function");
11151 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11153 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
11154 if (variable_template_p (tmpl
))
11156 error ("specialization of variable template %qD "
11157 "declared as function", tmpl
);
11158 inform (DECL_SOURCE_LOCATION (tmpl
),
11159 "variable template declared here");
11160 return error_mark_node
;
11164 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11165 function_context
= (ctype
!= NULL_TREE
) ?
11166 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11167 publicp
= (! friendp
|| ! staticp
)
11168 && function_context
== NULL_TREE
;
11170 if (late_return_type_p
)
11171 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11173 decl
= grokfndecl (ctype
, type
,
11174 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
11175 ? unqualified_id
: dname
,
11179 virtualp
, flags
, memfn_quals
, rqual
, raises
,
11180 friendp
? -1 : 0, friendp
, publicp
,
11181 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11182 initialized
== SD_DELETED
, sfk
,
11183 funcdef_flag
, template_count
, in_namespace
,
11184 attrlist
, declarator
->id_loc
);
11185 decl
= set_virt_specifiers (decl
, virt_specifiers
);
11186 if (decl
== NULL_TREE
)
11187 return error_mark_node
;
11189 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11190 /* The decl and setting of decl_attr is also turned off. */
11191 decl
= build_decl_attribute_variant (decl
, decl_attr
);
11194 /* [class.conv.ctor]
11196 A constructor declared without the function-specifier
11197 explicit that can be called with a single parameter
11198 specifies a conversion from the type of its first
11199 parameter to the type of its class. Such a constructor
11200 is called a converting constructor. */
11201 if (explicitp
== 2)
11202 DECL_NONCONVERTING_P (decl
) = 1;
11204 else if (!staticp
&& !dependent_type_p (type
)
11205 && !COMPLETE_TYPE_P (complete_type (type
))
11206 && (!complete_or_array_type_p (type
)
11207 || initialized
== 0))
11209 if (TREE_CODE (type
) != ARRAY_TYPE
11210 || !COMPLETE_TYPE_P (TREE_TYPE (type
)))
11212 if (unqualified_id
)
11214 error ("field %qD has incomplete type %qT",
11215 unqualified_id
, type
);
11216 cxx_incomplete_type_inform (strip_array_types (type
));
11219 error ("name %qT has incomplete type", type
);
11221 type
= error_mark_node
;
11229 error ("%qE is neither function nor member function; "
11230 "cannot be declared friend", unqualified_id
);
11238 /* Friends are treated specially. */
11239 if (ctype
== current_class_type
)
11240 ; /* We already issued a permerror. */
11241 else if (decl
&& DECL_NAME (decl
))
11243 if (template_class_depth (current_class_type
) == 0)
11245 decl
= check_explicit_specialization
11246 (unqualified_id
, decl
, template_count
,
11247 2 * funcdef_flag
+ 4);
11248 if (decl
== error_mark_node
)
11249 return error_mark_node
;
11252 decl
= do_friend (ctype
, unqualified_id
, decl
,
11258 return error_mark_node
;
11261 /* Structure field. It may not be a function, except for C++. */
11263 if (decl
== NULL_TREE
)
11267 /* C++ allows static class members. All other work
11268 for this is done by grokfield. */
11269 decl
= build_lang_decl_loc (declarator
11270 ? declarator
->id_loc
11272 VAR_DECL
, unqualified_id
, type
);
11273 set_linkage_for_static_data_member (decl
);
11274 /* Even if there is an in-class initialization, DECL
11275 is considered undefined until an out-of-class
11276 definition is provided. */
11277 DECL_EXTERNAL (decl
) = 1;
11281 CP_DECL_THREAD_LOCAL_P (decl
) = true;
11282 if (!processing_template_decl
)
11283 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
11284 if (declspecs
->gnu_thread_keyword_p
)
11285 SET_DECL_GNU_TLS_P (decl
);
11288 error ("static data member %qE declared %<concept%>",
11290 else if (constexpr_p
&& !initialized
)
11292 error ("constexpr static data member %qD must have an "
11293 "initializer", decl
);
11294 constexpr_p
= false;
11300 error ("non-static data member %qE declared %<concept%>",
11302 else if (constexpr_p
)
11304 error ("non-static data member %qE declared %<constexpr%>",
11306 constexpr_p
= false;
11308 decl
= build_decl (input_location
,
11309 FIELD_DECL
, unqualified_id
, type
);
11310 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11311 if (bitfield
&& !unqualified_id
)
11312 TREE_NO_WARNING (decl
) = 1;
11314 if (storage_class
== sc_mutable
)
11316 DECL_MUTABLE_P (decl
) = 1;
11317 storage_class
= sc_none
;
11322 /* An attempt is being made to initialize a non-static
11323 member. This is new in C++11. */
11324 maybe_warn_cpp0x (CPP0X_NSDMI
);
11326 /* If this has been parsed with static storage class, but
11327 errors forced staticp to be cleared, ensure NSDMI is
11329 if (declspecs
->storage_class
== sc_static
)
11330 DECL_INITIAL (decl
) = error_mark_node
;
11334 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
11335 memfn_quals
!= TYPE_UNQUALIFIED
,
11336 inlinep
, friendp
, raises
!= NULL_TREE
);
11339 else if (TREE_CODE (type
) == FUNCTION_TYPE
11340 || TREE_CODE (type
) == METHOD_TYPE
)
11342 tree original_name
;
11345 if (!unqualified_id
)
11346 return error_mark_node
;
11348 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11349 original_name
= dname
;
11351 original_name
= unqualified_id
;
11353 if (storage_class
== sc_auto
)
11354 error ("storage class %<auto%> invalid for function %qs", name
);
11355 else if (storage_class
== sc_register
)
11356 error ("storage class %<register%> invalid for function %qs", name
);
11359 if (declspecs
->gnu_thread_keyword_p
)
11360 error ("storage class %<__thread%> invalid for function %qs",
11363 error ("storage class %<thread_local%> invalid for function %qs",
11367 if (virt_specifiers
)
11368 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
11369 /* Function declaration not at top level.
11370 Storage classes other than `extern' are not allowed
11371 and `extern' makes no difference. */
11372 if (! toplevel_bindings_p ()
11373 && (storage_class
== sc_static
11374 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
11377 if (storage_class
== sc_static
)
11378 pedwarn (input_location
, OPT_Wpedantic
,
11379 "%<static%> specifier invalid for function %qs "
11380 "declared out of global scope", name
);
11382 pedwarn (input_location
, OPT_Wpedantic
,
11383 "%<inline%> specifier invalid for function %qs "
11384 "declared out of global scope", name
);
11387 if (ctype
== NULL_TREE
)
11391 error ("virtual non-class function %qs", name
);
11394 else if (sfk
== sfk_constructor
11395 || sfk
== sfk_destructor
)
11397 error (funcdef_flag
11398 ? G_("%qs defined in a non-class scope")
11399 : G_("%qs declared in a non-class scope"), name
);
11404 /* Record whether the function is public. */
11405 publicp
= (ctype
!= NULL_TREE
11406 || storage_class
!= sc_static
);
11408 if (late_return_type_p
)
11409 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11411 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
11412 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
11415 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11416 initialized
== SD_DELETED
,
11419 template_count
, in_namespace
, attrlist
,
11420 declarator
->id_loc
);
11421 if (decl
== NULL_TREE
)
11422 return error_mark_node
;
11426 int invalid_static
= 0;
11428 /* Don't allow a static member function in a class, and forbid
11429 declaring main to be static. */
11430 if (TREE_CODE (type
) == METHOD_TYPE
)
11432 permerror (input_location
, "cannot declare member function %qD to have "
11433 "static linkage", decl
);
11434 invalid_static
= 1;
11436 else if (current_function_decl
)
11438 /* 7.1.1: There can be no static function declarations within a
11440 error ("cannot declare static function inside another function");
11441 invalid_static
= 1;
11444 if (invalid_static
)
11447 storage_class
= sc_none
;
11453 /* It's a variable. */
11455 /* An uninitialized decl with `extern' is a reference. */
11456 decl
= grokvardecl (type
, dname
, unqualified_id
,
11459 ((type_quals
& TYPE_QUAL_CONST
) != 0) | (2 * concept_p
),
11461 ctype
? ctype
: in_namespace
);
11462 if (decl
== NULL_TREE
)
11463 return error_mark_node
;
11465 bad_specifiers (decl
, BSP_VAR
, virtualp
,
11466 memfn_quals
!= TYPE_UNQUALIFIED
,
11467 inlinep
, friendp
, raises
!= NULL_TREE
);
11471 DECL_CONTEXT (decl
) = ctype
;
11474 permerror (input_location
, "%<static%> may not be used when defining "
11475 "(as opposed to declaring) a static data member");
11477 storage_class
= sc_none
;
11479 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
11481 error ("static member %qD declared %<register%>", decl
);
11482 storage_class
= sc_none
;
11484 if (storage_class
== sc_extern
&& pedantic
)
11486 pedwarn (input_location
, OPT_Wpedantic
,
11487 "cannot explicitly declare member %q#D to have "
11488 "extern linkage", decl
);
11489 storage_class
= sc_none
;
11492 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
11494 error ("declaration of constexpr variable %qD is not a definition",
11496 constexpr_p
= false;
11500 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
11502 if (toplevel_bindings_p ())
11504 /* It's common practice (and completely valid) to have a const
11505 be initialized and declared extern. */
11506 if (!(type_quals
& TYPE_QUAL_CONST
))
11507 warning (0, "%qs initialized and declared %<extern%>", name
);
11511 error ("%qs has both %<extern%> and initializer", name
);
11512 return error_mark_node
;
11516 /* Record `register' declaration for warnings on &
11517 and in case doing stupid register allocation. */
11519 if (storage_class
== sc_register
)
11520 DECL_REGISTER (decl
) = 1;
11521 else if (storage_class
== sc_extern
)
11522 DECL_THIS_EXTERN (decl
) = 1;
11523 else if (storage_class
== sc_static
)
11524 DECL_THIS_STATIC (decl
) = 1;
11526 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11527 if (constexpr_p
&& VAR_P (decl
))
11528 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
11530 /* Record constancy and volatility on the DECL itself . There's
11531 no need to do this when processing a template; we'll do this
11532 for the instantiated declaration based on the type of DECL. */
11533 if (!processing_template_decl
)
11534 cp_apply_type_quals_to_decl (type_quals
, decl
);
11540 /* Subroutine of start_function. Ensure that each of the parameter
11541 types (as listed in PARMS) is complete, as is required for a
11542 function definition. */
11545 require_complete_types_for_parms (tree parms
)
11547 for (; parms
; parms
= DECL_CHAIN (parms
))
11549 if (dependent_type_p (TREE_TYPE (parms
)))
11551 if (!VOID_TYPE_P (TREE_TYPE (parms
))
11552 && complete_type_or_else (TREE_TYPE (parms
), parms
))
11554 relayout_decl (parms
);
11555 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
11558 /* grokparms or complete_type_or_else will have already issued
11560 TREE_TYPE (parms
) = error_mark_node
;
11564 /* Returns nonzero if T is a local variable. */
11567 local_variable_p (const_tree t
)
11570 /* A VAR_DECL with a context that is a _TYPE is a static data
11572 && !TYPE_P (CP_DECL_CONTEXT (t
))
11573 /* Any other non-local variable must be at namespace scope. */
11574 && !DECL_NAMESPACE_SCOPE_P (t
))
11575 || (TREE_CODE (t
) == PARM_DECL
))
11581 /* Like local_variable_p, but suitable for use as a tree-walking
11585 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
11588 if (local_variable_p (*tp
)
11589 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
11591 else if (TYPE_P (*tp
))
11592 *walk_subtrees
= 0;
11597 /* Check that ARG, which is a default-argument expression for a
11598 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11599 something goes wrong. DECL may also be a _TYPE node, rather than a
11600 DECL, if there is no DECL available. */
11603 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
11608 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11609 /* We get a DEFAULT_ARG when looking at an in-class declaration
11610 with a default argument. Ignore the argument for now; we'll
11611 deal with it after the class is complete. */
11620 decl_type
= TREE_TYPE (decl
);
11622 if (arg
== error_mark_node
11623 || decl
== error_mark_node
11624 || TREE_TYPE (arg
) == error_mark_node
11625 || decl_type
== error_mark_node
)
11626 /* Something already went wrong. There's no need to check
11628 return error_mark_node
;
11630 /* [dcl.fct.default]
11632 A default argument expression is implicitly converted to the
11634 ++cp_unevaluated_operand
;
11635 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
11637 --cp_unevaluated_operand
;
11639 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
11641 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
11642 && null_ptr_cst_p (arg
))
11643 return nullptr_node
;
11645 /* [dcl.fct.default]
11647 Local variables shall not be used in default argument
11650 The keyword `this' shall not be used in a default argument of a
11651 member function. */
11652 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11655 if (complain
& tf_warning_or_error
)
11657 if (DECL_NAME (var
) == this_identifier
)
11658 permerror (input_location
, "default argument %qE uses %qD",
11661 error ("default argument %qE uses local variable %qD", arg
, var
);
11663 return error_mark_node
;
11670 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11673 type_is_deprecated (tree type
)
11675 enum tree_code code
;
11676 if (TREE_DEPRECATED (type
))
11678 if (TYPE_NAME (type
))
11680 if (TREE_DEPRECATED (TYPE_NAME (type
)))
11686 /* Do warn about using typedefs to a deprecated class. */
11687 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11688 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11690 code
= TREE_CODE (type
);
11692 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11693 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11694 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11695 return type_is_deprecated (TREE_TYPE (type
));
11697 if (TYPE_PTRMEMFUNC_P (type
))
11698 return type_is_deprecated
11699 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11704 /* Decode the list of parameter types for a function type.
11705 Given the list of things declared inside the parens,
11706 return a list of types.
11708 If this parameter does not end with an ellipsis, we append
11711 *PARMS is set to the chain of PARM_DECLs created. */
11714 grokparms (tree parmlist
, tree
*parms
)
11716 tree result
= NULL_TREE
;
11717 tree decls
= NULL_TREE
;
11721 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11723 tree type
= NULL_TREE
;
11724 tree init
= TREE_PURPOSE (parm
);
11725 tree decl
= TREE_VALUE (parm
);
11727 if (parm
== void_list_node
)
11730 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11733 type
= TREE_TYPE (decl
);
11734 if (VOID_TYPE_P (type
))
11736 if (same_type_p (type
, void_type_node
)
11738 && !DECL_NAME (decl
) && !result
11739 && TREE_CHAIN (parm
) == void_list_node
)
11740 /* DR 577: A parameter list consisting of a single
11741 unnamed parameter of non-dependent type 'void'. */
11743 else if (cv_qualified_p (type
))
11744 error_at (DECL_SOURCE_LOCATION (decl
),
11745 "invalid use of cv-qualified type %qT in "
11746 "parameter declaration", type
);
11748 error_at (DECL_SOURCE_LOCATION (decl
),
11749 "invalid use of type %<void%> in parameter "
11751 /* It's not a good idea to actually create parameters of
11752 type `void'; other parts of the compiler assume that a
11753 void type terminates the parameter list. */
11754 type
= error_mark_node
;
11755 TREE_TYPE (decl
) = error_mark_node
;
11758 if (type
!= error_mark_node
11759 && TYPE_FOR_JAVA (type
)
11760 && MAYBE_CLASS_TYPE_P (type
))
11762 error ("parameter %qD has Java class type", decl
);
11763 type
= error_mark_node
;
11764 TREE_TYPE (decl
) = error_mark_node
;
11768 if (type
!= error_mark_node
)
11770 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11772 tree deptype
= type_is_deprecated (type
);
11774 warn_deprecated_use (deptype
, NULL_TREE
);
11777 /* Top-level qualifiers on the parameters are
11778 ignored for function types. */
11779 type
= cp_build_qualified_type (type
, 0);
11780 if (TREE_CODE (type
) == METHOD_TYPE
)
11782 error ("parameter %qD invalidly declared method type", decl
);
11783 type
= build_pointer_type (type
);
11784 TREE_TYPE (decl
) = type
;
11786 else if (abstract_virtuals_error (decl
, type
))
11787 any_error
= 1; /* Seems like a good idea. */
11788 else if (POINTER_TYPE_P (type
))
11790 /* [dcl.fct]/6, parameter types cannot contain pointers
11791 (references) to arrays of unknown bound. */
11792 tree t
= TREE_TYPE (type
);
11793 int ptr
= TYPE_PTR_P (type
);
11797 if (TYPE_PTR_P (t
))
11799 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11801 else if (!TYPE_DOMAIN (t
))
11805 if (TREE_CODE (t
) == ARRAY_TYPE
)
11807 ? G_("parameter %qD includes pointer to array of "
11808 "unknown bound %qT")
11809 : G_("parameter %qD includes reference to array of "
11810 "unknown bound %qT"),
11816 else if (init
&& !processing_template_decl
)
11817 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11820 DECL_CHAIN (decl
) = decls
;
11822 result
= tree_cons (init
, type
, result
);
11824 decls
= nreverse (decls
);
11825 result
= nreverse (result
);
11827 result
= chainon (result
, void_list_node
);
11834 /* D is a constructor or overloaded `operator='.
11836 Let T be the class in which D is declared. Then, this function
11839 -1 if D's is an ill-formed constructor or copy assignment operator
11840 whose first parameter is of type `T'.
11841 0 if D is not a copy constructor or copy assignment
11843 1 if D is a copy constructor or copy assignment operator whose
11844 first parameter is a reference to non-const qualified T.
11845 2 if D is a copy constructor or copy assignment operator whose
11846 first parameter is a reference to const qualified T.
11848 This function can be used as a predicate. Positive values indicate
11849 a copy constructor and nonzero values indicate a copy assignment
11853 copy_fn_p (const_tree d
)
11859 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11861 if (TREE_CODE (d
) == TEMPLATE_DECL
11862 || (DECL_TEMPLATE_INFO (d
)
11863 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11864 /* Instantiations of template member functions are never copy
11865 functions. Note that member functions of templated classes are
11866 represented as template functions internally, and we must
11867 accept those as copy functions. */
11870 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11874 arg_type
= TREE_VALUE (args
);
11875 if (arg_type
== error_mark_node
)
11878 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11880 /* Pass by value copy assignment operator. */
11883 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11884 && !TYPE_REF_IS_RVALUE (arg_type
)
11885 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11887 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11893 args
= TREE_CHAIN (args
);
11895 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11896 /* There are more non-optional args. */
11902 /* D is a constructor or overloaded `operator='.
11904 Let T be the class in which D is declared. Then, this function
11905 returns true when D is a move constructor or move assignment
11906 operator, false otherwise. */
11909 move_fn_p (const_tree d
)
11911 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11913 if (cxx_dialect
== cxx98
)
11914 /* There are no move constructors if we are in C++98 mode. */
11917 if (TREE_CODE (d
) == TEMPLATE_DECL
11918 || (DECL_TEMPLATE_INFO (d
)
11919 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11920 /* Instantiations of template member functions are never move
11921 functions. Note that member functions of templated classes are
11922 represented as template functions internally, and we must
11923 accept those as move functions. */
11926 return move_signature_fn_p (d
);
11929 /* D is a constructor or overloaded `operator='.
11931 Then, this function returns true when D has the same signature as a move
11932 constructor or move assignment operator (because either it is such a
11933 ctor/op= or it is a template specialization with the same signature),
11934 false otherwise. */
11937 move_signature_fn_p (const_tree d
)
11941 bool result
= false;
11943 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11947 arg_type
= TREE_VALUE (args
);
11948 if (arg_type
== error_mark_node
)
11951 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11952 && TYPE_REF_IS_RVALUE (arg_type
)
11953 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11957 args
= TREE_CHAIN (args
);
11959 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11960 /* There are more non-optional args. */
11966 /* Remember any special properties of member function DECL. */
11969 grok_special_member_properties (tree decl
)
11973 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11976 class_type
= DECL_CONTEXT (decl
);
11977 if (DECL_CONSTRUCTOR_P (decl
))
11979 int ctor
= copy_fn_p (decl
);
11981 if (!DECL_ARTIFICIAL (decl
))
11982 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11988 A non-template constructor for class X is a copy
11989 constructor if its first parameter is of type X&, const
11990 X&, volatile X& or const volatile X&, and either there
11991 are no other parameters or else all other parameters have
11992 default arguments. */
11993 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11994 if (user_provided_p (decl
))
11995 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11997 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11999 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
12000 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
12001 else if (move_fn_p (decl
) && user_provided_p (decl
))
12002 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
12003 else if (is_list_ctor (decl
))
12004 TYPE_HAS_LIST_CTOR (class_type
) = 1;
12006 if (DECL_DECLARED_CONSTEXPR_P (decl
)
12007 && !copy_fn_p (decl
) && !move_fn_p (decl
))
12008 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
12010 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
12014 A non-template assignment operator for class X is a copy
12015 assignment operator if its parameter is of type X, X&, const
12016 X&, volatile X& or const volatile X&. */
12018 int assop
= copy_fn_p (decl
);
12022 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
12023 if (user_provided_p (decl
))
12024 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
12026 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
12028 else if (move_fn_p (decl
) && user_provided_p (decl
))
12029 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
12031 /* Destructors are handled in check_methods. */
12034 /* Check a constructor DECL has the correct form. Complains
12035 if the class has a constructor of the form X(X). */
12038 grok_ctor_properties (const_tree ctype
, const_tree decl
)
12040 int ctor_parm
= copy_fn_p (decl
);
12046 A declaration of a constructor for a class X is ill-formed if
12047 its first parameter is of type (optionally cv-qualified) X
12048 and either there are no other parameters or else all other
12049 parameters have default arguments.
12051 We *don't* complain about member template instantiations that
12052 have this form, though; they can occur as we try to decide
12053 what constructor to use during overload resolution. Since
12054 overload resolution will never prefer such a constructor to
12055 the non-template copy constructor (which is either explicitly
12056 or implicitly defined), there's no need to worry about their
12057 existence. Theoretically, they should never even be
12058 instantiated, but that's hard to forestall. */
12059 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
12067 /* An operator with this code is unary, but can also be binary. */
12070 ambi_op_p (enum tree_code code
)
12072 return (code
== INDIRECT_REF
12073 || code
== ADDR_EXPR
12074 || code
== UNARY_PLUS_EXPR
12075 || code
== NEGATE_EXPR
12076 || code
== PREINCREMENT_EXPR
12077 || code
== PREDECREMENT_EXPR
);
12080 /* An operator with this name can only be unary. */
12083 unary_op_p (enum tree_code code
)
12085 return (code
== TRUTH_NOT_EXPR
12086 || code
== BIT_NOT_EXPR
12087 || code
== COMPONENT_REF
12088 || code
== TYPE_EXPR
);
12091 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
12092 errors are issued for invalid declarations. */
12095 grok_op_properties (tree decl
, bool complain
)
12097 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
12099 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
12100 tree name
= DECL_NAME (decl
);
12101 enum tree_code operator_code
;
12106 /* Count the number of arguments and check for ellipsis. */
12107 for (argtype
= argtypes
, arity
= 0;
12108 argtype
&& argtype
!= void_list_node
;
12109 argtype
= TREE_CHAIN (argtype
))
12111 ellipsis_p
= !argtype
;
12113 class_type
= DECL_CONTEXT (decl
);
12114 if (class_type
&& !CLASS_TYPE_P (class_type
))
12115 class_type
= NULL_TREE
;
12117 if (DECL_CONV_FN_P (decl
))
12118 operator_code
= TYPE_EXPR
;
12122 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12123 if (ansi_opname (CODE) == name) \
12125 operator_code = (CODE); \
12128 else if (ansi_assopname (CODE) == name) \
12130 operator_code = (CODE); \
12131 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12135 #include "operators.def"
12136 #undef DEF_OPERATOR
12138 gcc_unreachable ();
12141 gcc_assert (operator_code
!= MAX_TREE_CODES
);
12142 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12145 switch (operator_code
)
12148 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
12152 TYPE_GETS_DELETE (class_type
) |= 1;
12156 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
12159 case VEC_DELETE_EXPR
:
12160 TYPE_GETS_DELETE (class_type
) |= 2;
12167 /* [basic.std.dynamic.allocation]/1:
12169 A program is ill-formed if an allocation function is declared
12170 in a namespace scope other than global scope or declared static
12173 The same also holds true for deallocation functions. */
12174 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
12175 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12177 if (DECL_NAMESPACE_SCOPE_P (decl
))
12179 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
12181 error ("%qD may not be declared within a namespace", decl
);
12184 else if (!TREE_PUBLIC (decl
))
12186 error ("%qD may not be declared as static", decl
);
12192 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12194 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12195 DECL_IS_OPERATOR_NEW (decl
) = 1;
12197 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12198 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12201 /* An operator function must either be a non-static member function
12202 or have at least one parameter of a class, a reference to a class,
12203 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12204 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12206 if (operator_code
== TYPE_EXPR
12207 || operator_code
== CALL_EXPR
12208 || operator_code
== COMPONENT_REF
12209 || operator_code
== ARRAY_REF
12210 || operator_code
== NOP_EXPR
)
12212 error ("%qD must be a nonstatic member function", decl
);
12219 if (DECL_STATIC_FUNCTION_P (decl
))
12221 error ("%qD must be either a non-static member "
12222 "function or a non-member function", decl
);
12226 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
12228 tree arg
= non_reference (TREE_VALUE (p
));
12229 if (arg
== error_mark_node
)
12232 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
12233 because these checks are performed even on
12234 template functions. */
12235 if (MAYBE_CLASS_TYPE_P (arg
)
12236 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
12240 if (!p
|| p
== void_list_node
)
12243 error ("%qD must have an argument of class or "
12244 "enumerated type", decl
);
12250 /* There are no restrictions on the arguments to an overloaded
12252 if (operator_code
== CALL_EXPR
)
12255 /* Warn about conversion operators that will never be used. */
12256 if (IDENTIFIER_TYPENAME_P (name
)
12257 && ! DECL_TEMPLATE_INFO (decl
)
12259 /* Warn only declaring the function; there is no need to
12260 warn again about out-of-class definitions. */
12261 && class_type
== current_class_type
)
12263 tree t
= TREE_TYPE (name
);
12264 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12267 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12269 if (VOID_TYPE_P (t
))
12270 warning (OPT_Wconversion
,
12272 ? G_("conversion to a reference to void "
12273 "will never use a type conversion operator")
12274 : G_("conversion to void "
12275 "will never use a type conversion operator"));
12276 else if (class_type
)
12278 if (t
== class_type
)
12279 warning (OPT_Wconversion
,
12281 ? G_("conversion to a reference to the same type "
12282 "will never use a type conversion operator")
12283 : G_("conversion to the same type "
12284 "will never use a type conversion operator"));
12285 /* Don't force t to be complete here. */
12286 else if (MAYBE_CLASS_TYPE_P (t
)
12287 && COMPLETE_TYPE_P (t
)
12288 && DERIVED_FROM_P (t
, class_type
))
12289 warning (OPT_Wconversion
,
12291 ? G_("conversion to a reference to a base class "
12292 "will never use a type conversion operator")
12293 : G_("conversion to a base class "
12294 "will never use a type conversion operator"));
12299 if (operator_code
== COND_EXPR
)
12302 error ("ISO C++ prohibits overloading operator ?:");
12305 else if (ellipsis_p
)
12307 error ("%qD must not have variable number of arguments", decl
);
12310 else if (ambi_op_p (operator_code
))
12313 /* We pick the one-argument operator codes by default, so
12314 we don't have to change anything. */
12316 else if (arity
== 2)
12318 /* If we thought this was a unary operator, we now know
12319 it to be a binary operator. */
12320 switch (operator_code
)
12323 operator_code
= MULT_EXPR
;
12327 operator_code
= BIT_AND_EXPR
;
12330 case UNARY_PLUS_EXPR
:
12331 operator_code
= PLUS_EXPR
;
12335 operator_code
= MINUS_EXPR
;
12338 case PREINCREMENT_EXPR
:
12339 operator_code
= POSTINCREMENT_EXPR
;
12342 case PREDECREMENT_EXPR
:
12343 operator_code
= POSTDECREMENT_EXPR
;
12347 gcc_unreachable ();
12350 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12352 if ((operator_code
== POSTINCREMENT_EXPR
12353 || operator_code
== POSTDECREMENT_EXPR
)
12354 && ! processing_template_decl
12355 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12358 error ("postfix %qD must take %<int%> as its argument",
12361 error ("postfix %qD must take %<int%> as its second "
12369 error ("%qD must take either zero or one argument", decl
);
12371 error ("%qD must take either one or two arguments", decl
);
12375 /* More Effective C++ rule 6. */
12377 && (operator_code
== POSTINCREMENT_EXPR
12378 || operator_code
== POSTDECREMENT_EXPR
12379 || operator_code
== PREINCREMENT_EXPR
12380 || operator_code
== PREDECREMENT_EXPR
))
12382 tree arg
= TREE_VALUE (argtypes
);
12383 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12384 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12385 arg
= TREE_TYPE (arg
);
12386 arg
= TYPE_MAIN_VARIANT (arg
);
12387 if (operator_code
== PREINCREMENT_EXPR
12388 || operator_code
== PREDECREMENT_EXPR
)
12390 if (TREE_CODE (ret
) != REFERENCE_TYPE
12391 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12393 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
12394 build_reference_type (arg
));
12398 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12399 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
12403 else if (unary_op_p (operator_code
))
12408 error ("%qD must take %<void%>", decl
);
12410 error ("%qD must take exactly one argument", decl
);
12414 else /* if (binary_op_p (operator_code)) */
12419 error ("%qD must take exactly one argument", decl
);
12421 error ("%qD must take exactly two arguments", decl
);
12425 /* More Effective C++ rule 7. */
12427 && (operator_code
== TRUTH_ANDIF_EXPR
12428 || operator_code
== TRUTH_ORIF_EXPR
12429 || operator_code
== COMPOUND_EXPR
))
12430 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
12434 /* Effective C++ rule 23. */
12437 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
12438 && (operator_code
== PLUS_EXPR
12439 || operator_code
== MINUS_EXPR
12440 || operator_code
== TRUNC_DIV_EXPR
12441 || operator_code
== MULT_EXPR
12442 || operator_code
== TRUNC_MOD_EXPR
)
12443 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12444 warning (OPT_Weffc__
, "%qD should return by value", decl
);
12446 /* [over.oper]/8 */
12447 for (; argtypes
&& argtypes
!= void_list_node
;
12448 argtypes
= TREE_CHAIN (argtypes
))
12449 if (TREE_PURPOSE (argtypes
))
12451 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12452 if (operator_code
== POSTINCREMENT_EXPR
12453 || operator_code
== POSTDECREMENT_EXPR
)
12455 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
12460 error ("%qD cannot have default arguments", decl
);
12468 /* Return a string giving the keyword associate with CODE. */
12470 static const char *
12471 tag_name (enum tag_types code
)
12483 case typename_type
:
12486 gcc_unreachable ();
12490 /* Name lookup in an elaborated-type-specifier (after the keyword
12491 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12492 elaborated-type-specifier is invalid, issue a diagnostic and return
12493 error_mark_node; otherwise, return the *_TYPE to which it referred.
12494 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12497 check_elaborated_type_specifier (enum tag_types tag_code
,
12499 bool allow_template_p
)
12505 struct S { struct S *p; };
12507 name lookup will find the TYPE_DECL for the implicit "S::S"
12508 typedef. Adjust for that here. */
12509 if (DECL_SELF_REFERENCE_P (decl
))
12510 decl
= TYPE_NAME (TREE_TYPE (decl
));
12512 type
= TREE_TYPE (decl
);
12514 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12515 is false for this case as well. */
12516 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12518 error ("using template type parameter %qT after %qs",
12519 type
, tag_name (tag_code
));
12520 return error_mark_node
;
12522 /* Accept template template parameters. */
12523 else if (allow_template_p
12524 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
12525 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
12529 If the identifier resolves to a typedef-name or the
12530 simple-template-id resolves to an alias template
12531 specialization, the elaborated-type-specifier is ill-formed.
12533 In other words, the only legitimate declaration to use in the
12534 elaborated type specifier is the implicit typedef created when
12535 the type is declared. */
12536 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
12537 && !DECL_SELF_REFERENCE_P (decl
)
12538 && tag_code
!= typename_type
)
12540 if (alias_template_specialization_p (type
))
12541 error ("using alias template specialization %qT after %qs",
12542 type
, tag_name (tag_code
));
12544 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
12545 inform (DECL_SOURCE_LOCATION (decl
),
12546 "%qD has a previous declaration here", decl
);
12547 return error_mark_node
;
12549 else if (TREE_CODE (type
) != RECORD_TYPE
12550 && TREE_CODE (type
) != UNION_TYPE
12551 && tag_code
!= enum_type
12552 && tag_code
!= typename_type
)
12554 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
12555 inform (location_of (type
), "%qT has a previous declaration here", type
);
12556 return error_mark_node
;
12558 else if (TREE_CODE (type
) != ENUMERAL_TYPE
12559 && tag_code
== enum_type
)
12561 error ("%qT referred to as enum", type
);
12562 inform (location_of (type
), "%qT has a previous declaration here", type
);
12563 return error_mark_node
;
12565 else if (!allow_template_p
12566 && TREE_CODE (type
) == RECORD_TYPE
12567 && CLASSTYPE_IS_TEMPLATE (type
))
12569 /* If a class template appears as elaborated type specifier
12570 without a template header such as:
12572 template <class T> class C {};
12573 void f(class C); // No template header here
12575 then the required template argument is missing. */
12576 error ("template argument required for %<%s %T%>",
12577 tag_name (tag_code
),
12578 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
12579 return error_mark_node
;
12585 /* Lookup NAME in elaborate type specifier in scope according to
12586 SCOPE and issue diagnostics if necessary.
12587 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12588 found, and ERROR_MARK_NODE for type error. */
12591 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
12592 tag_scope scope
, bool template_header_p
)
12596 if (scope
== ts_global
)
12598 /* First try ordinary name lookup, ignoring hidden class name
12599 injected via friend declaration. */
12600 decl
= lookup_name_prefer_type (name
, 2);
12601 decl
= strip_using_decl (decl
);
12602 /* If that fails, the name will be placed in the smallest
12603 non-class, non-function-prototype scope according to 3.3.1/5.
12604 We may already have a hidden name declared as friend in this
12605 scope. So lookup again but not ignoring hidden names.
12606 If we find one, that name will be made visible rather than
12607 creating a new tag. */
12609 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
12612 decl
= lookup_type_scope (name
, scope
);
12615 && (DECL_CLASS_TEMPLATE_P (decl
)
12616 /* If scope is ts_current we're defining a class, so ignore a
12617 template template parameter. */
12618 || (scope
!= ts_current
12619 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
12620 decl
= DECL_TEMPLATE_RESULT (decl
);
12622 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
12624 /* Look for invalid nested type:
12628 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
12630 error ("%qD has the same name as the class in which it is "
12633 return error_mark_node
;
12636 /* Two cases we need to consider when deciding if a class
12637 template is allowed as an elaborated type specifier:
12638 1. It is a self reference to its own class.
12639 2. It comes with a template header.
12643 template <class T> class C {
12644 class C *c1; // DECL_SELF_REFERENCE_P is true
12647 template <class U> class C; // template_header_p is true
12648 template <class T> class C<T>::D {
12649 class C *c2; // DECL_SELF_REFERENCE_P is true
12652 t
= check_elaborated_type_specifier (tag_code
,
12655 | DECL_SELF_REFERENCE_P (decl
));
12656 if (template_header_p
&& t
&& CLASS_TYPE_P (t
)
12657 && (!CLASSTYPE_TEMPLATE_INFO (t
)
12658 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))))
12660 error ("%qT is not a template", t
);
12661 inform (location_of (t
), "previous declaration here");
12662 if (TYPE_CLASS_SCOPE_P (t
)
12663 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t
)))
12664 inform (input_location
,
12665 "perhaps you want to explicitly add %<%T::%>",
12667 t
= error_mark_node
;
12672 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12674 error ("reference to %qD is ambiguous", name
);
12675 print_candidates (decl
);
12676 return error_mark_node
;
12682 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12683 Define the tag as a forward-reference if it is not defined.
12685 If a declaration is given, process it here, and report an error if
12686 multiple declarations are not identical.
12688 SCOPE is TS_CURRENT when this is also a definition. Only look in
12689 the current frame for the name (since C++ allows new names in any
12690 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12691 declaration. Only look beginning from the current scope outward up
12692 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12694 TEMPLATE_HEADER_P is true when this declaration is preceded by
12695 a set of template parameters. */
12698 xref_tag_1 (enum tag_types tag_code
, tree name
,
12699 tag_scope orig_scope
, bool template_header_p
)
12701 enum tree_code code
;
12703 tree context
= NULL_TREE
;
12706 gcc_assert (identifier_p (name
));
12712 code
= RECORD_TYPE
;
12718 code
= ENUMERAL_TYPE
;
12721 gcc_unreachable ();
12724 if (orig_scope
== ts_lambda
)
12725 scope
= ts_current
;
12727 scope
= orig_scope
;
12729 /* In case of anonymous name, xref_tag is only called to
12730 make type node and push name. Name lookup is not required. */
12731 if (anon_aggrname_p (name
))
12734 t
= lookup_and_check_tag (tag_code
, name
,
12735 scope
, template_header_p
);
12737 if (t
== error_mark_node
)
12738 return error_mark_node
;
12740 if (scope
!= ts_current
&& t
&& current_class_type
12741 && template_class_depth (current_class_type
)
12742 && template_header_p
)
12744 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12747 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12748 definition of this tag. Since, in addition, we are currently
12749 processing a (member) template declaration of a template
12750 class, we must be very careful; consider:
12757 { template <class V>
12758 friend struct S1; };
12760 Here, the S2::S1 declaration should not be confused with the
12761 outer declaration. In particular, the inner version should
12762 have a template parameter of level 2, not level 1. This
12763 would be particularly important if the member declaration
12766 template <class V = U> friend struct S1;
12768 say, when we should tsubst into `U' when instantiating
12769 S2. On the other hand, when presented with:
12779 we must find the inner binding eventually. We
12780 accomplish this by making sure that the new type we
12781 create to represent this declaration has the right
12783 context
= TYPE_CONTEXT (t
);
12789 /* If no such tag is yet defined, create a forward-reference node
12790 and record it as the "definition".
12791 When a real declaration of this type is found,
12792 the forward-reference will be altered into a real type. */
12793 if (code
== ENUMERAL_TYPE
)
12795 error ("use of enum %q#D without previous declaration", name
);
12796 return error_mark_node
;
12800 t
= make_class_type (code
);
12801 TYPE_CONTEXT (t
) = context
;
12802 if (orig_scope
== ts_lambda
)
12803 /* Remember that we're declaring a lambda to avoid bogus errors
12804 in push_template_decl. */
12805 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12806 t
= pushtag (name
, t
, scope
);
12811 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12813 /* Check that we aren't trying to overload a class with different
12815 tree constr
= NULL_TREE
;
12816 if (current_template_parms
)
12818 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
12819 constr
= build_constraints (reqs
, NULL_TREE
);
12821 if (!redeclare_class_template (t
, current_template_parms
, constr
))
12822 return error_mark_node
;
12824 else if (!processing_template_decl
12825 && CLASS_TYPE_P (t
)
12826 && CLASSTYPE_IS_TEMPLATE (t
))
12828 error ("redeclaration of %qT as a non-template", t
);
12829 inform (location_of (t
), "previous declaration %qD", t
);
12830 return error_mark_node
;
12833 /* Make injected friend class visible. */
12834 if (scope
!= ts_within_enclosing_non_class
12835 && hidden_name_p (TYPE_NAME (t
)))
12837 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12838 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12840 if (TYPE_TEMPLATE_INFO (t
))
12842 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12843 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12851 /* Wrapper for xref_tag_1. */
12854 xref_tag (enum tag_types tag_code
, tree name
,
12855 tag_scope scope
, bool template_header_p
)
12859 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12860 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12861 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12867 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12869 enum tag_types tag_kind
;
12871 if (TREE_CODE (old
) == RECORD_TYPE
)
12872 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12874 tag_kind
= union_type
;
12876 if (id
== NULL_TREE
)
12877 id
= TYPE_IDENTIFIER (old
);
12879 return xref_tag (tag_kind
, id
, scope
, false);
12882 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12883 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12884 access_* node, and the TREE_VALUE is the type of the base-class.
12885 Non-NULL TREE_TYPE indicates virtual inheritance. */
12888 xref_basetypes (tree ref
, tree base_list
)
12891 tree binfo
, base_binfo
;
12892 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12893 unsigned max_bases
= 0; /* Maximum direct bases. */
12894 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
12896 tree default_access
;
12897 tree igo_prev
; /* Track Inheritance Graph Order. */
12899 if (ref
== error_mark_node
)
12902 /* The base of a derived class is private by default, all others are
12904 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12905 && CLASSTYPE_DECLARED_CLASS (ref
)
12906 ? access_private_node
: access_public_node
);
12908 /* First, make sure that any templates in base-classes are
12909 instantiated. This ensures that if we call ourselves recursively
12910 we do not get confused about which classes are marked and which
12912 basep
= &base_list
;
12915 tree basetype
= TREE_VALUE (*basep
);
12917 /* The dependent_type_p call below should really be dependent_scope_p
12918 so that we give a hard error about using an incomplete type as a
12919 base, but we allow it with a pedwarn for backward
12921 if (processing_template_decl
12922 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12923 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12924 if (!dependent_type_p (basetype
)
12925 && !complete_type_or_else (basetype
, NULL
))
12926 /* An incomplete type. Remove it from the list. */
12927 *basep
= TREE_CHAIN (*basep
);
12931 if (TREE_TYPE (*basep
))
12933 if (CLASS_TYPE_P (basetype
))
12934 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12935 basep
= &TREE_CHAIN (*basep
);
12938 max_vbases
+= max_dvbases
;
12940 TYPE_MARKED_P (ref
) = 1;
12942 /* The binfo slot should be empty, unless this is an (ill-formed)
12944 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
12946 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12948 binfo
= make_tree_binfo (max_bases
);
12950 TYPE_BINFO (ref
) = binfo
;
12951 BINFO_OFFSET (binfo
) = size_zero_node
;
12952 BINFO_TYPE (binfo
) = ref
;
12954 /* Apply base-class info set up to the variants of this type. */
12955 fixup_type_variants (ref
);
12959 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12960 /* An aggregate cannot have baseclasses. */
12961 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12963 if (TREE_CODE (ref
) == UNION_TYPE
)
12964 error ("derived union %qT invalid", ref
);
12969 if (TYPE_FOR_JAVA (ref
))
12970 error ("Java class %qT cannot have multiple bases", ref
);
12972 warning (OPT_Wmultiple_inheritance
,
12973 "%qT defined with multiple direct bases", ref
);
12978 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12980 if (TYPE_FOR_JAVA (ref
))
12981 error ("Java class %qT cannot have virtual bases", ref
);
12982 else if (max_dvbases
)
12983 warning (OPT_Wvirtual_inheritance
,
12984 "%qT defined with direct virtual base", ref
);
12987 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12989 tree access
= TREE_PURPOSE (base_list
);
12990 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12991 tree basetype
= TREE_VALUE (base_list
);
12993 if (access
== access_default_node
)
12994 access
= default_access
;
12996 if (PACK_EXPANSION_P (basetype
))
12997 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12998 if (TREE_CODE (basetype
) == TYPE_DECL
)
12999 basetype
= TREE_TYPE (basetype
);
13000 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
13002 error ("base type %qT fails to be a struct or class type",
13007 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
13008 TYPE_FOR_JAVA (ref
) = 1;
13010 base_binfo
= NULL_TREE
;
13011 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
13013 base_binfo
= TYPE_BINFO (basetype
);
13014 /* The original basetype could have been a typedef'd type. */
13015 basetype
= BINFO_TYPE (base_binfo
);
13017 /* Inherit flags from the base. */
13018 TYPE_HAS_NEW_OPERATOR (ref
)
13019 |= TYPE_HAS_NEW_OPERATOR (basetype
);
13020 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
13021 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
13022 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
13023 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
13024 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
13025 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
13026 CLASSTYPE_REPEATED_BASE_P (ref
)
13027 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
13030 /* We must do this test after we've seen through a typedef
13032 if (TYPE_MARKED_P (basetype
))
13034 if (basetype
== ref
)
13035 error ("recursive type %qT undefined", basetype
);
13037 error ("duplicate base type %qT invalid", basetype
);
13041 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
13042 /* Regenerate the pack expansion for the bases. */
13043 basetype
= make_pack_expansion (basetype
);
13045 TYPE_MARKED_P (basetype
) = 1;
13047 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
13048 &igo_prev
, via_virtual
);
13049 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
13050 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
13052 BINFO_BASE_APPEND (binfo
, base_binfo
);
13053 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
13057 /* Update max_vbases to reflect the reality that we are dropping
13058 this base: if it reaches zero we want to undo the vec_alloc
13059 above to avoid inconsistencies during error-recovery: eg, in
13060 build_special_member_call, CLASSTYPE_VBASECLASSES non null
13061 and vtt null (c++/27952). */
13064 if (CLASS_TYPE_P (basetype
))
13066 -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
13069 if (CLASSTYPE_VBASECLASSES (ref
)
13070 && max_vbases
== 0)
13071 vec_free (CLASSTYPE_VBASECLASSES (ref
));
13073 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
13074 /* If we didn't get max_vbases vbases, we must have shared at
13075 least one of them, and are therefore diamond shaped. */
13076 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
13078 /* Unmark all the types. */
13079 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
13080 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13081 TYPE_MARKED_P (ref
) = 0;
13083 /* Now see if we have a repeated base type. */
13084 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
13086 for (base_binfo
= binfo
; base_binfo
;
13087 base_binfo
= TREE_CHAIN (base_binfo
))
13089 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13091 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
13094 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
13096 for (base_binfo
= binfo
; base_binfo
;
13097 base_binfo
= TREE_CHAIN (base_binfo
))
13098 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
13099 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
13106 /* Copies the enum-related properties from type SRC to type DST.
13107 Used with the underlying type of an enum and the enum itself. */
13109 copy_type_enum (tree dst
, tree src
)
13112 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
13114 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
13115 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
13116 TYPE_SIZE (t
) = TYPE_SIZE (src
);
13117 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
13118 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
13119 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
13120 unsigned valign
= TYPE_ALIGN (src
);
13121 if (TYPE_USER_ALIGN (t
))
13122 valign
= MAX (valign
, TYPE_ALIGN (t
));
13124 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
13125 SET_TYPE_ALIGN (t
, valign
);
13126 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
13130 /* Begin compiling the definition of an enumeration type.
13133 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
13135 UNDERLYING_TYPE is the type that will be used as the storage for
13136 the enumeration type. This should be NULL_TREE if no storage type
13139 ATTRIBUTES are any attributes specified after the enum-key.
13141 SCOPED_ENUM_P is true if this is a scoped enumeration type.
13143 if IS_NEW is not NULL, gets TRUE iff a new type is created.
13145 Returns the type object, as yet incomplete.
13146 Also records info about it so that build_enumerator
13147 may be used to declare the individual values as they are read. */
13150 start_enum (tree name
, tree enumtype
, tree underlying_type
,
13151 tree attributes
, bool scoped_enum_p
, bool *is_new
)
13153 tree prevtype
= NULL_TREE
;
13154 gcc_assert (identifier_p (name
));
13158 /* [C++0x dcl.enum]p5:
13160 If not explicitly specified, the underlying type of a scoped
13161 enumeration type is int. */
13162 if (!underlying_type
&& scoped_enum_p
)
13163 underlying_type
= integer_type_node
;
13165 if (underlying_type
)
13166 underlying_type
= cv_unqualified (underlying_type
);
13168 /* If this is the real definition for a previous forward reference,
13169 fill in the contents in the same object that used to be the
13170 forward reference. */
13172 enumtype
= lookup_and_check_tag (enum_type
, name
,
13173 /*tag_scope=*/ts_current
,
13174 /*template_header_p=*/false);
13176 /* In case of a template_decl, the only check that should be deferred
13177 to instantiation time is the comparison of underlying types. */
13178 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13180 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
13182 error_at (input_location
, "scoped/unscoped mismatch "
13183 "in enum %q#T", enumtype
);
13184 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13185 "previous definition here");
13186 enumtype
= error_mark_node
;
13188 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
13190 error_at (input_location
, "underlying type mismatch "
13191 "in enum %q#T", enumtype
);
13192 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13193 "previous definition here");
13194 enumtype
= error_mark_node
;
13196 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
13197 && !dependent_type_p (underlying_type
)
13198 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
13199 && !same_type_p (underlying_type
,
13200 ENUM_UNDERLYING_TYPE (enumtype
)))
13202 error_at (input_location
, "different underlying type "
13203 "in enum %q#T", enumtype
);
13204 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13205 "previous definition here");
13206 underlying_type
= NULL_TREE
;
13210 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
13211 || processing_template_decl
)
13213 /* In case of error, make a dummy enum to allow parsing to
13215 if (enumtype
== error_mark_node
)
13217 name
= make_anon_name ();
13218 enumtype
= NULL_TREE
;
13221 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
13222 of an opaque enum, or an opaque enum of an already defined
13223 enumeration (C++0x only).
13224 In any other case, it'll be NULL_TREE. */
13230 prevtype
= enumtype
;
13232 /* Do not push the decl more than once, unless we need to
13233 compare underlying types at instantiation time */
13235 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
13236 || (underlying_type
13237 && dependent_type_p (underlying_type
))
13238 || (ENUM_UNDERLYING_TYPE (enumtype
)
13239 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
13241 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
13242 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
13245 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
13248 if (enumtype
== error_mark_node
)
13249 return error_mark_node
;
13251 /* The enum is considered opaque until the opening '{' of the
13252 enumerator list. */
13253 SET_OPAQUE_ENUM_P (enumtype
, true);
13254 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
13257 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
13259 cplus_decl_attributes (&enumtype
, attributes
, (int)ATTR_FLAG_TYPE_IN_PLACE
);
13261 if (underlying_type
)
13263 if (ENUM_UNDERLYING_TYPE (enumtype
))
13264 /* We already checked that it matches, don't change it to a different
13265 typedef variant. */;
13266 else if (CP_INTEGRAL_TYPE_P (underlying_type
))
13268 copy_type_enum (enumtype
, underlying_type
);
13269 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13271 else if (dependent_type_p (underlying_type
))
13272 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13274 error ("underlying type %<%T%> of %<%T%> must be an integral type",
13275 underlying_type
, enumtype
);
13278 /* If into a template class, the returned enum is always the first
13279 declaration (opaque or not) seen. This way all the references to
13280 this type will be to the same declaration. The following ones are used
13281 only to check for definition errors. */
13282 if (prevtype
&& processing_template_decl
)
13288 /* After processing and defining all the values of an enumeration type,
13289 install their decls in the enumeration type.
13290 ENUMTYPE is the type object. */
13293 finish_enum_value_list (tree enumtype
)
13296 tree underlying_type
;
13299 tree minnode
, maxnode
;
13302 bool fixed_underlying_type_p
13303 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
13305 /* We built up the VALUES in reverse order. */
13306 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
13308 /* For an enum defined in a template, just set the type of the values;
13309 all further processing is postponed until the template is
13310 instantiated. We need to set the type so that tsubst of a CONST_DECL
13312 if (processing_template_decl
)
13314 for (values
= TYPE_VALUES (enumtype
);
13316 values
= TREE_CHAIN (values
))
13317 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
13321 /* Determine the minimum and maximum values of the enumerators. */
13322 if (TYPE_VALUES (enumtype
))
13324 minnode
= maxnode
= NULL_TREE
;
13326 for (values
= TYPE_VALUES (enumtype
);
13328 values
= TREE_CHAIN (values
))
13330 decl
= TREE_VALUE (values
);
13332 /* [dcl.enum]: Following the closing brace of an enum-specifier,
13333 each enumerator has the type of its enumeration. Prior to the
13334 closing brace, the type of each enumerator is the type of its
13335 initializing value. */
13336 TREE_TYPE (decl
) = enumtype
;
13338 /* Update the minimum and maximum values, if appropriate. */
13339 value
= DECL_INITIAL (decl
);
13340 if (value
== error_mark_node
)
13341 value
= integer_zero_node
;
13342 /* Figure out what the minimum and maximum values of the
13343 enumerators are. */
13345 minnode
= maxnode
= value
;
13346 else if (tree_int_cst_lt (maxnode
, value
))
13348 else if (tree_int_cst_lt (value
, minnode
))
13355 If the enumerator-list is empty, the underlying type is as if
13356 the enumeration had a single enumerator with value 0. */
13357 minnode
= maxnode
= integer_zero_node
;
13359 if (!fixed_underlying_type_p
)
13361 /* Compute the number of bits require to represent all values of the
13362 enumeration. We must do this before the type of MINNODE and
13363 MAXNODE are transformed, since tree_int_cst_min_precision relies
13364 on the TREE_TYPE of the value it is passed. */
13365 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
13366 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
13367 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
13368 int precision
= MAX (lowprec
, highprec
);
13370 bool use_short_enum
;
13372 /* Determine the underlying type of the enumeration.
13376 The underlying type of an enumeration is an integral type that
13377 can represent all the enumerator values defined in the
13378 enumeration. It is implementation-defined which integral type is
13379 used as the underlying type for an enumeration except that the
13380 underlying type shall not be larger than int unless the value of
13381 an enumerator cannot fit in an int or unsigned int.
13383 We use "int" or an "unsigned int" as the underlying type, even if
13384 a smaller integral type would work, unless the user has
13385 explicitly requested that we use the smallest possible type. The
13386 user can request that for all enumerations with a command line
13387 flag, or for just one enumeration with an attribute. */
13389 use_short_enum
= flag_short_enums
13390 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
13392 /* If the precision of the type was specified with an attribute and it
13393 was too small, give an error. Otherwise, use it. */
13394 if (TYPE_PRECISION (enumtype
))
13396 if (precision
> TYPE_PRECISION (enumtype
))
13397 error ("specified mode too small for enumeral values");
13400 use_short_enum
= true;
13401 precision
= TYPE_PRECISION (enumtype
);
13405 for (itk
= (use_short_enum
? itk_char
: itk_int
);
13409 underlying_type
= integer_types
[itk
];
13410 if (underlying_type
!= NULL_TREE
13411 && TYPE_PRECISION (underlying_type
) >= precision
13412 && TYPE_SIGN (underlying_type
) == sgn
)
13415 if (itk
== itk_none
)
13419 IF no integral type can represent all the enumerator values, the
13420 enumeration is ill-formed. */
13421 error ("no integral type can represent all of the enumerator values "
13422 "for %qT", enumtype
);
13423 precision
= TYPE_PRECISION (long_long_integer_type_node
);
13424 underlying_type
= integer_types
[itk_unsigned_long_long
];
13429 The value of sizeof() applied to an enumeration type, an object
13430 of an enumeration type, or an enumerator, is the value of sizeof()
13431 applied to the underlying type. */
13432 copy_type_enum (enumtype
, underlying_type
);
13434 /* Compute the minimum and maximum values for the type.
13438 For an enumeration where emin is the smallest enumerator and emax
13439 is the largest, the values of the enumeration are the values of the
13440 underlying type in the range bmin to bmax, where bmin and bmax are,
13441 respectively, the smallest and largest values of the smallest bit-
13442 field that can store emin and emax. */
13444 /* The middle-end currently assumes that types with TYPE_PRECISION
13445 narrower than their underlying type are suitably zero or sign
13446 extended to fill their mode. Similarly, it assumes that the front
13447 end assures that a value of a particular type must be within
13448 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
13450 We used to set these fields based on bmin and bmax, but that led
13451 to invalid assumptions like optimizing away bounds checking. So
13452 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
13453 TYPE_MAX_VALUE to the values for the mode above and only restrict
13454 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
13455 ENUM_UNDERLYING_TYPE (enumtype
)
13456 = build_distinct_type_copy (underlying_type
);
13457 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
13458 set_min_and_max_values_for_integral_type
13459 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
13461 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
13462 if (flag_strict_enums
)
13463 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
13466 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
13468 /* Convert each of the enumerators to the type of the underlying
13469 type of the enumeration. */
13470 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13472 location_t saved_location
;
13474 decl
= TREE_VALUE (values
);
13475 saved_location
= input_location
;
13476 input_location
= DECL_SOURCE_LOCATION (decl
);
13477 if (fixed_underlying_type_p
)
13478 /* If the enumeration type has a fixed underlying type, we
13479 already checked all of the enumerator values. */
13480 value
= DECL_INITIAL (decl
);
13482 value
= perform_implicit_conversion (underlying_type
,
13483 DECL_INITIAL (decl
),
13484 tf_warning_or_error
);
13485 input_location
= saved_location
;
13487 /* Do not clobber shared ints. */
13488 value
= copy_node (value
);
13490 TREE_TYPE (value
) = enumtype
;
13491 DECL_INITIAL (decl
) = value
;
13494 /* Fix up all variant types of this enum type. */
13495 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
13496 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
13498 if (at_class_scope_p ()
13499 && COMPLETE_TYPE_P (current_class_type
)
13500 && UNSCOPED_ENUM_P (enumtype
))
13501 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
13502 current_class_type
);
13504 /* Finish debugging output for this type. */
13505 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13507 /* Each enumerator now has the type of its enumeration. Clear the cache
13508 so that this change in types doesn't confuse us later on. */
13509 clear_cv_and_fold_caches ();
13512 /* Finishes the enum type. This is called only the first time an
13513 enumeration is seen, be it opaque or odinary.
13514 ENUMTYPE is the type object. */
13517 finish_enum (tree enumtype
)
13519 if (processing_template_decl
)
13521 if (at_function_scope_p ())
13522 add_stmt (build_min (TAG_DEFN
, enumtype
));
13526 /* If this is a forward declaration, there should not be any variants,
13527 though we can get a variant in the middle of an enum-specifier with
13528 wacky code like 'enum E { e = sizeof(const E*) };' */
13529 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
13530 && (TYPE_VALUES (enumtype
)
13531 || !TYPE_NEXT_VARIANT (enumtype
)));
13534 /* Build and install a CONST_DECL for an enumeration constant of the
13535 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13536 Apply ATTRIBUTES if available. LOC is the location of NAME.
13537 Assignment of sequential values by default is handled here. */
13540 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
13547 /* scalar_constant_value will pull out this expression, so make sure
13548 it's folded as appropriate. */
13549 if (processing_template_decl
)
13550 value
= fold_non_dependent_expr (value
);
13552 /* If the VALUE was erroneous, pretend it wasn't there; that will
13553 result in the enum being assigned the next value in sequence. */
13554 if (value
== error_mark_node
)
13557 /* Remove no-op casts from the value. */
13559 STRIP_TYPE_NOPS (value
);
13561 if (! processing_template_decl
)
13563 /* Validate and default VALUE. */
13564 if (value
!= NULL_TREE
)
13566 if (!ENUM_UNDERLYING_TYPE (enumtype
))
13568 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
13573 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
13574 (TREE_TYPE (value
)))
13575 value
= perform_implicit_conversion_flags
13576 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
13577 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
13579 if (value
== error_mark_node
)
13582 if (value
!= NULL_TREE
)
13584 value
= cxx_constant_value (value
);
13586 if (TREE_CODE (value
) != INTEGER_CST
13587 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13589 error ("enumerator value for %qD is not an integer constant",
13596 /* Default based on previous value. */
13597 if (value
== NULL_TREE
)
13599 if (TYPE_VALUES (enumtype
))
13604 /* C++03 7.2/4: If no initializer is specified for the first
13605 enumerator, the type is an unspecified integral
13606 type. Otherwise the type is the same as the type of the
13607 initializing value of the preceding enumerator unless the
13608 incremented value is not representable in that type, in
13609 which case the type is an unspecified integral type
13610 sufficient to contain the incremented value. */
13611 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13612 if (error_operand_p (prev_value
))
13613 value
= error_mark_node
;
13616 tree type
= TREE_TYPE (prev_value
);
13617 signop sgn
= TYPE_SIGN (type
);
13618 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
13622 bool pos
= !wi::neg_p (wi
, sgn
);
13623 if (!wi::fits_to_tree_p (wi
, type
))
13626 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
13628 type
= integer_types
[itk
];
13629 if (type
!= NULL_TREE
13630 && (pos
|| !TYPE_UNSIGNED (type
))
13631 && wi::fits_to_tree_p (wi
, type
))
13634 if (type
&& cxx_dialect
< cxx11
13635 && itk
> itk_unsigned_long
)
13636 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
13637 incremented enumerator value is too large for %<unsigned long%>" : "\
13638 incremented enumerator value is too large for %<long%>");
13640 if (type
== NULL_TREE
)
13643 value
= wide_int_to_tree (type
, wi
);
13648 error ("overflow in enumeration values at %qD", name
);
13649 value
= error_mark_node
;
13654 value
= integer_zero_node
;
13657 /* Remove no-op casts from the value. */
13658 STRIP_TYPE_NOPS (value
);
13660 /* If the underlying type of the enum is fixed, check whether
13661 the enumerator values fits in the underlying type. If it
13662 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13663 if (ENUM_UNDERLYING_TYPE (enumtype
)
13665 && TREE_CODE (value
) == INTEGER_CST
)
13667 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
13668 error ("enumerator value %E is outside the range of underlying "
13669 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
13671 /* Convert the value to the appropriate type. */
13672 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
13676 /* C++ associates enums with global, function, or class declarations. */
13677 context
= current_scope ();
13679 /* Build the actual enumeration constant. Note that the enumeration
13680 constants have the underlying type of the enum (if it is fixed)
13681 or the type of their initializer (if the underlying type of the
13682 enum is not fixed):
13686 If the underlying type is fixed, the type of each enumerator
13687 prior to the closing brace is the underlying type; if the
13688 initializing value of an enumerator cannot be represented by
13689 the underlying type, the program is ill-formed. If the
13690 underlying type is not fixed, the type of each enumerator is
13691 the type of its initializing value.
13693 If the underlying type is not fixed, it will be computed by
13694 finish_enum and we will reset the type of this enumerator. Of
13695 course, if we're processing a template, there may be no value. */
13696 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13698 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
13700 DECL_CONTEXT (decl
) = enumtype
;
13701 TREE_CONSTANT (decl
) = 1;
13702 TREE_READONLY (decl
) = 1;
13703 DECL_INITIAL (decl
) = value
;
13706 cplus_decl_attributes (&decl
, attributes
, 0);
13708 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
13710 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13711 on the TYPE_FIELDS list for `S'. (That's so that you can say
13712 things like `S::i' later.) */
13714 /* The enumerator may be getting declared outside of its enclosing
13717 class S { public: enum E : int; }; enum S::E : int { i = 7; };
13719 For which case we need to make sure that the access of `S::i'
13720 matches the access of `S::E'. */
13721 tree saved_cas
= current_access_specifier
;
13722 if (TREE_PRIVATE (TYPE_NAME (enumtype
)))
13723 current_access_specifier
= access_private_node
;
13724 else if (TREE_PROTECTED (TYPE_NAME (enumtype
)))
13725 current_access_specifier
= access_protected_node
;
13727 current_access_specifier
= access_public_node
;
13729 finish_member_declaration (decl
);
13731 current_access_specifier
= saved_cas
;
13736 /* Add this enumeration constant to the list for this type. */
13737 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13740 /* Look for an enumerator with the given NAME within the enumeration
13741 type ENUMTYPE. This routine is used primarily for qualified name
13742 lookup into an enumerator in C++0x, e.g.,
13744 enum class Color { Red, Green, Blue };
13746 Color color = Color::Red;
13748 Returns the value corresponding to the enumerator, or
13749 NULL_TREE if no such enumerator was found. */
13751 lookup_enumerator (tree enumtype
, tree name
)
13754 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13756 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13757 return e
? TREE_VALUE (e
) : NULL_TREE
;
13761 /* We're defining DECL. Make sure that its type is OK. */
13764 check_function_type (tree decl
, tree current_function_parms
)
13766 tree fntype
= TREE_TYPE (decl
);
13767 tree return_type
= complete_type (TREE_TYPE (fntype
));
13769 /* In a function definition, arg types must be complete. */
13770 require_complete_types_for_parms (current_function_parms
);
13772 if (dependent_type_p (return_type
)
13773 || type_uses_auto (return_type
))
13775 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13776 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13778 tree args
= TYPE_ARG_TYPES (fntype
);
13780 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13781 error ("return type %q#T is incomplete", return_type
);
13783 error ("return type has Java class type %q#T", return_type
);
13785 /* Make it return void instead. */
13786 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13787 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13789 TREE_CHAIN (args
));
13791 fntype
= build_function_type (void_type_node
, args
);
13793 = build_exception_variant (fntype
,
13794 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13795 fntype
= (cp_build_type_attribute_variant
13796 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13797 TREE_TYPE (decl
) = fntype
;
13800 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13803 /* True iff FN is an implicitly-defined default constructor. */
13806 implicit_default_ctor_p (tree fn
)
13808 return (DECL_CONSTRUCTOR_P (fn
)
13809 && !user_provided_p (fn
)
13810 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
13813 /* Clobber the contents of *this to let the back end know that the object
13814 storage is dead when we enter the constructor or leave the destructor. */
13817 build_clobber_this ()
13819 /* Clobbering an empty base is pointless, and harmful if its one byte
13820 TYPE_SIZE overlays real data. */
13821 if (is_empty_class (current_class_type
))
13824 /* If we have virtual bases, clobber the whole object, but only if we're in
13825 charge. If we don't have virtual bases, clobber the as-base type so we
13826 don't mess with tail padding. */
13827 bool vbases
= CLASSTYPE_VBASECLASSES (current_class_type
);
13829 tree ctype
= current_class_type
;
13831 ctype
= CLASSTYPE_AS_BASE (ctype
);
13833 tree clobber
= build_constructor (ctype
, NULL
);
13834 TREE_THIS_VOLATILE (clobber
) = true;
13836 tree thisref
= current_class_ref
;
13837 if (ctype
!= current_class_type
)
13839 thisref
= build_nop (build_reference_type (ctype
), current_class_ptr
);
13840 thisref
= convert_from_reference (thisref
);
13843 tree exprstmt
= build2 (MODIFY_EXPR
, void_type_node
, thisref
, clobber
);
13845 exprstmt
= build_if_in_charge (exprstmt
);
13850 /* Create the FUNCTION_DECL for a function definition.
13851 DECLSPECS and DECLARATOR are the parts of the declaration;
13852 they describe the function's name and the type it returns,
13853 but twisted together in a fashion that parallels the syntax of C.
13855 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13856 DECLARATOR is really the DECL for the function we are about to
13857 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13858 indicating that the function is an inline defined in-class.
13860 This function creates a binding context for the function body
13861 as well as setting up the FUNCTION_DECL in current_function_decl.
13863 For C++, we must first check whether that datum makes any sense.
13864 For example, "class A local_a(1,2);" means that variable local_a
13865 is an aggregate of type A, which should have a constructor
13866 applied to it with the argument list [1, 2].
13868 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13869 or may be a BLOCK if the function has been defined previously
13870 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13871 error_mark_node if the function has never been defined, or
13872 a BLOCK if the function has been defined somewhere. */
13875 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13877 tree ctype
= NULL_TREE
;
13880 int doing_friend
= 0;
13881 cp_binding_level
*bl
;
13882 tree current_function_parms
;
13883 struct c_fileinfo
*finfo
13884 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13885 bool honor_interface
;
13887 /* Sanity check. */
13888 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13889 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13891 fntype
= TREE_TYPE (decl1
);
13892 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13893 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13895 /* ISO C++ 11.4/5. A friend function defined in a class is in
13896 the (lexical) scope of the class in which it is defined. */
13897 if (!ctype
&& DECL_FRIEND_P (decl1
))
13899 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13901 /* CTYPE could be null here if we're dealing with a template;
13902 for example, `inline friend float foo()' inside a template
13903 will have no CTYPE set. */
13904 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13910 if (DECL_DECLARED_INLINE_P (decl1
)
13911 && lookup_attribute ("noinline", attrs
))
13912 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
13913 "inline function %qD given attribute noinline", decl1
);
13915 /* Handle gnu_inline attribute. */
13916 if (GNU_INLINE_P (decl1
))
13918 DECL_EXTERNAL (decl1
) = 1;
13919 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13920 DECL_INTERFACE_KNOWN (decl1
) = 1;
13921 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13924 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13925 /* This is a constructor, we must ensure that any default args
13926 introduced by this definition are propagated to the clones
13927 now. The clones are used directly in overload resolution. */
13928 adjust_clone_args (decl1
);
13930 /* Sometimes we don't notice that a function is a static member, and
13931 build a METHOD_TYPE for it. Fix that up now. */
13932 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13933 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13935 /* Set up current_class_type, and enter the scope of the class, if
13938 push_nested_class (ctype
);
13939 else if (DECL_STATIC_FUNCTION_P (decl1
))
13940 push_nested_class (DECL_CONTEXT (decl1
));
13942 /* Now that we have entered the scope of the class, we must restore
13943 the bindings for any template parameters surrounding DECL1, if it
13944 is an inline member template. (Order is important; consider the
13945 case where a template parameter has the same name as a field of
13946 the class.) It is not until after this point that
13947 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13948 if (flags
& SF_INCLASS_INLINE
)
13949 maybe_begin_member_template_processing (decl1
);
13951 /* Effective C++ rule 15. */
13953 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13954 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13955 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13957 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13958 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13959 if (!DECL_INITIAL (decl1
))
13960 DECL_INITIAL (decl1
) = error_mark_node
;
13962 /* This function exists in static storage.
13963 (This does not mean `static' in the C sense!) */
13964 TREE_STATIC (decl1
) = 1;
13966 /* We must call push_template_decl after current_class_type is set
13967 up. (If we are processing inline definitions after exiting a
13968 class scope, current_class_type will be NULL_TREE until set above
13969 by push_nested_class.) */
13970 if (processing_template_decl
)
13972 tree newdecl1
= push_template_decl (decl1
);
13973 if (newdecl1
== error_mark_node
)
13975 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13976 pop_nested_class ();
13982 /* We are now in the scope of the function being defined. */
13983 current_function_decl
= decl1
;
13985 /* Save the parm names or decls from this function's declarator
13986 where store_parm_decls will find them. */
13987 current_function_parms
= DECL_ARGUMENTS (decl1
);
13989 /* Make sure the parameter and return types are reasonable. When
13990 you declare a function, these types can be incomplete, but they
13991 must be complete when you define the function. */
13992 check_function_type (decl1
, current_function_parms
);
13994 /* Build the return declaration for the function. */
13995 restype
= TREE_TYPE (fntype
);
13997 if (DECL_RESULT (decl1
) == NULL_TREE
)
14001 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
14002 DECL_ARTIFICIAL (resdecl
) = 1;
14003 DECL_IGNORED_P (resdecl
) = 1;
14004 DECL_RESULT (decl1
) = resdecl
;
14006 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
14009 /* Let the user know we're compiling this function. */
14010 announce_function (decl1
);
14012 /* Record the decl so that the function name is defined.
14013 If we already have a decl for this name, and it is a FUNCTION_DECL,
14014 use the old decl. */
14015 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
14017 /* A specialization is not used to guide overload resolution. */
14018 if (!DECL_FUNCTION_MEMBER_P (decl1
)
14019 && !(DECL_USE_TEMPLATE (decl1
) &&
14020 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
14022 tree olddecl
= pushdecl (decl1
);
14024 if (olddecl
== error_mark_node
)
14025 /* If something went wrong when registering the declaration,
14026 use DECL1; we have to have a FUNCTION_DECL to use when
14027 parsing the body of the function. */
14031 /* Otherwise, OLDDECL is either a previous declaration
14032 of the same function or DECL1 itself. */
14034 if (warn_missing_declarations
14035 && olddecl
== decl1
14036 && !DECL_MAIN_P (decl1
)
14037 && TREE_PUBLIC (decl1
)
14038 && !DECL_DECLARED_INLINE_P (decl1
))
14042 /* Check whether DECL1 is in an anonymous
14044 for (context
= DECL_CONTEXT (decl1
);
14046 context
= DECL_CONTEXT (context
))
14048 if (TREE_CODE (context
) == NAMESPACE_DECL
14049 && DECL_NAME (context
) == NULL_TREE
)
14053 if (context
== NULL
)
14054 warning_at (DECL_SOURCE_LOCATION (decl1
),
14055 OPT_Wmissing_declarations
,
14056 "no previous declaration for %qD", decl1
);
14064 /* We need to set the DECL_CONTEXT. */
14065 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
14066 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
14068 fntype
= TREE_TYPE (decl1
);
14069 restype
= TREE_TYPE (fntype
);
14071 /* If #pragma weak applies, mark the decl appropriately now.
14072 The pragma only applies to global functions. Because
14073 determining whether or not the #pragma applies involves
14074 computing the mangled name for the declaration, we cannot
14075 apply the pragma until after we have merged this declaration
14076 with any previous declarations; if the original declaration
14077 has a linkage specification, that specification applies to
14078 the definition as well, and may affect the mangled name. */
14079 if (DECL_FILE_SCOPE_P (decl1
))
14080 maybe_apply_pragma_weak (decl1
);
14083 /* Reset this in case the call to pushdecl changed it. */
14084 current_function_decl
= decl1
;
14086 gcc_assert (DECL_INITIAL (decl1
));
14088 /* This function may already have been parsed, in which case just
14089 return; our caller will skip over the body without parsing. */
14090 if (DECL_INITIAL (decl1
) != error_mark_node
)
14093 /* Initialize RTL machinery. We cannot do this until
14094 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
14095 even when processing a template; this is how we get
14096 CFUN set up, and our per-function variables initialized.
14097 FIXME factor out the non-RTL stuff. */
14098 bl
= current_binding_level
;
14099 allocate_struct_function (decl1
, processing_template_decl
);
14101 /* Initialize the language data structures. Whenever we start
14102 a new function, we destroy temporaries in the usual way. */
14103 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
14104 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
14105 current_binding_level
= bl
;
14107 if (!processing_template_decl
&& type_uses_auto (restype
))
14109 FNDECL_USED_AUTO (decl1
) = true;
14110 current_function_auto_return_pattern
= restype
;
14113 /* Start the statement-tree, start the tree now. */
14114 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
14116 /* If we are (erroneously) defining a function that we have already
14117 defined before, wipe out what we knew before. */
14118 if (!DECL_PENDING_INLINE_P (decl1
))
14119 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
14121 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
14123 /* We know that this was set up by `grokclassfn'. We do not
14124 wait until `store_parm_decls', since evil parse errors may
14125 never get us to that point. Here we keep the consistency
14126 between `current_class_type' and `current_class_ptr'. */
14127 tree t
= DECL_ARGUMENTS (decl1
);
14129 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
14130 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
14132 cp_function_chain
->x_current_class_ref
14133 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
14134 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
14135 cp_function_chain
->x_current_class_ptr
= t
;
14137 /* Constructors and destructors need to know whether they're "in
14138 charge" of initializing virtual base classes. */
14139 t
= DECL_CHAIN (t
);
14140 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
14142 current_in_charge_parm
= t
;
14143 t
= DECL_CHAIN (t
);
14145 if (DECL_HAS_VTT_PARM_P (decl1
))
14147 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
14148 current_vtt_parm
= t
;
14152 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
14153 /* Implicitly-defined methods (like the
14154 destructor for a class in which no destructor
14155 is explicitly declared) must not be defined
14156 until their definition is needed. So, we
14157 ignore interface specifications for
14158 compiler-generated functions. */
14159 && !DECL_ARTIFICIAL (decl1
));
14161 if (processing_template_decl
)
14162 /* Don't mess with interface flags. */;
14163 else if (DECL_INTERFACE_KNOWN (decl1
))
14165 tree ctx
= decl_function_context (decl1
);
14167 if (DECL_NOT_REALLY_EXTERN (decl1
))
14168 DECL_EXTERNAL (decl1
) = 0;
14170 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
14171 /* This is a function in a local class in an extern inline
14172 or template function. */
14173 comdat_linkage (decl1
);
14175 /* If this function belongs to an interface, it is public.
14176 If it belongs to someone else's interface, it is also external.
14177 This only affects inlines and template instantiations. */
14178 else if (!finfo
->interface_unknown
&& honor_interface
)
14180 if (DECL_DECLARED_INLINE_P (decl1
)
14181 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14183 DECL_EXTERNAL (decl1
)
14184 = (finfo
->interface_only
14185 || (DECL_DECLARED_INLINE_P (decl1
)
14186 && ! flag_implement_inlines
14187 && !DECL_VINDEX (decl1
)));
14189 /* For WIN32 we also want to put these in linkonce sections. */
14190 maybe_make_one_only (decl1
);
14193 DECL_EXTERNAL (decl1
) = 0;
14194 DECL_INTERFACE_KNOWN (decl1
) = 1;
14195 /* If this function is in an interface implemented in this file,
14196 make sure that the back end knows to emit this function
14198 if (!DECL_EXTERNAL (decl1
))
14199 mark_needed (decl1
);
14201 else if (finfo
->interface_unknown
&& finfo
->interface_only
14202 && honor_interface
)
14204 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14205 interface, we will have both finfo->interface_unknown and
14206 finfo->interface_only set. In that case, we don't want to
14207 use the normal heuristics because someone will supply a
14208 #pragma implementation elsewhere, and deducing it here would
14209 produce a conflict. */
14210 comdat_linkage (decl1
);
14211 DECL_EXTERNAL (decl1
) = 0;
14212 DECL_INTERFACE_KNOWN (decl1
) = 1;
14213 DECL_DEFER_OUTPUT (decl1
) = 1;
14217 /* This is a definition, not a reference.
14218 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
14219 if (!GNU_INLINE_P (decl1
))
14220 DECL_EXTERNAL (decl1
) = 0;
14222 if ((DECL_DECLARED_INLINE_P (decl1
)
14223 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14224 && ! DECL_INTERFACE_KNOWN (decl1
))
14225 DECL_DEFER_OUTPUT (decl1
) = 1;
14227 DECL_INTERFACE_KNOWN (decl1
) = 1;
14230 /* Determine the ELF visibility attribute for the function. We must not
14231 do this before calling "pushdecl", as we must allow "duplicate_decls"
14232 to merge any attributes appropriately. We also need to wait until
14234 if (!DECL_CLONED_FUNCTION_P (decl1
))
14235 determine_visibility (decl1
);
14237 if (!processing_template_decl
)
14238 maybe_instantiate_noexcept (decl1
);
14240 begin_scope (sk_function_parms
, decl1
);
14244 if (DECL_DESTRUCTOR_P (decl1
)
14245 || (DECL_CONSTRUCTOR_P (decl1
)
14246 && targetm
.cxx
.cdtor_returns_this ()))
14247 cdtor_label
= create_artificial_label (input_location
);
14249 start_fname_decls ();
14251 store_parm_decls (current_function_parms
);
14253 if (!processing_template_decl
14254 && (flag_lifetime_dse
> 1)
14255 && DECL_CONSTRUCTOR_P (decl1
)
14256 && !DECL_CLONED_FUNCTION_P (decl1
)
14257 /* Clobbering an empty base is harmful if it overlays real data. */
14258 && !is_empty_class (current_class_type
)
14259 /* We can't clobber safely for an implicitly-defined default constructor
14260 because part of the initialization might happen before we enter the
14261 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
14262 && !implicit_default_ctor_p (decl1
))
14263 finish_expr_stmt (build_clobber_this ());
14265 if (!processing_template_decl
14266 && DECL_CONSTRUCTOR_P (decl1
)
14267 && (flag_sanitize
& SANITIZE_VPTR
)
14268 && !DECL_CLONED_FUNCTION_P (decl1
)
14269 && !implicit_default_ctor_p (decl1
))
14270 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr
);
14276 /* Like start_preparsed_function, except that instead of a
14277 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
14279 Returns true on success. If the DECLARATOR is not suitable
14280 for a function, we return false, which tells the parser to
14281 skip the entire function. */
14284 start_function (cp_decl_specifier_seq
*declspecs
,
14285 const cp_declarator
*declarator
,
14290 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
14291 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
14292 if (decl1
== error_mark_node
)
14294 /* If the declarator is not suitable for a function definition,
14295 cause a syntax error. */
14296 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
14298 error ("invalid function declaration");
14302 if (DECL_MAIN_P (decl1
))
14303 /* main must return int. grokfndecl should have corrected it
14304 (and issued a diagnostic) if the user got it wrong. */
14305 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
14306 integer_type_node
));
14308 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
14311 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
14315 use_eh_spec_block (tree fn
)
14317 return (flag_exceptions
&& flag_enforce_eh_specs
14318 && !processing_template_decl
14319 && !type_throw_all_p (TREE_TYPE (fn
))
14320 /* We insert the EH_SPEC_BLOCK only in the original
14321 function; then, it is copied automatically to the
14323 && !DECL_CLONED_FUNCTION_P (fn
)
14324 /* Implicitly-generated constructors and destructors have
14325 exception specifications. However, those specifications
14326 are the union of the possible exceptions specified by the
14327 constructors/destructors for bases and members, so no
14328 unallowed exception will ever reach this function. By
14329 not creating the EH_SPEC_BLOCK we save a little memory,
14330 and we avoid spurious warnings about unreachable
14332 && !DECL_DEFAULTED_FN (fn
));
14335 /* Store the parameter declarations into the current function declaration.
14336 This is called after parsing the parameter declarations, before
14337 digesting the body of the function.
14339 Also install to binding contour return value identifier, if any. */
14342 store_parm_decls (tree current_function_parms
)
14344 tree fndecl
= current_function_decl
;
14347 /* This is a chain of any other decls that came in among the parm
14348 declarations. If a parm is declared with enum {foo, bar} x;
14349 then CONST_DECLs for foo and bar are put here. */
14350 tree nonparms
= NULL_TREE
;
14352 if (current_function_parms
)
14354 /* This case is when the function was defined with an ANSI prototype.
14355 The parms already have decls, so we need not do anything here
14356 except record them as in effect
14357 and complain if any redundant old-style parm decls were written. */
14359 tree specparms
= current_function_parms
;
14362 /* Must clear this because it might contain TYPE_DECLs declared
14364 current_binding_level
->names
= NULL
;
14366 /* If we're doing semantic analysis, then we'll call pushdecl
14367 for each of these. We must do them in reverse order so that
14368 they end in the correct forward order. */
14369 specparms
= nreverse (specparms
);
14371 for (parm
= specparms
; parm
; parm
= next
)
14373 next
= DECL_CHAIN (parm
);
14374 if (TREE_CODE (parm
) == PARM_DECL
)
14376 if (DECL_NAME (parm
) == NULL_TREE
14377 || !VOID_TYPE_P (parm
))
14380 error ("parameter %qD declared void", parm
);
14384 /* If we find an enum constant or a type tag,
14385 put it aside for the moment. */
14386 TREE_CHAIN (parm
) = NULL_TREE
;
14387 nonparms
= chainon (nonparms
, parm
);
14391 /* Get the decls in their original chain order and record in the
14392 function. This is all and only the PARM_DECLs that were
14393 pushed into scope by the loop above. */
14394 DECL_ARGUMENTS (fndecl
) = getdecls ();
14397 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
14399 /* Now store the final chain of decls for the arguments
14400 as the decl-chain of the current lexical scope.
14401 Put the enumerators in as well, at the front so that
14402 DECL_ARGUMENTS is not modified. */
14403 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
14405 if (use_eh_spec_block (current_function_decl
))
14406 current_eh_spec_block
= begin_eh_spec_block ();
14410 /* We have finished doing semantic analysis on DECL, but have not yet
14411 generated RTL for its body. Save away our current state, so that
14412 when we want to generate RTL later we know what to do. */
14415 save_function_data (tree decl
)
14417 struct language_function
*f
;
14419 /* Save the language-specific per-function data so that we can
14420 get it back when we really expand this function. */
14421 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
14424 f
= ggc_alloc
<language_function
> ();
14425 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
14426 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
14428 /* Clear out the bits we don't need. */
14429 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
14430 f
->bindings
= NULL
;
14431 f
->x_local_names
= NULL
;
14432 f
->base
.local_typedefs
= NULL
;
14436 /* Set the return value of the constructor (if present). */
14439 finish_constructor_body (void)
14444 if (targetm
.cxx
.cdtor_returns_this ()
14445 && (! TYPE_FOR_JAVA (current_class_type
)))
14447 /* Any return from a constructor will end up here. */
14448 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14450 val
= DECL_ARGUMENTS (current_function_decl
);
14451 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14452 DECL_RESULT (current_function_decl
), val
);
14453 /* Return the address of the object. */
14454 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14455 add_stmt (exprstmt
);
14459 /* Do all the processing for the beginning of a destructor; set up the
14460 vtable pointers and cleanups for bases and members. */
14463 begin_destructor_body (void)
14465 tree compound_stmt
;
14467 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
14468 issued an error message. We still want to try to process the
14469 body of the function, but initialize_vtbl_ptrs will crash if
14470 TYPE_BINFO is NULL. */
14471 if (COMPLETE_TYPE_P (current_class_type
))
14473 compound_stmt
= begin_compound_stmt (0);
14474 /* Make all virtual function table pointers in non-virtual base
14475 classes point to CURRENT_CLASS_TYPE's virtual function
14477 initialize_vtbl_ptrs (current_class_ptr
);
14478 finish_compound_stmt (compound_stmt
);
14480 if (flag_lifetime_dse
14481 /* Clobbering an empty base is harmful if it overlays real data. */
14482 && !is_empty_class (current_class_type
))
14483 finish_decl_cleanup (NULL_TREE
, build_clobber_this ());
14485 /* And insert cleanups for our bases and members so that they
14486 will be properly destroyed if we throw. */
14487 push_base_cleanups ();
14491 /* At the end of every destructor we generate code to delete the object if
14492 necessary. Do that now. */
14495 finish_destructor_body (void)
14499 /* Any return from a destructor will end up here; that way all base
14500 and member cleanups will be run when the function returns. */
14501 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14503 if (targetm
.cxx
.cdtor_returns_this ())
14507 val
= DECL_ARGUMENTS (current_function_decl
);
14508 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14509 DECL_RESULT (current_function_decl
), val
);
14510 /* Return the address of the object. */
14511 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14512 add_stmt (exprstmt
);
14516 /* Do the necessary processing for the beginning of a function body, which
14517 in this case includes member-initializers, but not the catch clauses of
14518 a function-try-block. Currently, this means opening a binding level
14519 for the member-initializers (in a ctor), member cleanups (in a dtor),
14520 and capture proxies (in a lambda operator()). */
14523 begin_function_body (void)
14527 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
14530 if (processing_template_decl
)
14531 /* Do nothing now. */;
14533 /* Always keep the BLOCK node associated with the outermost pair of
14534 curly braces of a function. These are needed for correct
14535 operation of dwarfout.c. */
14536 keep_next_level (true);
14538 stmt
= begin_compound_stmt (BCS_FN_BODY
);
14540 if (processing_template_decl
)
14541 /* Do nothing now. */;
14542 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14543 begin_destructor_body ();
14548 /* Do the processing for the end of a function body. Currently, this means
14549 closing out the cleanups for fully-constructed bases and members, and in
14550 the case of the destructor, deleting the object if desired. Again, this
14551 is only meaningful for [cd]tors, since they are the only functions where
14552 there is a significant distinction between the main body and any
14553 function catch clauses. Handling, say, main() return semantics here
14554 would be wrong, as flowing off the end of a function catch clause for
14555 main() would also need to return 0. */
14558 finish_function_body (tree compstmt
)
14560 if (compstmt
== NULL_TREE
)
14563 /* Close the block. */
14564 finish_compound_stmt (compstmt
);
14566 if (processing_template_decl
)
14567 /* Do nothing now. */;
14568 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
14569 finish_constructor_body ();
14570 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14571 finish_destructor_body ();
14574 /* Given a function, returns the BLOCK corresponding to the outermost level
14575 of curly braces, skipping the artificial block created for constructor
14579 outer_curly_brace_block (tree fndecl
)
14581 tree block
= DECL_INITIAL (fndecl
);
14582 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14584 block
= BLOCK_SUBBLOCKS (block
);
14585 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14587 block
= BLOCK_SUBBLOCKS (block
);
14588 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
14592 /* If FNDECL is a class's key method, add the class to the list of
14593 keyed classes that should be emitted. */
14596 record_key_method_defined (tree fndecl
)
14598 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
14599 && DECL_VIRTUAL_P (fndecl
)
14600 && !processing_template_decl
)
14602 tree fnclass
= DECL_CONTEXT (fndecl
);
14603 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
14604 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
14608 /* Subroutine of finish_function.
14609 Save the body of constexpr functions for possible
14610 future compile time evaluation. */
14613 maybe_save_function_definition (tree fun
)
14615 if (!processing_template_decl
14616 && DECL_DECLARED_CONSTEXPR_P (fun
)
14617 && !cp_function_chain
->invalid_constexpr
14618 && !DECL_CLONED_FUNCTION_P (fun
))
14619 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
14622 /* Finish up a function declaration and compile that function
14623 all the way to assembler language output. The free the storage
14624 for the function definition.
14626 FLAGS is a bitwise or of the following values:
14628 We just finished processing the body of an in-class inline
14629 function definition. (This processing will have taken place
14630 after the class definition is complete.) */
14633 finish_function (int flags
)
14635 tree fndecl
= current_function_decl
;
14636 tree fntype
, ctype
= NULL_TREE
;
14637 int inclass_inline
= (flags
& 2) != 0;
14639 /* When we get some parse errors, we can end up without a
14640 current_function_decl, so cope. */
14641 if (fndecl
== NULL_TREE
)
14642 return error_mark_node
;
14644 if (c_dialect_objc ())
14645 objc_finish_function ();
14647 record_key_method_defined (fndecl
);
14649 fntype
= TREE_TYPE (fndecl
);
14651 /* TREE_READONLY (fndecl) = 1;
14652 This caused &foo to be of type ptr-to-const-function
14653 which then got a warning when stored in a ptr-to-function variable. */
14655 gcc_assert (building_stmt_list_p ());
14656 /* The current function is being defined, so its DECL_INITIAL should
14657 be set, and unless there's a multiple definition, it should be
14658 error_mark_node. */
14659 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
14661 /* For a cloned function, we've already got all the code we need;
14662 there's no need to add any extra bits. */
14663 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14665 /* Make it so that `main' always returns 0 by default. */
14666 if (DECL_MAIN_P (current_function_decl
))
14667 finish_return_stmt (integer_zero_node
);
14669 if (use_eh_spec_block (current_function_decl
))
14670 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14671 (TREE_TYPE (current_function_decl
)),
14672 current_eh_spec_block
);
14675 /* If we're saving up tree structure, tie off the function now. */
14676 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
14678 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
14679 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
14681 finish_fname_decls ();
14683 /* If this function can't throw any exceptions, remember that. */
14684 if (!processing_template_decl
14685 && !cp_function_chain
->can_throw
14686 && !flag_non_call_exceptions
14687 && !decl_replaceable_p (fndecl
))
14688 TREE_NOTHROW (fndecl
) = 1;
14690 /* This must come after expand_function_end because cleanups might
14691 have declarations (from inline functions) that need to go into
14692 this function's blocks. */
14694 /* If the current binding level isn't the outermost binding level
14695 for this function, either there is a bug, or we have experienced
14696 syntax errors and the statement tree is malformed. */
14697 if (current_binding_level
->kind
!= sk_function_parms
)
14699 /* Make sure we have already experienced errors. */
14700 gcc_assert (errorcount
);
14702 /* Throw away the broken statement tree and extra binding
14704 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
14706 while (current_binding_level
->kind
!= sk_function_parms
)
14708 if (current_binding_level
->kind
== sk_class
)
14709 pop_nested_class ();
14711 poplevel (0, 0, 0);
14714 poplevel (1, 0, 1);
14716 /* Statements should always be full-expressions at the outermost set
14717 of curly braces for a function. */
14718 gcc_assert (stmts_are_full_exprs_p ());
14720 /* If there are no return statements in a function with auto return type,
14721 the return type is void. But if the declared type is something like
14722 auto*, this is an error. */
14723 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
14724 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
14726 if (!is_auto (current_function_auto_return_pattern
)
14727 && !current_function_returns_value
&& !current_function_returns_null
)
14729 error ("no return statements in function returning %qT",
14730 current_function_auto_return_pattern
);
14731 inform (input_location
, "only plain %<auto%> return type can be "
14732 "deduced to %<void%>");
14734 apply_deduced_return_type (fndecl
, void_type_node
);
14735 fntype
= TREE_TYPE (fndecl
);
14738 // If this is a concept, check that the definition is reasonable.
14739 if (DECL_DECLARED_CONCEPT_P (fndecl
))
14740 check_function_concept (fndecl
);
14742 /* Save constexpr function body before it gets munged by
14743 the NRV transformation. */
14744 maybe_save_function_definition (fndecl
);
14746 /* Invoke the pre-genericize plugin before we start munging things. */
14747 if (!processing_template_decl
)
14748 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14750 /* Perform delayed folding before NRV transformation. */
14751 if (!processing_template_decl
)
14752 cp_fold_function (fndecl
);
14754 /* Set up the named return value optimization, if we can. Candidate
14755 variables are selected in check_return_expr. */
14756 if (current_function_return_value
)
14758 tree r
= current_function_return_value
;
14761 if (r
!= error_mark_node
14762 /* This is only worth doing for fns that return in memory--and
14763 simpler, since we don't have to worry about promoted modes. */
14764 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
14765 /* Only allow this for variables declared in the outer scope of
14766 the function so we know that their lifetime always ends with a
14767 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14768 we were to do this optimization in tree-ssa. */
14769 && (outer
= outer_curly_brace_block (fndecl
))
14770 && chain_member (r
, BLOCK_VARS (outer
)))
14771 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
14773 current_function_return_value
= NULL_TREE
;
14776 /* Remember that we were in class scope. */
14777 if (current_class_name
)
14778 ctype
= current_class_type
;
14780 /* Must mark the RESULT_DECL as being in this function. */
14781 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14783 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14784 to the FUNCTION_DECL node itself. */
14785 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14787 /* Save away current state, if appropriate. */
14788 if (!processing_template_decl
)
14789 save_function_data (fndecl
);
14791 /* Complain if there's just no return statement. */
14792 if (warn_return_type
14793 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14794 && !dependent_type_p (TREE_TYPE (fntype
))
14795 && !current_function_returns_value
&& !current_function_returns_null
14796 /* Don't complain if we abort or throw. */
14797 && !current_function_returns_abnormally
14798 /* Don't complain if there's an infinite loop. */
14799 && !current_function_infinite_loop
14800 /* Don't complain if we are declared noreturn. */
14801 && !TREE_THIS_VOLATILE (fndecl
)
14802 && !DECL_NAME (DECL_RESULT (fndecl
))
14803 && !TREE_NO_WARNING (fndecl
)
14804 /* Structor return values (if any) are set by the compiler. */
14805 && !DECL_CONSTRUCTOR_P (fndecl
)
14806 && !DECL_DESTRUCTOR_P (fndecl
)
14807 && targetm
.warn_func_return (fndecl
))
14809 warning (OPT_Wreturn_type
,
14810 "no return statement in function returning non-void");
14811 TREE_NO_WARNING (fndecl
) = 1;
14814 /* Store the end of the function, so that we get good line number
14815 info for the epilogue. */
14816 cfun
->function_end_locus
= input_location
;
14818 /* Complain about parameters that are only set, but never otherwise used. */
14819 if (warn_unused_but_set_parameter
14820 && !processing_template_decl
14821 && errorcount
== unused_but_set_errorcount
14822 && !DECL_CLONED_FUNCTION_P (fndecl
))
14826 for (decl
= DECL_ARGUMENTS (fndecl
);
14828 decl
= DECL_CHAIN (decl
))
14829 if (TREE_USED (decl
)
14830 && TREE_CODE (decl
) == PARM_DECL
14831 && !DECL_READ_P (decl
)
14832 && DECL_NAME (decl
)
14833 && !DECL_ARTIFICIAL (decl
)
14834 && !TREE_NO_WARNING (decl
)
14835 && !DECL_IN_SYSTEM_HEADER (decl
)
14836 && TREE_TYPE (decl
) != error_mark_node
14837 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14838 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14839 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14840 warning_at (DECL_SOURCE_LOCATION (decl
),
14841 OPT_Wunused_but_set_parameter
,
14842 "parameter %qD set but not used", decl
);
14843 unused_but_set_errorcount
= errorcount
;
14846 /* Complain about locally defined typedefs that are not used in this
14848 maybe_warn_unused_local_typedefs ();
14850 /* Possibly warn about unused parameters. */
14851 if (warn_unused_parameter
14852 && !processing_template_decl
14853 && !DECL_CLONED_FUNCTION_P (fndecl
))
14854 do_warn_unused_parameter (fndecl
);
14856 /* Genericize before inlining. */
14857 if (!processing_template_decl
)
14859 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14860 cp_genericize (fndecl
);
14861 /* Clear out the bits we don't need. */
14862 f
->x_current_class_ptr
= NULL
;
14863 f
->x_current_class_ref
= NULL
;
14864 f
->x_eh_spec_block
= NULL
;
14865 f
->x_in_charge_parm
= NULL
;
14866 f
->x_vtt_parm
= NULL
;
14867 f
->x_return_value
= NULL
;
14868 f
->bindings
= NULL
;
14869 f
->extern_decl_map
= NULL
;
14870 f
->infinite_loops
= NULL
;
14872 /* Clear out the bits we don't need. */
14873 local_names
= NULL
;
14875 /* We're leaving the context of this function, so zap cfun. It's still in
14876 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14878 current_function_decl
= NULL
;
14880 /* If this is an in-class inline definition, we may have to pop the
14881 bindings for the template parameters that we added in
14882 maybe_begin_member_template_processing when start_function was
14884 if (inclass_inline
)
14885 maybe_end_member_template_processing ();
14887 /* Leave the scope of the class. */
14889 pop_nested_class ();
14894 current_function_decl
= NULL_TREE
;
14896 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
14900 /* Create the FUNCTION_DECL for a function definition.
14901 DECLSPECS and DECLARATOR are the parts of the declaration;
14902 they describe the return type and the name of the function,
14903 but twisted together in a fashion that parallels the syntax of C.
14905 This function creates a binding context for the function body
14906 as well as setting up the FUNCTION_DECL in current_function_decl.
14908 Returns a FUNCTION_DECL on success.
14910 If the DECLARATOR is not suitable for a function (it defines a datum
14911 instead), we return 0, which tells yyparse to report a parse error.
14913 May return void_type_node indicating that this method is actually
14914 a friend. See grokfield for more details.
14916 Came here with a `.pushlevel' .
14918 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14919 CHANGES TO CODE IN `grokfield'. */
14922 grokmethod (cp_decl_specifier_seq
*declspecs
,
14923 const cp_declarator
*declarator
, tree attrlist
)
14925 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14928 if (fndecl
== error_mark_node
)
14929 return error_mark_node
;
14931 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14933 error ("invalid member function declaration");
14934 return error_mark_node
;
14938 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14940 /* Pass friends other than inline friend functions back. */
14941 if (fndecl
== void_type_node
)
14944 if (DECL_IN_AGGR_P (fndecl
))
14946 if (DECL_CLASS_SCOPE_P (fndecl
))
14947 error ("%qD is already defined in class %qT", fndecl
,
14948 DECL_CONTEXT (fndecl
));
14949 return error_mark_node
;
14952 check_template_shadow (fndecl
);
14954 if (TREE_PUBLIC (fndecl
))
14955 DECL_COMDAT (fndecl
) = 1;
14956 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14957 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14959 /* We process method specializations in finish_struct_1. */
14960 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14962 fndecl
= push_template_decl (fndecl
);
14963 if (fndecl
== error_mark_node
)
14967 if (! DECL_FRIEND_P (fndecl
))
14969 if (DECL_CHAIN (fndecl
))
14971 fndecl
= copy_node (fndecl
);
14972 TREE_CHAIN (fndecl
) = NULL_TREE
;
14976 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14978 DECL_IN_AGGR_P (fndecl
) = 1;
14983 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14984 we can lay it out later, when and if its type becomes complete.
14986 Also handle constexpr variables where the initializer involves
14987 an unlowered PTRMEM_CST because the class isn't complete yet. */
14990 maybe_register_incomplete_var (tree var
)
14992 gcc_assert (VAR_P (var
));
14994 /* Keep track of variables with incomplete types. */
14995 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14996 && DECL_EXTERNAL (var
))
14998 tree inner_type
= TREE_TYPE (var
);
15000 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
15001 inner_type
= TREE_TYPE (inner_type
);
15002 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
15004 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
15005 /* RTTI TD entries are created while defining the type_info. */
15006 || (TYPE_LANG_SPECIFIC (inner_type
)
15007 && TYPE_BEING_DEFINED (inner_type
)))
15009 incomplete_var iv
= {var
, inner_type
};
15010 vec_safe_push (incomplete_vars
, iv
);
15012 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
15013 && decl_constant_var_p (var
)
15014 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
15016 /* When the outermost open class is complete we can resolve any
15017 pointers-to-members. */
15018 tree context
= outermost_open_class ();
15019 incomplete_var iv
= {var
, context
};
15020 vec_safe_push (incomplete_vars
, iv
);
15025 /* Called when a class type (given by TYPE) is defined. If there are
15026 any existing VAR_DECLs whose type has been completed by this
15027 declaration, update them now. */
15030 complete_vars (tree type
)
15033 incomplete_var
*iv
;
15035 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
15037 if (same_type_p (type
, iv
->incomplete_type
))
15039 tree var
= iv
->decl
;
15040 tree type
= TREE_TYPE (var
);
15042 if (type
!= error_mark_node
15043 && (TYPE_MAIN_VARIANT (strip_array_types (type
))
15044 == iv
->incomplete_type
))
15046 /* Complete the type of the variable. The VAR_DECL itself
15047 will be laid out in expand_expr. */
15048 complete_type (type
);
15049 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
15052 /* Remove this entry from the list. */
15053 incomplete_vars
->unordered_remove (ix
);
15059 /* Check for pending declarations which may have abstract type. */
15060 complete_type_check_abstract (type
);
15063 /* If DECL is of a type which needs a cleanup, build and return an
15064 expression to perform that cleanup here. Return NULL_TREE if no
15065 cleanup need be done. DECL can also be a _REF when called from
15066 split_nonconstant_init_1. */
15069 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
15075 /* Assume no cleanup is required. */
15076 cleanup
= NULL_TREE
;
15078 if (error_operand_p (decl
))
15081 /* Handle "__attribute__((cleanup))". We run the cleanup function
15082 before the destructor since the destructor is what actually
15083 terminates the lifetime of the object. */
15085 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
15094 /* Get the name specified by the user for the cleanup function. */
15095 id
= TREE_VALUE (TREE_VALUE (attr
));
15096 /* Look up the name to find the cleanup function to call. It is
15097 important to use lookup_name here because that is what is
15098 used in c-common.c:handle_cleanup_attribute when performing
15099 initial checks on the attribute. Note that those checks
15100 include ensuring that the function found is not an overloaded
15101 function, or an object with an overloaded call operator,
15102 etc.; we can rely on the fact that the function found is an
15103 ordinary FUNCTION_DECL. */
15104 fn
= lookup_name (id
);
15105 arg
= build_address (decl
);
15106 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
15107 return error_mark_node
;
15108 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
15109 if (cleanup
== error_mark_node
)
15110 return error_mark_node
;
15112 /* Handle ordinary C++ destructors. */
15113 type
= TREE_TYPE (decl
);
15114 if (type_build_dtor_call (type
))
15116 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
15120 if (TREE_CODE (type
) == ARRAY_TYPE
)
15123 addr
= build_address (decl
);
15125 call
= build_delete (TREE_TYPE (addr
), addr
,
15126 sfk_complete_destructor
, flags
, 0, complain
);
15127 if (call
== error_mark_node
)
15128 cleanup
= error_mark_node
;
15129 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
15130 /* Discard the call. */;
15132 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
15137 /* build_delete sets the location of the destructor call to the
15138 current location, even though the destructor is going to be
15139 called later, at the end of the current scope. This can lead to
15140 a "jumpy" behavior for users of debuggers when they step around
15141 the end of the block. So let's unset the location of the
15142 destructor call instead. */
15143 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
15147 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
15148 /* Treat objects with destructors as used; the destructor may do
15149 something substantive. */
15150 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
15151 return error_mark_node
;
15157 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
15158 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
15159 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
15162 static_fn_type (tree memfntype
)
15167 if (TYPE_PTRMEMFUNC_P (memfntype
))
15168 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
15169 if (POINTER_TYPE_P (memfntype
)
15170 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
15171 memfntype
= TREE_TYPE (memfntype
);
15172 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
15174 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
15175 args
= TYPE_ARG_TYPES (memfntype
);
15176 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
15177 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
15178 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
15179 fntype
= (cp_build_type_attribute_variant
15180 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
15181 fntype
= (build_exception_variant
15182 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
15183 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
15184 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
15188 /* DECL was originally constructed as a non-static member function,
15189 but turned out to be static. Update it accordingly. */
15192 revert_static_member_fn (tree decl
)
15194 tree stype
= static_fn_type (decl
);
15195 cp_cv_quals quals
= type_memfn_quals (stype
);
15196 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
15198 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
15199 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
15201 TREE_TYPE (decl
) = stype
;
15203 if (DECL_ARGUMENTS (decl
))
15204 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
15205 DECL_STATIC_FUNCTION_P (decl
) = 1;
15208 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
15209 one of the language-independent trees. */
15211 enum cp_tree_node_structure_enum
15212 cp_tree_node_structure (union lang_tree_node
* t
)
15214 switch (TREE_CODE (&t
->generic
))
15216 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
15217 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
15218 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
15219 case OVERLOAD
: return TS_CP_OVERLOAD
;
15220 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
15221 case PTRMEM_CST
: return TS_CP_PTRMEM
;
15222 case BASELINK
: return TS_CP_BASELINK
;
15223 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
15224 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
15225 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
15226 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
15227 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
15228 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
15229 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
15230 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
15231 default: return TS_CP_GENERIC
;
15235 /* Build the void_list_node (void_type_node having been created). */
15237 build_void_list_node (void)
15239 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
15244 cp_missing_noreturn_ok_p (tree decl
)
15246 /* A missing noreturn is ok for the `main' function. */
15247 return DECL_MAIN_P (decl
);
15250 /* Return the decl used to identify the COMDAT group into which DECL should
15254 cxx_comdat_group (tree decl
)
15256 /* Virtual tables, construction virtual tables, and virtual table
15257 tables all go in a single COMDAT group, named after the primary
15259 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
15260 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
15261 /* For all other DECLs, the COMDAT group is the mangled name of the
15262 declaration itself. */
15265 while (DECL_THUNK_P (decl
))
15267 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
15268 into the same section as the target function. In that case
15269 we must return target's name. */
15270 tree target
= THUNK_TARGET (decl
);
15271 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
15272 && DECL_SECTION_NAME (target
) != NULL
15273 && DECL_ONE_ONLY (target
))
15283 /* Returns the return type for FN as written by the user, which may include
15284 a placeholder for a deduced return type. */
15287 fndecl_declared_return_type (tree fn
)
15289 fn
= STRIP_TEMPLATE (fn
);
15290 if (FNDECL_USED_AUTO (fn
))
15292 struct language_function
*f
= NULL
;
15293 if (DECL_STRUCT_FUNCTION (fn
))
15294 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
15296 f
= DECL_SAVED_FUNCTION_DATA (fn
);
15297 return f
->x_auto_return_pattern
;
15299 return TREE_TYPE (TREE_TYPE (fn
));
15302 /* Returns true iff DECL was declared with an auto return type and it has
15303 not yet been deduced to a real type. */
15306 undeduced_auto_decl (tree decl
)
15308 if (cxx_dialect
< cxx14
)
15310 return type_uses_auto (TREE_TYPE (decl
));
15313 /* Complain if DECL has an undeduced return type. */
15316 require_deduced_type (tree decl
)
15318 if (undeduced_auto_decl (decl
))
15319 error ("use of %qD before deduction of %<auto%>", decl
);
15322 #include "gt-cp-decl.h"