1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2015 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
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"
35 #include "tree-hasher.h"
36 #include "stringpool.h"
37 #include "stor-layout.h"
43 #include "tree-iterator.h"
44 #include "tree-inline.h"
50 #include "c-family/c-common.h"
51 #include "c-family/c-objc.h"
52 #include "c-family/c-pragma.h"
53 #include "c-family/c-target.h"
54 #include "c-family/c-ubsan.h"
55 #include "diagnostic.h"
59 #include "splay-tree.h"
61 #include "hard-reg-set.h"
67 /* Possible cases of bad specifiers type used by bad_specifiers. */
69 BSP_VAR
, /* variable */
70 BSP_PARM
, /* parameter */
75 static tree
grokparms (tree parmlist
, tree
*);
76 static const char *redeclaration_error_message (tree
, tree
);
78 static int decl_jump_unsafe (tree
);
79 static void require_complete_types_for_parms (tree
);
80 static int ambi_op_p (enum tree_code
);
81 static int unary_op_p (enum tree_code
);
82 static void push_local_name (tree
);
83 static tree
grok_reference_init (tree
, tree
, tree
, int);
84 static tree
grokvardecl (tree
, tree
, tree
, const cp_decl_specifier_seq
*,
86 static int check_static_variable_definition (tree
, tree
);
87 static void record_unknown_type (tree
, const char *);
88 static tree
builtin_function_1 (tree
, tree
, bool);
89 static int member_function_or_else (tree
, tree
, enum overload_flags
);
90 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
92 static void check_for_uninitialized_const_var (tree
);
93 static tree
local_variable_p_walkfn (tree
*, int *, void *);
94 static tree
record_builtin_java_type (const char *, int);
95 static const char *tag_name (enum tag_types
);
96 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
97 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
98 static void maybe_deduce_size_from_array_init (tree
, tree
);
99 static void layout_var_decl (tree
);
100 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
101 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
102 static void save_function_data (tree
);
103 static void copy_type_enum (tree
, tree
);
104 static void check_function_type (tree
, tree
);
105 static void finish_constructor_body (void);
106 static void begin_destructor_body (void);
107 static void finish_destructor_body (void);
108 static void record_key_method_defined (tree
);
109 static tree
create_array_type_for_decl (tree
, tree
, tree
);
110 static tree
get_atexit_node (void);
111 static tree
get_dso_handle_node (void);
112 static tree
start_cleanup_fn (void);
113 static void end_cleanup_fn (void);
114 static tree
cp_make_fname_decl (location_t
, tree
, int);
115 static void initialize_predefined_identifiers (void);
116 static tree check_special_function_return_type
117 (special_function_kind
, tree
, tree
);
118 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
119 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
120 static void store_parm_decls (tree
);
121 static void initialize_local_var (tree
, tree
);
122 static void expand_static_init (tree
, tree
);
124 /* The following symbols are subsumed in the cp_global_trees array, and
125 listed here individually for documentation purposes.
128 tree wchar_decl_node;
130 tree vtable_entry_type;
131 tree delta_type_node;
132 tree __t_desc_type_node;
134 tree class_type_node;
135 tree unknown_type_node;
137 Array type `vtable_entry_type[]'
140 tree vtbl_ptr_type_node;
147 A FUNCTION_DECL which can call `abort'. Not necessarily the
148 one that the user will declare, but sufficient to be called
149 by routines that want to abort the program.
154 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
155 tree tinfo_var_id; */
157 tree cp_global_trees
[CPTI_MAX
];
159 /* Indicates that there is a type value in some namespace, although
160 that is not necessarily in scope at the moment. */
162 tree global_type_node
;
164 /* The node that holds the "name" of the global scope. */
165 tree global_scope_name
;
167 #define local_names cp_function_chain->x_local_names
169 /* A list of objects which have constructors or destructors
170 which reside in the global scope. The decl is stored in
171 the TREE_VALUE slot and the initializer is stored
172 in the TREE_PURPOSE slot. */
173 tree static_aggregates
;
175 /* Like static_aggregates, but for thread_local variables. */
180 /* A node for the integer constant 2. */
182 tree integer_two_node
;
184 /* Used only for jumps to as-yet undefined labels, since jumps to
185 defined labels can have their validity checked immediately. */
187 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
188 struct named_label_use_entry
*next
;
189 /* The binding level to which this entry is *currently* attached.
190 This is initially the binding level in which the goto appeared,
191 but is modified as scopes are closed. */
192 cp_binding_level
*binding_level
;
193 /* The head of the names list that was current when the goto appeared,
194 or the inner scope popped. These are the decls that will *not* be
195 skipped when jumping to the label. */
197 /* The location of the goto, for error reporting. */
198 location_t o_goto_locus
;
199 /* True if an OpenMP structured block scope has been closed since
200 the goto appeared. This means that the branch from the label will
201 illegally exit an OpenMP scope. */
205 /* A list of all LABEL_DECLs in the function that have names. Here so
206 we can clear out their names' definitions at the end of the
207 function, and so we can check the validity of jumps to these labels. */
209 struct GTY((for_user
)) named_label_entry
{
210 /* The decl itself. */
213 /* The binding level to which the label is *currently* attached.
214 This is initially set to the binding level in which the label
215 is defined, but is modified as scopes are closed. */
216 cp_binding_level
*binding_level
;
217 /* The head of the names list that was current when the label was
218 defined, or the inner scope popped. These are the decls that will
219 be skipped when jumping to the label. */
221 /* A vector of all decls from all binding levels that would be
222 crossed by a backward branch to the label. */
223 vec
<tree
, va_gc
> *bad_decls
;
225 /* A list of uses of the label, before the label is defined. */
226 struct named_label_use_entry
*uses
;
228 /* The following bits are set after the label is defined, and are
229 updated as scopes are popped. They indicate that a backward jump
230 to the label will illegally enter a scope of the given flavor. */
236 #define named_labels cp_function_chain->x_named_labels
238 /* The number of function bodies which we are currently processing.
239 (Zero if we are at namespace scope, one inside the body of a
240 function, two inside the body of a function in a local class, etc.) */
243 /* To avoid unwanted recursion, finish_function defers all mark_used calls
244 encountered during its execution until it finishes. */
245 bool defer_mark_used_calls
;
246 vec
<tree
, va_gc
> *deferred_mark_used_calls
;
248 /* States indicating how grokdeclarator() should handle declspecs marked
249 with __attribute__((deprecated)). An object declared as
250 __attribute__((deprecated)) suppresses warnings of uses of other
252 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
255 /* A list of VAR_DECLs whose type was incomplete at the time the
256 variable was declared. */
258 typedef struct GTY(()) incomplete_var_d
{
260 tree incomplete_type
;
264 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
266 /* Returns the kind of template specialization we are currently
267 processing, given that it's declaration contained N_CLASS_SCOPES
268 explicit scope qualifications. */
271 current_tmpl_spec_kind (int n_class_scopes
)
273 int n_template_parm_scopes
= 0;
274 int seen_specialization_p
= 0;
275 int innermost_specialization_p
= 0;
278 /* Scan through the template parameter scopes. */
279 for (b
= current_binding_level
;
280 b
->kind
== sk_template_parms
;
283 /* If we see a specialization scope inside a parameter scope,
284 then something is wrong. That corresponds to a declaration
287 template <class T> template <> ...
289 which is always invalid since [temp.expl.spec] forbids the
290 specialization of a class member template if the enclosing
291 class templates are not explicitly specialized as well. */
292 if (b
->explicit_spec_p
)
294 if (n_template_parm_scopes
== 0)
295 innermost_specialization_p
= 1;
297 seen_specialization_p
= 1;
299 else if (seen_specialization_p
== 1)
300 return tsk_invalid_member_spec
;
302 ++n_template_parm_scopes
;
305 /* Handle explicit instantiations. */
306 if (processing_explicit_instantiation
)
308 if (n_template_parm_scopes
!= 0)
309 /* We've seen a template parameter list during an explicit
310 instantiation. For example:
312 template <class T> template void f(int);
314 This is erroneous. */
315 return tsk_invalid_expl_inst
;
317 return tsk_expl_inst
;
320 if (n_template_parm_scopes
< n_class_scopes
)
321 /* We've not seen enough template headers to match all the
322 specialized classes present. For example:
324 template <class T> void R<T>::S<T>::f(int);
326 This is invalid; there needs to be one set of template
327 parameters for each class. */
328 return tsk_insufficient_parms
;
329 else if (n_template_parm_scopes
== n_class_scopes
)
330 /* We're processing a non-template declaration (even though it may
331 be a member of a template class.) For example:
333 template <class T> void S<T>::f(int);
335 The `class T' matches the `S<T>', leaving no template headers
336 corresponding to the `f'. */
338 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
339 /* We've got too many template headers. For example:
341 template <> template <class T> void f (T);
343 There need to be more enclosing classes. */
344 return tsk_excessive_parms
;
346 /* This must be a template. It's of the form:
348 template <class T> template <class U> void S<T>::f(U);
350 This is a specialization if the innermost level was a
351 specialization; otherwise it's just a definition of the
353 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
356 /* Exit the current scope. */
364 /* When a label goes out of scope, check to see if that label was used
365 in a valid manner, and issue any appropriate warnings or errors. */
368 pop_label (tree label
, tree old_value
)
370 if (!processing_template_decl
)
372 if (DECL_INITIAL (label
) == NULL_TREE
)
376 error ("label %q+D used but not defined", label
);
377 location
= input_location
;
378 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
379 /* Avoid crashing later. */
380 define_label (location
, DECL_NAME (label
));
383 warn_for_unused_label (label
);
386 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
389 /* At the end of a function, all labels declared within the function
390 go out of scope. BLOCK is the top-level block for the
394 pop_labels_1 (named_label_entry
**slot
, tree block
)
396 struct named_label_entry
*ent
= *slot
;
398 pop_label (ent
->label_decl
, NULL_TREE
);
400 /* Put the labels into the "variables" of the top-level block,
401 so debugger can see them. */
402 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
403 BLOCK_VARS (block
) = ent
->label_decl
;
405 named_labels
->clear_slot (slot
);
411 pop_labels (tree block
)
415 named_labels
->traverse
<tree
, pop_labels_1
> (block
);
420 /* At the end of a block with local labels, restore the outer definition. */
423 pop_local_label (tree label
, tree old_value
)
425 struct named_label_entry dummy
;
427 pop_label (label
, old_value
);
429 dummy
.label_decl
= label
;
430 named_label_entry
**slot
= named_labels
->find_slot (&dummy
, NO_INSERT
);
431 named_labels
->clear_slot (slot
);
434 /* The following two routines are used to interface to Objective-C++.
435 The binding level is purposely treated as an opaque type. */
438 objc_get_current_scope (void)
440 return current_binding_level
;
443 /* The following routine is used by the NeXT-style SJLJ exceptions;
444 variables get marked 'volatile' so as to not be clobbered by
445 _setjmp()/_longjmp() calls. All variables in the current scope,
446 as well as parent scopes up to (but not including) ENCLOSING_BLK
447 shall be thusly marked. */
450 objc_mark_locals_volatile (void *enclosing_blk
)
452 cp_binding_level
*scope
;
454 for (scope
= current_binding_level
;
455 scope
&& scope
!= enclosing_blk
;
456 scope
= scope
->level_chain
)
460 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
461 objc_volatilize_decl (decl
);
463 /* Do not climb up past the current function. */
464 if (scope
->kind
== sk_function_parms
)
469 /* Update data for defined and undefined labels when leaving a scope. */
472 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
474 named_label_entry
*ent
= *slot
;
475 cp_binding_level
*obl
= bl
->level_chain
;
477 if (ent
->binding_level
== bl
)
481 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
482 TREE_LISTs representing OVERLOADs, so be careful. */
483 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
485 : TREE_CHAIN (decl
)))
486 if (decl_jump_unsafe (decl
))
487 vec_safe_push (ent
->bad_decls
, decl
);
489 ent
->binding_level
= obl
;
490 ent
->names_in_scope
= obl
->names
;
494 ent
->in_try_scope
= true;
497 ent
->in_catch_scope
= true;
500 ent
->in_omp_scope
= true;
508 struct named_label_use_entry
*use
;
510 for (use
= ent
->uses
; use
; use
= use
->next
)
511 if (use
->binding_level
== bl
)
513 use
->binding_level
= obl
;
514 use
->names_in_scope
= obl
->names
;
515 if (bl
->kind
== sk_omp
)
516 use
->in_omp_scope
= true;
523 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
524 when errors were reported, except for -Werror-unused-but-set-*. */
525 static int unused_but_set_errorcount
;
527 /* Exit a binding level.
528 Pop the level off, and restore the state of the identifier-decl mappings
529 that were in effect when this level was entered.
531 If KEEP == 1, this level had explicit declarations, so
532 and create a "block" (a BLOCK node) for the level
533 to record its declarations and subblocks for symbol table output.
535 If FUNCTIONBODY is nonzero, this level is the body of a function,
536 so create a block as if KEEP were set and also clear out all
539 If REVERSE is nonzero, reverse the order of decls before putting
540 them into the BLOCK. */
543 poplevel (int keep
, int reverse
, int functionbody
)
546 /* The chain of decls was accumulated in reverse order.
547 Put it into forward order, just for cleanliness. */
552 int leaving_for_scope
;
555 cp_label_binding
*label_bind
;
557 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
562 gcc_assert (current_binding_level
->kind
!= sk_class
);
564 if (current_binding_level
->kind
== sk_cleanup
)
566 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
568 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
570 /* We used to use KEEP == 2 to indicate that the new block should go
571 at the beginning of the list of blocks at this binding level,
572 rather than the end. This hack is no longer used. */
573 gcc_assert (keep
== 0 || keep
== 1);
575 if (current_binding_level
->keep
)
578 /* Any uses of undefined labels, and any defined labels, now operate
579 under constraints of next binding contour. */
580 if (cfun
&& !functionbody
&& named_labels
)
581 named_labels
->traverse
<cp_binding_level
*, poplevel_named_label_1
>
582 (current_binding_level
);
584 /* Get the decls in the order they were written.
585 Usually current_binding_level->names is in reverse order.
586 But parameter decls were previously put in forward order. */
589 current_binding_level
->names
590 = decls
= nreverse (current_binding_level
->names
);
592 decls
= current_binding_level
->names
;
594 /* If there were any declarations or structure tags in that level,
595 or if this level is a function body,
596 create a BLOCK to record them for the life of this function. */
598 /* Avoid function body block if possible. */
599 if (functionbody
&& subblocks
&& BLOCK_CHAIN (subblocks
) == NULL_TREE
)
601 else if (keep
== 1 || functionbody
)
602 block
= make_node (BLOCK
);
603 if (block
!= NULL_TREE
)
605 BLOCK_VARS (block
) = decls
;
606 BLOCK_SUBBLOCKS (block
) = subblocks
;
609 /* In each subblock, record that this is its superior. */
611 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
612 BLOCK_SUPERCONTEXT (link
) = block
;
614 /* We still support the old for-scope rules, whereby the variables
615 in a for-init statement were in scope after the for-statement
616 ended. We only use the new rules if flag_new_for_scope is
619 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
621 /* Before we remove the declarations first check for unused variables. */
622 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
623 && current_binding_level
->kind
!= sk_template_parms
624 && !processing_template_decl
)
625 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
627 /* There are cases where D itself is a TREE_LIST. See in
628 push_local_binding where the list of decls returned by
629 getdecls is built. */
630 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
631 tree type
= TREE_TYPE (decl
);
633 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
634 && ! DECL_IN_SYSTEM_HEADER (decl
)
635 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
636 && type
!= error_mark_node
637 && (!CLASS_TYPE_P (type
)
638 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
639 || lookup_attribute ("warn_unused",
640 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
642 if (! TREE_USED (decl
))
643 warning_at (DECL_SOURCE_LOCATION (decl
),
644 OPT_Wunused_variable
, "unused variable %qD", decl
);
645 else if (DECL_CONTEXT (decl
) == current_function_decl
646 // For -Wunused-but-set-variable leave references alone.
647 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
648 && errorcount
== unused_but_set_errorcount
)
650 warning_at (DECL_SOURCE_LOCATION (decl
),
651 OPT_Wunused_but_set_variable
,
652 "variable %qD set but not used", decl
);
653 unused_but_set_errorcount
= errorcount
;
658 /* Remove declarations for all the DECLs in this level. */
659 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
661 if (leaving_for_scope
&& VAR_P (link
)
662 /* It's hard to make this ARM compatibility hack play nicely with
663 lambdas, and it really isn't necessary in C++11 mode. */
664 && cxx_dialect
< cxx11
667 tree name
= DECL_NAME (link
);
671 ob
= outer_binding (name
,
672 IDENTIFIER_BINDING (name
),
675 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
677 ns_binding
= NULL_TREE
;
679 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
680 /* We have something like:
685 and we are leaving the `for' scope. There's no reason to
686 keep the binding of the inner `i' in this case. */
687 pop_binding (name
, link
);
688 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
689 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
690 /* Here, we have something like:
698 We must pop the for-scope binding so we know what's a
699 type and what isn't. */
700 pop_binding (name
, link
);
703 /* Mark this VAR_DECL as dead so that we can tell we left it
704 there only for backward compatibility. */
705 DECL_DEAD_FOR_LOCAL (link
) = 1;
707 /* Keep track of what should have happened when we
708 popped the binding. */
711 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
712 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
715 /* Add it to the list of dead variables in the next
716 outermost binding to that we can remove these when we
717 leave that binding. */
719 current_binding_level
->level_chain
->dead_vars_from_for
,
722 /* Although we don't pop the cxx_binding, we do clear
723 its SCOPE since the scope is going away now. */
724 IDENTIFIER_BINDING (name
)->scope
725 = current_binding_level
->level_chain
;
732 /* Remove the binding. */
735 if (TREE_CODE (decl
) == TREE_LIST
)
736 decl
= TREE_VALUE (decl
);
739 if (TREE_CODE (name
) == OVERLOAD
)
740 name
= OVL_FUNCTION (name
);
742 gcc_assert (DECL_P (name
));
743 pop_binding (DECL_NAME (name
), decl
);
747 /* Remove declarations for any `for' variables from inner scopes
748 that we kept around. */
749 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
751 pop_binding (DECL_NAME (decl
), decl
);
753 /* Restore the IDENTIFIER_TYPE_VALUEs. */
754 for (link
= current_binding_level
->type_shadowed
;
755 link
; link
= TREE_CHAIN (link
))
756 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
758 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
759 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
761 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
763 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
764 list if a `using' declaration put them there. The debugging
765 back ends won't understand OVERLOAD, so we remove them here.
766 Because the BLOCK_VARS are (temporarily) shared with
767 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
768 popped all the bindings. */
773 for (d
= &BLOCK_VARS (block
); *d
; )
775 if (TREE_CODE (*d
) == TREE_LIST
)
776 *d
= TREE_CHAIN (*d
);
778 d
= &DECL_CHAIN (*d
);
782 /* If the level being exited is the top level of a function,
783 check over all the labels. */
788 /* Since this is the top level block of a function, the vars are
789 the function's parameters. Don't leave them in the BLOCK
790 because they are found in the FUNCTION_DECL instead. */
791 BLOCK_VARS (block
) = 0;
795 pop_labels (subblocks
);
798 kind
= current_binding_level
->kind
;
799 if (kind
== sk_cleanup
)
803 /* If this is a temporary binding created for a cleanup, then we'll
804 have pushed a statement list level. Pop that, create a new
805 BIND_EXPR for the block, and insert it into the stream. */
806 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
807 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
814 /* The current function is being defined, so its DECL_INITIAL
815 should be error_mark_node. */
816 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
817 DECL_INITIAL (current_function_decl
) = block
? block
: subblocks
;
820 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
822 if (BLOCK_SUBBLOCKS (subblocks
))
823 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks
)) = 1;
826 BLOCK_OUTER_CURLY_BRACE_P (subblocks
) = 1;
830 current_binding_level
->blocks
831 = block_chainon (current_binding_level
->blocks
, block
);
833 /* If we did not make a block for the level just exited,
834 any blocks made for inner levels
835 (since they cannot be recorded as subblocks in that level)
836 must be carried forward so they will later become subblocks
837 of something else. */
839 current_binding_level
->blocks
840 = block_chainon (current_binding_level
->blocks
, subblocks
);
842 /* Each and every BLOCK node created here in `poplevel' is important
843 (e.g. for proper debugging information) so if we created one
844 earlier, mark it as "used". */
846 TREE_USED (block
) = 1;
848 /* All temporary bindings created for cleanups are popped silently. */
849 if (kind
== sk_cleanup
)
852 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
856 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
857 itself, calling F for each. The DATA is passed to F as well. */
860 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
863 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
865 result
|= (*f
) (name_space
, data
);
867 for (; current
; current
= DECL_CHAIN (current
))
868 result
|= walk_namespaces_r (current
, f
, data
);
873 /* Walk all the namespaces, calling F for each. The DATA is passed to
877 walk_namespaces (walk_namespaces_fn f
, void* data
)
879 return walk_namespaces_r (global_namespace
, f
, data
);
882 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
885 wrapup_globals_for_namespace (tree name_space
, void* data ATTRIBUTE_UNUSED
)
887 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
888 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
889 tree
*vec
= statics
->address ();
890 int len
= statics
->length ();
892 /* Write out any globals that need to be output. */
893 return wrapup_global_declarations (vec
, len
);
896 /* In C++, you don't have to write `struct S' to refer to `S'; you
897 can just use `S'. We accomplish this by creating a TYPE_DECL as
898 if the user had written `typedef struct S S'. Create and return
899 the TYPE_DECL for TYPE. */
902 create_implicit_typedef (tree name
, tree type
)
906 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
907 DECL_ARTIFICIAL (decl
) = 1;
908 /* There are other implicit type declarations, like the one *within*
909 a class that allows you to write `S::S'. We must distinguish
911 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
912 TYPE_NAME (type
) = decl
;
913 TYPE_STUB_DECL (type
) = decl
;
918 /* Remember a local name for name-mangling purposes. */
921 push_local_name (tree decl
)
926 timevar_start (TV_NAME_LOOKUP
);
928 name
= DECL_NAME (decl
);
930 nelts
= vec_safe_length (local_names
);
931 for (i
= 0; i
< nelts
; i
++)
933 t
= (*local_names
)[i
];
934 if (DECL_NAME (t
) == name
)
936 if (!DECL_LANG_SPECIFIC (decl
))
937 retrofit_lang_decl (decl
);
938 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
939 if (DECL_DISCRIMINATOR_SET_P (t
))
940 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
942 DECL_DISCRIMINATOR (decl
) = 1;
944 (*local_names
)[i
] = decl
;
945 timevar_stop (TV_NAME_LOOKUP
);
950 vec_safe_push (local_names
, decl
);
951 timevar_stop (TV_NAME_LOOKUP
);
954 /* Subroutine of duplicate_decls: return truthvalue of whether
955 or not types of these decls match.
957 For C++, we must compare the parameter list so that `int' can match
958 `int&' in a parameter position, but `int&' is not confused with
962 decls_match (tree newdecl
, tree olddecl
)
966 if (newdecl
== olddecl
)
969 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
970 /* If the two DECLs are not even the same kind of thing, we're not
971 interested in their types. */
974 gcc_assert (DECL_P (newdecl
));
976 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
978 tree f1
= TREE_TYPE (newdecl
);
979 tree f2
= TREE_TYPE (olddecl
);
980 tree p1
= TYPE_ARG_TYPES (f1
);
981 tree p2
= TYPE_ARG_TYPES (f2
);
984 /* Specializations of different templates are different functions
985 even if they have the same type. */
986 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
987 ? DECL_TI_TEMPLATE (newdecl
)
989 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
990 ? DECL_TI_TEMPLATE (olddecl
)
995 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
996 && ! (DECL_EXTERN_C_P (newdecl
)
997 && DECL_EXTERN_C_P (olddecl
)))
1000 /* A new declaration doesn't match a built-in one unless it
1001 is also extern "C". */
1002 if (DECL_IS_BUILTIN (olddecl
)
1003 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1006 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1009 /* A declaration with deduced return type should use its pre-deduction
1010 type for declaration matching. */
1011 r2
= fndecl_declared_return_type (olddecl
);
1013 if (same_type_p (TREE_TYPE (f1
), r2
))
1015 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1016 && (DECL_BUILT_IN (olddecl
)
1017 #ifndef NO_IMPLICIT_EXTERN_C
1018 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1019 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1023 types_match
= self_promoting_args_p (p1
);
1024 if (p1
== void_list_node
)
1025 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1027 #ifndef NO_IMPLICIT_EXTERN_C
1028 else if (!prototype_p (f1
)
1029 && (DECL_EXTERN_C_P (olddecl
)
1030 && DECL_IN_SYSTEM_HEADER (olddecl
)
1031 && !DECL_CLASS_SCOPE_P (olddecl
))
1032 && (DECL_EXTERN_C_P (newdecl
)
1033 && DECL_IN_SYSTEM_HEADER (newdecl
)
1034 && !DECL_CLASS_SCOPE_P (newdecl
)))
1036 types_match
= self_promoting_args_p (p2
);
1037 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1043 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1044 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1045 || comp_type_attributes (TREE_TYPE (newdecl
),
1046 TREE_TYPE (olddecl
)) != 0);
1051 /* The decls dont match if they correspond to two different versions
1052 of the same function. Disallow extern "C" functions to be
1053 versions for now. */
1055 && !DECL_EXTERN_C_P (newdecl
)
1056 && !DECL_EXTERN_C_P (olddecl
)
1057 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1059 /* Mark functions as versions if necessary. Modify the mangled decl
1060 name if necessary. */
1061 if (DECL_FUNCTION_VERSIONED (newdecl
)
1062 && DECL_FUNCTION_VERSIONED (olddecl
))
1064 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1066 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1067 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1068 mangle_decl (newdecl
);
1070 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1072 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1073 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1074 mangle_decl (olddecl
);
1076 cgraph_node::record_function_versions (olddecl
, newdecl
);
1080 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1082 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1083 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1086 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1087 DECL_TEMPLATE_PARMS (olddecl
)))
1090 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1091 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1092 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1094 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1095 DECL_TEMPLATE_RESULT (newdecl
));
1099 /* Need to check scope for variable declaration (VAR_DECL).
1100 For typedef (TYPE_DECL), scope is ignored. */
1102 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1104 Two declarations for an object with C language linkage
1105 with the same name (ignoring the namespace that qualify
1106 it) that appear in different namespace scopes refer to
1108 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1111 if (TREE_TYPE (newdecl
) == error_mark_node
)
1112 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1113 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1114 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1115 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1118 types_match
= comptypes (TREE_TYPE (newdecl
),
1119 TREE_TYPE (olddecl
),
1120 COMPARE_REDECLARATION
);
1126 /* If NEWDECL is `static' and an `extern' was seen previously,
1127 warn about it. OLDDECL is the previous declaration.
1129 Note that this does not apply to the C++ case of declaring
1130 a variable `extern const' and then later `const'.
1132 Don't complain about built-in functions, since they are beyond
1133 the user's control. */
1136 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1138 if (TREE_CODE (newdecl
) == TYPE_DECL
1139 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1140 || TREE_CODE (newdecl
) == CONST_DECL
1141 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1144 /* Don't get confused by static member functions; that's a different
1146 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1147 && DECL_STATIC_FUNCTION_P (newdecl
))
1150 /* If the old declaration was `static', or the new one isn't, then
1151 everything is OK. */
1152 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1155 /* It's OK to declare a builtin function as `static'. */
1156 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1157 && DECL_ARTIFICIAL (olddecl
))
1160 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1161 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1162 inform (DECL_SOURCE_LOCATION (olddecl
),
1163 "previous declaration of %qD", olddecl
);
1166 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1167 function templates. If their exception specifications do not
1168 match, issue a diagnostic. */
1171 check_redeclaration_exception_specification (tree new_decl
,
1174 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1175 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1177 /* Two default specs are equivalent, don't force evaluation. */
1178 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1179 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1182 maybe_instantiate_noexcept (new_decl
);
1183 maybe_instantiate_noexcept (old_decl
);
1184 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1185 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1189 If any declaration of a function has an exception-specification,
1190 all declarations, including the definition and an explicit
1191 specialization, of that function shall have an
1192 exception-specification with the same set of type-ids. */
1193 if (! DECL_IS_BUILTIN (old_decl
)
1195 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1198 = "declaration of %q+F has a different exception specifier";
1199 bool complained
= true;
1200 if (! DECL_IN_SYSTEM_HEADER (old_decl
))
1201 error (msg
, new_decl
);
1203 complained
= pedwarn (0, OPT_Wsystem_headers
, msg
, new_decl
);
1205 inform (0, "from previous declaration %q+F", old_decl
);
1209 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1210 Otherwise issue diagnostics. */
1213 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1215 old_decl
= STRIP_TEMPLATE (old_decl
);
1216 new_decl
= STRIP_TEMPLATE (new_decl
);
1217 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1218 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1220 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1221 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1223 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1225 if (DECL_BUILT_IN (old_decl
))
1227 /* Hide a built-in declaration. */
1228 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1229 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1232 /* 7.1.5 [dcl.constexpr]
1233 Note: An explicit specialization can differ from the template
1234 declaration with respect to the constexpr specifier. */
1235 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1236 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1239 error ("redeclaration %q+D differs in %<constexpr%>", new_decl
);
1240 error ("from previous declaration %q+D", old_decl
);
1246 /* DECL is a redeclaration of a function or function template. If
1247 it does have default arguments issue a diagnostic. Note: this
1248 function is used to enforce the requirements in C++11 8.3.6 about
1249 no default arguments in redeclarations. */
1252 check_redeclaration_no_default_args (tree decl
)
1254 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1256 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1257 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1258 if (TREE_PURPOSE (t
))
1260 permerror (DECL_SOURCE_LOCATION (decl
),
1261 "redeclaration of %q#D may not have default "
1267 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1268 && lookup_attribute ("gnu_inline", \
1269 DECL_ATTRIBUTES (fn)))
1271 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1272 If the redeclaration is invalid, a diagnostic is issued, and the
1273 error_mark_node is returned. Otherwise, OLDDECL is returned.
1275 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1278 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1281 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1283 unsigned olddecl_uid
= DECL_UID (olddecl
);
1284 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1285 int new_defines_function
= 0;
1286 tree new_template_info
;
1288 if (newdecl
== olddecl
)
1291 types_match
= decls_match (newdecl
, olddecl
);
1293 /* If either the type of the new decl or the type of the old decl is an
1294 error_mark_node, then that implies that we have already issued an
1295 error (earlier) for some bogus type specification, and in that case,
1296 it is rather pointless to harass the user with yet more error message
1297 about the same declaration, so just pretend the types match here. */
1298 if (TREE_TYPE (newdecl
) == error_mark_node
1299 || TREE_TYPE (olddecl
) == error_mark_node
)
1300 return error_mark_node
;
1302 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1303 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1305 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1306 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1307 && check_raw_literal_operator (olddecl
))
1308 error ("literal operator template %q+D conflicts with"
1309 " raw literal operator %qD", newdecl
, olddecl
);
1310 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1311 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1312 && check_raw_literal_operator (newdecl
))
1313 error ("raw literal operator %q+D conflicts with"
1314 " literal operator template %qD", newdecl
, olddecl
);
1317 if (DECL_P (olddecl
)
1318 && TREE_CODE (newdecl
) == FUNCTION_DECL
1319 && TREE_CODE (olddecl
) == FUNCTION_DECL
1320 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1322 if (DECL_DECLARED_INLINE_P (newdecl
)
1323 && DECL_UNINLINABLE (newdecl
)
1324 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1325 /* Already warned elsewhere. */;
1326 else if (DECL_DECLARED_INLINE_P (olddecl
)
1327 && DECL_UNINLINABLE (olddecl
)
1328 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1329 /* Already warned. */;
1330 else if (DECL_DECLARED_INLINE_P (newdecl
)
1331 && DECL_UNINLINABLE (olddecl
)
1332 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1334 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1335 OPT_Wattributes
, "function %qD redeclared as inline",
1337 inform (DECL_SOURCE_LOCATION (olddecl
),
1338 "previous declaration of %qD with attribute noinline",
1341 else if (DECL_DECLARED_INLINE_P (olddecl
)
1342 && DECL_UNINLINABLE (newdecl
)
1343 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1345 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1346 OPT_Wattributes
, "function %qD redeclared with "
1347 "attribute noinline", newdecl
))
1348 inform (DECL_SOURCE_LOCATION (olddecl
),
1349 "previous declaration of %qD was inline",
1354 /* Check for redeclaration and other discrepancies. */
1355 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1356 && DECL_ARTIFICIAL (olddecl
))
1358 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1359 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1361 /* Avoid warnings redeclaring built-ins which have not been
1362 explicitly declared. */
1363 if (DECL_ANTICIPATED (olddecl
))
1366 /* If you declare a built-in or predefined function name as static,
1367 the old definition is overridden, but optionally warn this was a
1368 bad choice of name. */
1369 if (! TREE_PUBLIC (newdecl
))
1371 warning (OPT_Wshadow
,
1372 DECL_BUILT_IN (olddecl
)
1373 ? G_("shadowing built-in function %q#D")
1374 : G_("shadowing library function %q#D"), olddecl
);
1375 /* Discard the old built-in function. */
1378 /* If the built-in is not ansi, then programs can override
1379 it even globally without an error. */
1380 else if (! DECL_BUILT_IN (olddecl
))
1381 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1382 "library function %q#D redeclared as non-function %q#D",
1385 error ("declaration of %q+#D conflicts with built-in "
1386 "declaration %q#D", newdecl
, olddecl
);
1389 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1391 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1392 error_at (DECL_SOURCE_LOCATION (newdecl
),
1393 "redeclaration of %<pragma omp declare reduction%>");
1394 inform (DECL_SOURCE_LOCATION (olddecl
),
1395 "previous %<pragma omp declare reduction%> declaration");
1396 return error_mark_node
;
1398 else if (!types_match
)
1400 /* Avoid warnings redeclaring built-ins which have not been
1401 explicitly declared. */
1402 if (DECL_ANTICIPATED (olddecl
))
1404 /* Deal with fileptr_type_node. FILE type is not known
1405 at the time we create the builtins. */
1408 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1409 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1411 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1414 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1416 tree t
= TREE_VALUE (t1
);
1419 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1420 == get_identifier ("FILE")
1421 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1423 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1425 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1426 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1427 types_match
= decls_match (newdecl
, olddecl
);
1429 return duplicate_decls (newdecl
, olddecl
,
1431 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1434 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1437 else if ((DECL_EXTERN_C_P (newdecl
)
1438 && DECL_EXTERN_C_P (olddecl
))
1439 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1440 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1442 /* A near match; override the builtin. */
1444 if (TREE_PUBLIC (newdecl
))
1445 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1446 "new declaration %q#D ambiguates built-in "
1447 "declaration %q#D", newdecl
, olddecl
);
1449 warning (OPT_Wshadow
,
1450 DECL_BUILT_IN (olddecl
)
1451 ? G_("shadowing built-in function %q#D")
1452 : G_("shadowing library function %q#D"), olddecl
);
1455 /* Discard the old built-in function. */
1458 /* Replace the old RTL to avoid problems with inlining. */
1459 COPY_DECL_RTL (newdecl
, olddecl
);
1461 /* Even if the types match, prefer the new declarations type for
1462 built-ins which have not been explicitly declared, for
1463 exception lists, etc... */
1464 else if (DECL_IS_BUILTIN (olddecl
))
1466 tree type
= TREE_TYPE (newdecl
);
1467 tree attribs
= (*targetm
.merge_type_attributes
)
1468 (TREE_TYPE (olddecl
), type
);
1470 type
= cp_build_type_attribute_variant (type
, attribs
);
1471 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1474 /* If a function is explicitly declared "throw ()", propagate that to
1475 the corresponding builtin. */
1476 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1477 && DECL_ANTICIPATED (olddecl
)
1478 && TREE_NOTHROW (newdecl
)
1479 && !TREE_NOTHROW (olddecl
))
1481 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1482 tree tmpdecl
= builtin_decl_explicit (fncode
);
1483 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1484 TREE_NOTHROW (tmpdecl
) = 1;
1487 /* Whether or not the builtin can throw exceptions has no
1488 bearing on this declarator. */
1489 TREE_NOTHROW (olddecl
) = 0;
1491 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1493 /* If a builtin function is redeclared as `static', merge
1494 the declarations, but make the original one static. */
1495 DECL_THIS_STATIC (olddecl
) = 1;
1496 TREE_PUBLIC (olddecl
) = 0;
1498 /* Make the old declaration consistent with the new one so
1499 that all remnants of the builtin-ness of this function
1500 will be banished. */
1501 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1502 COPY_DECL_RTL (newdecl
, olddecl
);
1505 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1507 /* C++ Standard, 3.3, clause 4:
1508 "[Note: a namespace name or a class template name must be unique
1509 in its declarative region (7.3.2, clause 14). ]" */
1510 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1511 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1512 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1513 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1514 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1515 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1517 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1518 && TREE_CODE (newdecl
) != TYPE_DECL
)
1519 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1520 && TREE_CODE (olddecl
) != TYPE_DECL
))
1522 /* We do nothing special here, because C++ does such nasty
1523 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1524 get shadowed, and know that if we need to find a TYPE_DECL
1525 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1526 slot of the identifier. */
1530 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1531 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1532 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1533 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1537 error ("%q#D redeclared as different kind of symbol", newdecl
);
1538 if (TREE_CODE (olddecl
) == TREE_LIST
)
1539 olddecl
= TREE_VALUE (olddecl
);
1540 inform (DECL_SOURCE_LOCATION (olddecl
),
1541 "previous declaration %q#D", olddecl
);
1543 return error_mark_node
;
1545 else if (!types_match
)
1547 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1548 /* These are certainly not duplicate declarations; they're
1549 from different scopes. */
1552 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1554 /* The name of a class template may not be declared to refer to
1555 any other template, class, function, object, namespace, value,
1556 or type in the same scope. */
1557 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1558 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1560 error ("conflicting declaration of template %q+#D", newdecl
);
1561 inform (DECL_SOURCE_LOCATION (olddecl
),
1562 "previous declaration %q#D", olddecl
);
1563 return error_mark_node
;
1565 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1566 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1567 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1568 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1569 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1570 DECL_TEMPLATE_PARMS (olddecl
))
1571 /* Template functions can be disambiguated by
1573 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1574 TREE_TYPE (TREE_TYPE (olddecl
))))
1576 error ("ambiguating new declaration %q+#D", newdecl
);
1577 inform (DECL_SOURCE_LOCATION (olddecl
),
1578 "old declaration %q#D", olddecl
);
1582 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1584 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1586 error ("conflicting declaration of C function %q+#D",
1588 inform (DECL_SOURCE_LOCATION (olddecl
),
1589 "previous declaration %q#D", olddecl
);
1592 /* For function versions, params and types match, but they
1593 are not ambiguous. */
1594 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1595 && !DECL_FUNCTION_VERSIONED (olddecl
))
1596 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1597 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1599 error ("ambiguating new declaration of %q+#D", newdecl
);
1600 inform (DECL_SOURCE_LOCATION (olddecl
),
1601 "old declaration %q#D", olddecl
);
1602 return error_mark_node
;
1609 error ("conflicting declaration %q+#D", newdecl
);
1610 inform (DECL_SOURCE_LOCATION (olddecl
),
1611 "previous declaration as %q#D", olddecl
);
1612 return error_mark_node
;
1615 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1616 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1617 && (!DECL_TEMPLATE_INFO (newdecl
)
1618 || (DECL_TI_TEMPLATE (newdecl
)
1619 != DECL_TI_TEMPLATE (olddecl
))))
1620 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1621 && (!DECL_TEMPLATE_INFO (olddecl
)
1622 || (DECL_TI_TEMPLATE (olddecl
)
1623 != DECL_TI_TEMPLATE (newdecl
))))))
1624 /* It's OK to have a template specialization and a non-template
1625 with the same type, or to have specializations of two
1626 different templates with the same type. Note that if one is a
1627 specialization, and the other is an instantiation of the same
1628 template, that we do not exit at this point. That situation
1629 can occur if we instantiate a template class, and then
1630 specialize one of its methods. This situation is valid, but
1631 the declarations must be merged in the usual way. */
1633 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1634 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1635 && !DECL_USE_TEMPLATE (newdecl
))
1636 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1637 && !DECL_USE_TEMPLATE (olddecl
))))
1638 /* One of the declarations is a template instantiation, and the
1639 other is not a template at all. That's OK. */
1641 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1643 /* In [namespace.alias] we have:
1645 In a declarative region, a namespace-alias-definition can be
1646 used to redefine a namespace-alias declared in that declarative
1647 region to refer only to the namespace to which it already
1650 Therefore, if we encounter a second alias directive for the same
1651 alias, we can just ignore the second directive. */
1652 if (DECL_NAMESPACE_ALIAS (newdecl
)
1653 && (DECL_NAMESPACE_ALIAS (newdecl
)
1654 == DECL_NAMESPACE_ALIAS (olddecl
)))
1656 /* [namespace.alias]
1658 A namespace-name or namespace-alias shall not be declared as
1659 the name of any other entity in the same declarative region.
1660 A namespace-name defined at global scope shall not be
1661 declared as the name of any other entity in any global scope
1663 error ("conflicting declaration of namespace %q+D", newdecl
);
1664 inform (DECL_SOURCE_LOCATION (olddecl
),
1665 "previous declaration of namespace %qD here", olddecl
);
1666 return error_mark_node
;
1670 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1673 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1674 if (DECL_NAME (olddecl
) != NULL_TREE
)
1675 inform (DECL_SOURCE_LOCATION (olddecl
),
1676 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1677 ? G_("%q#D previously defined here")
1678 : G_("%q#D previously declared here"), olddecl
);
1679 return error_mark_node
;
1681 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1682 && DECL_INITIAL (olddecl
) != NULL_TREE
1683 && !prototype_p (TREE_TYPE (olddecl
))
1684 && prototype_p (TREE_TYPE (newdecl
)))
1686 /* Prototype decl follows defn w/o prototype. */
1687 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1688 "prototype specified for %q#D", newdecl
))
1689 inform (DECL_SOURCE_LOCATION (olddecl
),
1690 "previous non-prototype definition here");
1692 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1693 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1696 If two declarations of the same function or object
1697 specify different linkage-specifications ..., the program
1698 is ill-formed.... Except for functions with C++ linkage,
1699 a function declaration without a linkage specification
1700 shall not precede the first linkage specification for
1701 that function. A function can be declared without a
1702 linkage specification after an explicit linkage
1703 specification has been seen; the linkage explicitly
1704 specified in the earlier declaration is not affected by
1705 such a function declaration.
1707 DR 563 raises the question why the restrictions on
1708 functions should not also apply to objects. Older
1709 versions of G++ silently ignore the linkage-specification
1717 which is clearly wrong. Therefore, we now treat objects
1719 if (current_lang_depth () == 0)
1721 /* There is no explicit linkage-specification, so we use
1722 the linkage from the previous declaration. */
1723 if (!DECL_LANG_SPECIFIC (newdecl
))
1724 retrofit_lang_decl (newdecl
);
1725 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1729 error ("conflicting declaration of %q+#D with %qL linkage",
1730 newdecl
, DECL_LANGUAGE (newdecl
));
1731 inform (DECL_SOURCE_LOCATION (olddecl
),
1732 "previous declaration with %qL linkage",
1733 DECL_LANGUAGE (olddecl
));
1737 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1739 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1741 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1742 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1743 && (/* grokfndecl passes member function templates too
1744 as FUNCTION_DECLs. */
1745 DECL_TEMPLATE_INFO (olddecl
)
1747 Default arguments for a member function of a class
1748 template shall be specified on the initial declaration
1749 of the member function within the class template. */
1750 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1751 check_redeclaration_no_default_args (newdecl
);
1754 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1755 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1758 for (; t1
&& t1
!= void_list_node
;
1759 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1760 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1762 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1765 if (permerror (input_location
,
1766 "default argument given for parameter "
1767 "%d of %q#D", i
, newdecl
))
1768 inform (DECL_SOURCE_LOCATION (olddecl
),
1769 "previous specification in %q#D here",
1774 error ("default argument given for parameter %d "
1775 "of %q#D", i
, newdecl
);
1776 inform (DECL_SOURCE_LOCATION (olddecl
),
1777 "previous specification in %q#D here",
1785 /* Do not merge an implicit typedef with an explicit one. In:
1789 typedef class A A __attribute__ ((foo));
1791 the attribute should apply only to the typedef. */
1792 if (TREE_CODE (olddecl
) == TYPE_DECL
1793 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1794 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1797 /* If new decl is `static' and an `extern' was seen previously,
1799 warn_extern_redeclared_static (newdecl
, olddecl
);
1801 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1802 return error_mark_node
;
1804 /* We have committed to returning 1 at this point. */
1805 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1807 /* Now that functions must hold information normally held
1808 by field decls, there is extra work to do so that
1809 declaration information does not get destroyed during
1811 if (DECL_VINDEX (olddecl
))
1812 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1813 if (DECL_CONTEXT (olddecl
))
1814 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1815 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1816 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1817 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1818 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1819 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1820 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1821 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1822 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1823 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1824 SET_OVERLOADED_OPERATOR_CODE
1825 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1826 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1828 /* Optionally warn about more than one declaration for the same
1829 name, but don't warn about a function declaration followed by a
1831 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1832 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1833 /* Don't warn about extern decl followed by definition. */
1834 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1835 /* Don't warn about friends, let add_friend take care of it. */
1836 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1837 /* Don't warn about declaration followed by specialization. */
1838 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1839 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1841 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1842 OPT_Wredundant_decls
,
1843 "redundant redeclaration of %qD in same scope",
1845 inform (DECL_SOURCE_LOCATION (olddecl
),
1846 "previous declaration of %qD", olddecl
);
1849 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1850 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1852 if (DECL_DELETED_FN (newdecl
))
1854 error ("deleted definition of %q+D", newdecl
);
1855 inform (DECL_SOURCE_LOCATION (olddecl
),
1856 "previous declaration of %qD", olddecl
);
1858 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1862 /* Deal with C++: must preserve virtual function table size. */
1863 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1865 tree newtype
= TREE_TYPE (newdecl
);
1866 tree oldtype
= TREE_TYPE (olddecl
);
1868 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1869 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1870 CLASSTYPE_FRIEND_CLASSES (newtype
)
1871 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1873 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1876 /* Copy all the DECL_... slots specified in the new decl
1877 except for any that we copy here from the old type. */
1878 DECL_ATTRIBUTES (newdecl
)
1879 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1881 if (DECL_DECLARES_FUNCTION_P (olddecl
) && DECL_DECLARES_FUNCTION_P (newdecl
))
1883 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1884 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1885 && DECL_HIDDEN_FRIEND_P (olddecl
)
1886 && newdecl_is_friend
);
1889 DECL_ANTICIPATED (olddecl
) = 0;
1890 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
1894 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1898 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1899 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1900 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1901 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1902 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1903 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1905 DECL_ATTRIBUTES (old_result
)
1906 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1908 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1910 /* Per C++11 8.3.6/4, default arguments cannot be added in later
1911 declarations of a function template. */
1912 if (DECL_SOURCE_LOCATION (newdecl
)
1913 != DECL_SOURCE_LOCATION (olddecl
))
1914 check_redeclaration_no_default_args (newdecl
);
1916 check_default_args (newdecl
);
1918 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1919 && DECL_INITIAL (new_result
))
1921 if (DECL_INITIAL (old_result
))
1922 DECL_UNINLINABLE (old_result
) = 1;
1924 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1925 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1926 DECL_NOT_REALLY_EXTERN (old_result
)
1927 = DECL_NOT_REALLY_EXTERN (new_result
);
1928 DECL_INTERFACE_KNOWN (old_result
)
1929 = DECL_INTERFACE_KNOWN (new_result
);
1930 DECL_DECLARED_INLINE_P (old_result
)
1931 = DECL_DECLARED_INLINE_P (new_result
);
1932 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1933 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1938 DECL_DECLARED_INLINE_P (old_result
)
1939 |= DECL_DECLARED_INLINE_P (new_result
);
1940 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1941 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1942 check_redeclaration_exception_specification (newdecl
, olddecl
);
1946 /* If the new declaration is a definition, update the file and
1947 line information on the declaration, and also make
1948 the old declaration the same definition. */
1949 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1951 DECL_SOURCE_LOCATION (olddecl
)
1952 = DECL_SOURCE_LOCATION (old_result
)
1953 = DECL_SOURCE_LOCATION (newdecl
);
1954 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1955 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1958 DECL_ARGUMENTS (old_result
)
1959 = DECL_ARGUMENTS (new_result
);
1960 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1961 parm
= DECL_CHAIN (parm
))
1962 DECL_CONTEXT (parm
) = old_result
;
1971 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1972 check_redeclaration_exception_specification (newdecl
, olddecl
);
1974 /* Automatically handles default parameters. */
1975 tree oldtype
= TREE_TYPE (olddecl
);
1978 /* For typedefs use the old type, as the new type's DECL_NAME points
1979 at newdecl, which will be ggc_freed. */
1980 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1983 /* Merge the data types specified in the two decls. */
1984 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1986 if (VAR_P (newdecl
))
1988 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1989 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1990 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1991 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1992 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1993 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1995 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1996 if (DECL_LANG_SPECIFIC (olddecl
)
1997 && CP_DECL_THREADPRIVATE_P (olddecl
))
1999 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2000 if (!DECL_LANG_SPECIFIC (newdecl
))
2001 retrofit_lang_decl (newdecl
);
2003 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2007 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2009 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2010 check_default_args (newdecl
);
2012 /* Lay the type out, unless already done. */
2013 if (! same_type_p (newtype
, oldtype
)
2014 && TREE_TYPE (newdecl
) != error_mark_node
2015 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2016 layout_type (TREE_TYPE (newdecl
));
2018 if ((VAR_P (newdecl
)
2019 || TREE_CODE (newdecl
) == PARM_DECL
2020 || TREE_CODE (newdecl
) == RESULT_DECL
2021 || TREE_CODE (newdecl
) == FIELD_DECL
2022 || TREE_CODE (newdecl
) == TYPE_DECL
)
2023 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2024 layout_decl (newdecl
, 0);
2026 /* Merge the type qualifiers. */
2027 if (TREE_READONLY (newdecl
))
2028 TREE_READONLY (olddecl
) = 1;
2029 if (TREE_THIS_VOLATILE (newdecl
))
2030 TREE_THIS_VOLATILE (olddecl
) = 1;
2031 if (TREE_NOTHROW (newdecl
))
2032 TREE_NOTHROW (olddecl
) = 1;
2034 /* Merge deprecatedness. */
2035 if (TREE_DEPRECATED (newdecl
))
2036 TREE_DEPRECATED (olddecl
) = 1;
2038 /* Preserve function specific target and optimization options */
2039 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2041 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2042 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2043 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2044 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2046 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2047 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2048 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2049 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2052 /* Merge the initialization information. */
2053 if (DECL_INITIAL (newdecl
) == NULL_TREE
2054 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2056 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2057 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2058 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2060 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2061 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2065 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2067 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2068 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2069 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2070 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2071 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2072 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2073 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2074 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2075 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2076 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2077 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2078 /* Keep the old RTL. */
2079 COPY_DECL_RTL (olddecl
, newdecl
);
2081 else if (VAR_P (newdecl
)
2082 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2084 /* Keep the old RTL. We cannot keep the old RTL if the old
2085 declaration was for an incomplete object and the new
2086 declaration is not since many attributes of the RTL will
2088 COPY_DECL_RTL (olddecl
, newdecl
);
2091 /* If cannot merge, then use the new type and qualifiers,
2092 and don't preserve the old rtl. */
2095 /* Clean out any memory we had of the old declaration. */
2096 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2098 TREE_VALUE (oldstatic
) = error_mark_node
;
2100 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2101 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2102 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2103 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2106 /* Merge the storage class information. */
2107 merge_weak (newdecl
, olddecl
);
2109 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2110 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2111 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2112 if (! DECL_EXTERNAL (olddecl
))
2113 DECL_EXTERNAL (newdecl
) = 0;
2114 if (! DECL_COMDAT (olddecl
))
2115 DECL_COMDAT (newdecl
) = 0;
2117 new_template_info
= NULL_TREE
;
2118 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2120 bool new_redefines_gnu_inline
= false;
2122 if (new_defines_function
2123 && ((DECL_INTERFACE_KNOWN (olddecl
)
2124 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2125 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2126 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2127 == FUNCTION_DECL
))))
2131 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2132 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2134 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2137 if (!new_redefines_gnu_inline
)
2139 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2140 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2141 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2143 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2144 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2145 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2147 /* If the OLDDECL is an instantiation and/or specialization,
2148 then the NEWDECL must be too. But, it may not yet be marked
2149 as such if the caller has created NEWDECL, but has not yet
2150 figured out that it is a redeclaration. */
2151 if (!DECL_USE_TEMPLATE (newdecl
))
2152 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2154 /* Don't really know how much of the language-specific
2155 values we should copy from old to new. */
2156 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2157 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2158 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2159 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2161 if (LANG_DECL_HAS_MIN (newdecl
))
2163 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2164 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2165 if (DECL_TEMPLATE_INFO (newdecl
))
2167 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2168 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2169 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2170 /* Remember the presence of explicit specialization args. */
2171 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2172 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2174 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2176 /* Only functions have these fields. */
2177 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2179 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2180 DECL_BEFRIENDING_CLASSES (newdecl
)
2181 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2182 DECL_BEFRIENDING_CLASSES (olddecl
));
2183 /* DECL_THUNKS is only valid for virtual functions,
2184 otherwise it is a DECL_FRIEND_CONTEXT. */
2185 if (DECL_VIRTUAL_P (newdecl
))
2186 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2188 /* Only variables have this field. */
2189 else if (VAR_P (newdecl
)
2190 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2191 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2194 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2198 /* Merge parameter attributes. */
2199 tree oldarg
, newarg
;
2200 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2201 newarg
= DECL_ARGUMENTS(newdecl
);
2203 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2204 DECL_ATTRIBUTES (newarg
)
2205 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2206 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2209 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2210 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2212 /* If newdecl is not a specialization, then it is not a
2213 template-related function at all. And that means that we
2214 should have exited above, returning 0. */
2215 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2217 if (DECL_ODR_USED (olddecl
))
2218 /* From [temp.expl.spec]:
2220 If a template, a member template or the member of a class
2221 template is explicitly specialized then that
2222 specialization shall be declared before the first use of
2223 that specialization that would cause an implicit
2224 instantiation to take place, in every translation unit in
2225 which such a use occurs. */
2226 error ("explicit specialization of %qD after first use",
2229 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2230 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2231 && DECL_DECLARED_INLINE_P (newdecl
));
2233 /* Don't propagate visibility from the template to the
2234 specialization here. We'll do that in determine_visibility if
2236 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2238 /* [temp.expl.spec/14] We don't inline explicit specialization
2239 just because the primary template says so. */
2241 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2242 the always_inline attribute. */
2243 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2244 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2246 if (DECL_DECLARED_INLINE_P (newdecl
))
2247 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2249 DECL_ATTRIBUTES (newdecl
)
2250 = remove_attribute ("always_inline",
2251 DECL_ATTRIBUTES (newdecl
));
2254 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2256 /* Never inline re-defined extern inline functions.
2257 FIXME: this could be better handled by keeping both
2258 function as separate declarations. */
2259 DECL_UNINLINABLE (newdecl
) = 1;
2263 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2264 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2266 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2268 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2269 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2271 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2272 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2273 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2274 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2277 /* Preserve abstractness on cloned [cd]tors. */
2278 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2280 /* Update newdecl's parms to point at olddecl. */
2281 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2282 parm
= DECL_CHAIN (parm
))
2283 DECL_CONTEXT (parm
) = olddecl
;
2287 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2288 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2289 COPY_DECL_RTL (newdecl
, olddecl
);
2291 if (! types_match
|| new_defines_function
)
2293 /* These need to be copied so that the names are available.
2294 Note that if the types do match, we'll preserve inline
2295 info and other bits, but if not, we won't. */
2296 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2297 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2299 /* If redeclaring a builtin function, it stays built in
2300 if newdecl is a gnu_inline definition, or if newdecl is just
2302 if (DECL_BUILT_IN (olddecl
)
2303 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2305 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2306 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2307 /* If we're keeping the built-in definition, keep the rtl,
2308 regardless of declaration matches. */
2309 COPY_DECL_RTL (olddecl
, newdecl
);
2310 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2312 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2315 /* If a compatible prototype of these builtin functions
2316 is seen, assume the runtime implements it with the
2317 expected semantics. */
2318 case BUILT_IN_STPCPY
:
2319 if (builtin_decl_explicit_p (fncode
))
2320 set_builtin_decl_implicit_p (fncode
, true);
2323 if (builtin_decl_explicit_p (fncode
))
2324 set_builtin_decl_declared_p (fncode
, true);
2329 if (new_defines_function
)
2330 /* If defining a function declared with other language
2331 linkage, use the previously declared language linkage. */
2332 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2333 else if (types_match
)
2335 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2336 /* Don't clear out the arguments if we're just redeclaring a
2338 if (DECL_ARGUMENTS (olddecl
))
2339 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2342 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2343 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2345 /* Now preserve various other info from the definition. */
2346 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2347 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2348 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2349 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2351 /* Warn about conflicting visibility specifications. */
2352 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2353 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2354 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2356 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2357 "%qD: visibility attribute ignored because it "
2358 "conflicts with previous declaration", newdecl
))
2359 inform (DECL_SOURCE_LOCATION (olddecl
),
2360 "previous declaration of %qD", olddecl
);
2362 /* Choose the declaration which specified visibility. */
2363 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2365 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2366 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2368 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2369 so keep this behavior. */
2370 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2372 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2373 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2375 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2376 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2378 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2379 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2381 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2382 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2383 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2385 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2386 with that from NEWDECL below. */
2387 if (DECL_LANG_SPECIFIC (olddecl
))
2389 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2390 != DECL_LANG_SPECIFIC (newdecl
));
2391 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2394 /* Merge the USED information. */
2395 if (TREE_USED (olddecl
))
2396 TREE_USED (newdecl
) = 1;
2397 else if (TREE_USED (newdecl
))
2398 TREE_USED (olddecl
) = 1;
2399 if (VAR_P (newdecl
))
2401 if (DECL_READ_P (olddecl
))
2402 DECL_READ_P (newdecl
) = 1;
2403 else if (DECL_READ_P (newdecl
))
2404 DECL_READ_P (olddecl
) = 1;
2406 if (DECL_PRESERVE_P (olddecl
))
2407 DECL_PRESERVE_P (newdecl
) = 1;
2408 else if (DECL_PRESERVE_P (newdecl
))
2409 DECL_PRESERVE_P (olddecl
) = 1;
2411 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2412 to olddecl and deleted. */
2413 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2414 && DECL_FUNCTION_VERSIONED (olddecl
))
2416 /* Set the flag for newdecl so that it gets copied to olddecl. */
2417 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2418 /* newdecl will be purged after copying to olddecl and is no longer
2420 cgraph_node::delete_function_version (newdecl
);
2423 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2426 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2428 function_size
= sizeof (struct tree_decl_common
);
2430 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2431 (char *) newdecl
+ sizeof (struct tree_common
),
2432 function_size
- sizeof (struct tree_common
));
2434 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2435 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2436 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2438 /* Preserve symtab node mapping. */
2439 olddecl
->decl_with_vis
.symtab_node
= snode
;
2441 if (new_template_info
)
2442 /* If newdecl is a template instantiation, it is possible that
2443 the following sequence of events has occurred:
2445 o A friend function was declared in a class template. The
2446 class template was instantiated.
2448 o The instantiation of the friend declaration was
2449 recorded on the instantiation list, and is newdecl.
2451 o Later, however, instantiate_class_template called pushdecl
2452 on the newdecl to perform name injection. But, pushdecl in
2453 turn called duplicate_decls when it discovered that another
2454 declaration of a global function with the same name already
2457 o Here, in duplicate_decls, we decided to clobber newdecl.
2459 If we're going to do that, we'd better make sure that
2460 olddecl, and not newdecl, is on the list of
2461 instantiations so that if we try to do the instantiation
2462 again we won't get the clobbered declaration. */
2463 reregister_specialization (newdecl
,
2469 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2471 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2472 (char *) newdecl
+ sizeof (struct tree_common
),
2473 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2474 switch (TREE_CODE (newdecl
))
2484 struct symtab_node
*snode
= NULL
;
2487 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2488 || DECL_EXTERNAL (olddecl
)))
2489 snode
= symtab_node::get (olddecl
);
2490 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2491 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2492 size
- sizeof (struct tree_decl_common
)
2493 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2494 if (VAR_P (newdecl
))
2495 olddecl
->decl_with_vis
.symtab_node
= snode
;
2499 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2500 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2501 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2502 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2507 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2509 if (DECL_EXTERNAL (olddecl
)
2510 || TREE_PUBLIC (olddecl
)
2511 || TREE_STATIC (olddecl
))
2513 /* Merge the section attribute.
2514 We want to issue an error if the sections conflict but that must be
2515 done later in decl_attributes since we are called before attributes
2517 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2518 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2520 if (DECL_ONE_ONLY (newdecl
))
2522 struct symtab_node
*oldsym
, *newsym
;
2523 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2524 oldsym
= cgraph_node::get_create (olddecl
);
2526 oldsym
= varpool_node::get_create (olddecl
);
2527 newsym
= symtab_node::get (newdecl
);
2528 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2533 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2535 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2536 if (!processing_template_decl
)
2537 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2541 DECL_UID (olddecl
) = olddecl_uid
;
2543 DECL_FRIEND_P (olddecl
) = 1;
2546 DECL_ANTICIPATED (olddecl
) = 1;
2547 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2550 /* NEWDECL contains the merged attribute lists.
2551 Update OLDDECL to be the same. */
2552 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2554 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2555 so that encode_section_info has a chance to look at the new decl
2556 flags and attributes. */
2557 if (DECL_RTL_SET_P (olddecl
)
2558 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2560 && TREE_STATIC (olddecl
))))
2561 make_decl_rtl (olddecl
);
2563 /* The NEWDECL will no longer be needed. Because every out-of-class
2564 declaration of a member results in a call to duplicate_decls,
2565 freeing these nodes represents in a significant savings.
2567 Before releasing the node, be sore to remove function from symbol
2568 table that might have been inserted there to record comdat group.
2569 Be sure to however do not free DECL_STRUCT_FUNCTION becuase this
2570 structure is shared in between newdecl and oldecl. */
2571 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2572 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2573 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2575 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2584 /* Return zero if the declaration NEWDECL is valid
2585 when the declaration OLDDECL (assumed to be for the same name)
2586 has already been seen.
2587 Otherwise return an error message format string with a %s
2588 where the identifier should go. */
2591 redeclaration_error_message (tree newdecl
, tree olddecl
)
2593 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2595 /* Because C++ can put things into name space for free,
2596 constructs like "typedef struct foo { ... } foo"
2597 would look like an erroneous redeclaration. */
2598 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2601 return G_("redefinition of %q#D");
2603 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2605 /* If this is a pure function, its olddecl will actually be
2606 the original initialization to `0' (which we force to call
2607 abort()). Don't complain about redefinition in this case. */
2608 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2609 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2612 /* If both functions come from different namespaces, this is not
2613 a redeclaration - this is a conflict with a used function. */
2614 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2615 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2616 && ! decls_match (olddecl
, newdecl
))
2617 return G_("%qD conflicts with used function");
2619 /* We'll complain about linkage mismatches in
2620 warn_extern_redeclared_static. */
2622 /* Defining the same name twice is no good. */
2623 if (DECL_INITIAL (olddecl
) != NULL_TREE
2624 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2626 if (DECL_NAME (olddecl
) == NULL_TREE
)
2627 return G_("%q#D not declared in class");
2628 else if (!GNU_INLINE_P (olddecl
)
2629 || GNU_INLINE_P (newdecl
))
2630 return G_("redefinition of %q#D");
2633 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2635 bool olda
= GNU_INLINE_P (olddecl
);
2636 bool newa
= GNU_INLINE_P (newdecl
);
2641 return G_("%q+D redeclared inline with "
2642 "%<gnu_inline%> attribute");
2644 return G_("%q+D redeclared inline without "
2645 "%<gnu_inline%> attribute");
2649 check_abi_tag_redeclaration
2650 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2651 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2655 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2659 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2661 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2662 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2663 return G_("redefinition of %q#D");
2667 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2668 || (DECL_TEMPLATE_RESULT (newdecl
)
2669 == DECL_TEMPLATE_RESULT (olddecl
)))
2672 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2673 if (DECL_TEMPLATE_INFO (nt
))
2674 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2675 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2676 if (DECL_TEMPLATE_INFO (ot
))
2677 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2678 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2679 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2680 return G_("redefinition of %q#D");
2682 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2684 bool olda
= GNU_INLINE_P (ot
);
2685 bool newa
= GNU_INLINE_P (nt
);
2690 return G_("%q+D redeclared inline with "
2691 "%<gnu_inline%> attribute");
2693 return G_("%q+D redeclared inline without "
2694 "%<gnu_inline%> attribute");
2698 /* Core issue #226 (C++0x):
2700 If a friend function template declaration specifies a
2701 default template-argument, that declaration shall be a
2702 definition and shall be the only declaration of the
2703 function template in the translation unit. */
2704 if ((cxx_dialect
!= cxx98
)
2705 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2706 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2707 /*is_primary=*/true,
2708 /*is_partial=*/false,
2709 /*is_friend_decl=*/2))
2710 return G_("redeclaration of friend %q#D "
2711 "may not have default template arguments");
2715 else if (VAR_P (newdecl
)
2716 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2717 && (! DECL_LANG_SPECIFIC (olddecl
)
2718 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2719 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2721 /* Only variables can be thread-local, and all declarations must
2722 agree on this property. */
2723 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2724 return G_("thread-local declaration of %q#D follows "
2725 "non-thread-local declaration");
2727 return G_("non-thread-local declaration of %q#D follows "
2728 "thread-local declaration");
2730 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2732 /* The objects have been declared at namespace scope. If either
2733 is a member of an anonymous union, then this is an invalid
2734 redeclaration. For example:
2740 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2741 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2742 return G_("redeclaration of %q#D");
2743 /* If at least one declaration is a reference, there is no
2744 conflict. For example:
2750 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2752 /* Reject two definitions. */
2753 return G_("redefinition of %q#D");
2757 /* Objects declared with block scope: */
2758 /* Reject two definitions, and reject a definition
2759 together with an external reference. */
2760 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2761 return G_("redeclaration of %q#D");
2766 /* Hash and equality functions for the named_label table. */
2769 named_label_hasher::hash (named_label_entry
*ent
)
2771 return DECL_UID (ent
->label_decl
);
2775 named_label_hasher::equal (named_label_entry
*a
, named_label_entry
*b
)
2777 return a
->label_decl
== b
->label_decl
;
2780 /* Create a new label, named ID. */
2783 make_label_decl (tree id
, int local_p
)
2785 struct named_label_entry
*ent
;
2788 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2790 DECL_CONTEXT (decl
) = current_function_decl
;
2791 DECL_MODE (decl
) = VOIDmode
;
2792 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2794 /* Say where one reference is to the label, for the sake of the
2795 error if it is not defined. */
2796 DECL_SOURCE_LOCATION (decl
) = input_location
;
2798 /* Record the fact that this identifier is bound to this label. */
2799 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2801 /* Create the label htab for the function on demand. */
2803 named_labels
= hash_table
<named_label_hasher
>::create_ggc (13);
2805 /* Record this label on the list of labels used in this function.
2806 We do this before calling make_label_decl so that we get the
2807 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2808 ent
= ggc_cleared_alloc
<named_label_entry
> ();
2809 ent
->label_decl
= decl
;
2811 named_label_entry
**slot
= named_labels
->find_slot (ent
, INSERT
);
2812 gcc_assert (*slot
== NULL
);
2818 /* Look for a label named ID in the current function. If one cannot
2819 be found, create one. (We keep track of used, but undefined,
2820 labels, and complain about them at the end of a function.) */
2823 lookup_label_1 (tree id
)
2827 /* You can't use labels at global scope. */
2828 if (current_function_decl
== NULL_TREE
)
2830 error ("label %qE referenced outside of any function", id
);
2834 /* See if we've already got this label. */
2835 decl
= IDENTIFIER_LABEL_VALUE (id
);
2836 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2839 decl
= make_label_decl (id
, /*local_p=*/0);
2843 /* Wrapper for lookup_label_1. */
2846 lookup_label (tree id
)
2849 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2850 ret
= lookup_label_1 (id
);
2851 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2855 /* Declare a local label named ID. */
2858 declare_local_label (tree id
)
2861 cp_label_binding bind
;
2863 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2864 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2865 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2867 decl
= make_label_decl (id
, /*local_p=*/1);
2869 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2874 /* Returns nonzero if it is ill-formed to jump past the declaration of
2875 DECL. Returns 2 if it's also a real problem. */
2878 decl_jump_unsafe (tree decl
)
2880 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2881 with automatic storage duration is not in scope to a point where it is
2882 in scope is ill-formed unless the variable has scalar type, class type
2883 with a trivial default constructor and a trivial destructor, a
2884 cv-qualified version of one of these types, or an array of one of the
2885 preceding types and is declared without an initializer (8.5). */
2886 tree type
= TREE_TYPE (decl
);
2888 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2889 || type
== error_mark_node
)
2892 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
2893 || variably_modified_type_p (type
, NULL_TREE
))
2896 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2902 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2905 identify_goto (tree decl
, const location_t
*locus
)
2907 bool complained
= (decl
2908 ? permerror (input_location
, "jump to label %qD", decl
)
2909 : permerror (input_location
, "jump to case label"));
2910 if (complained
&& locus
)
2911 inform (*locus
, " from here");
2915 /* Check that a single previously seen jump to a newly defined label
2916 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2917 the jump context; NAMES are the names in scope in LEVEL at the jump
2918 context; LOCUS is the source position of the jump or 0. Returns
2919 true if all is well. */
2922 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2923 bool exited_omp
, const location_t
*locus
)
2925 cp_binding_level
*b
;
2926 bool identified
= false, complained
= false;
2927 bool saw_eh
= false, saw_omp
= false;
2931 complained
= identify_goto (decl
, locus
);
2933 inform (input_location
, " exits OpenMP structured block");
2934 identified
= saw_omp
= true;
2937 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2939 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2941 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2942 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2943 : TREE_CHAIN (new_decls
)))
2945 int problem
= decl_jump_unsafe (new_decls
);
2951 complained
= identify_goto (decl
, locus
);
2957 inform (DECL_SOURCE_LOCATION (new_decls
),
2958 " crosses initialization of %q#D", new_decls
);
2960 inform (DECL_SOURCE_LOCATION (new_decls
),
2961 " enters scope of %q#D which has "
2962 "non-trivial destructor", new_decls
);
2968 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2972 complained
= identify_goto (decl
, locus
);
2977 if (b
->kind
== sk_try
)
2978 inform (input_location
, " enters try block");
2980 inform (input_location
, " enters catch block");
2984 if (b
->kind
== sk_omp
&& !saw_omp
)
2988 complained
= identify_goto (decl
, locus
);
2992 inform (input_location
, " enters OpenMP structured block");
3001 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3003 check_previous_goto_1 (decl
, use
->binding_level
,
3004 use
->names_in_scope
, use
->in_omp_scope
,
3005 &use
->o_goto_locus
);
3009 check_switch_goto (cp_binding_level
* level
)
3011 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3014 /* Check that a new jump to a label DECL is OK. Called by
3015 finish_goto_stmt. */
3018 check_goto (tree decl
)
3020 struct named_label_entry
*ent
, dummy
;
3021 bool saw_catch
= false, identified
= false, complained
= false;
3025 /* We can't know where a computed goto is jumping.
3026 So we assume that it's OK. */
3027 if (TREE_CODE (decl
) != LABEL_DECL
)
3030 /* We didn't record any information about this label when we created it,
3031 and there's not much point since it's trivial to analyze as a return. */
3032 if (decl
== cdtor_label
)
3035 dummy
.label_decl
= decl
;
3036 ent
= named_labels
->find (&dummy
);
3037 gcc_assert (ent
!= NULL
);
3039 /* If the label hasn't been defined yet, defer checking. */
3040 if (! DECL_INITIAL (decl
))
3042 struct named_label_use_entry
*new_use
;
3044 /* Don't bother creating another use if the last goto had the
3045 same data, and will therefore create the same set of errors. */
3047 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3050 new_use
= ggc_alloc
<named_label_use_entry
> ();
3051 new_use
->binding_level
= current_binding_level
;
3052 new_use
->names_in_scope
= current_binding_level
->names
;
3053 new_use
->o_goto_locus
= input_location
;
3054 new_use
->in_omp_scope
= false;
3056 new_use
->next
= ent
->uses
;
3057 ent
->uses
= new_use
;
3061 if (ent
->in_try_scope
|| ent
->in_catch_scope
3062 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3064 complained
= permerror (DECL_SOURCE_LOCATION (decl
),
3065 "jump to label %qD", decl
);
3067 inform (input_location
, " from here");
3071 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3073 int u
= decl_jump_unsafe (bad
);
3075 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3077 /* Can't skip init of __exception_info. */
3079 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3082 else if (complained
)
3085 inform (DECL_SOURCE_LOCATION (bad
),
3086 " skips initialization of %q#D", bad
);
3088 inform (DECL_SOURCE_LOCATION (bad
),
3089 " enters scope of %q#D which has "
3090 "non-trivial destructor", bad
);
3096 if (ent
->in_try_scope
)
3097 inform (input_location
, " enters try block");
3098 else if (ent
->in_catch_scope
&& !saw_catch
)
3099 inform (input_location
, " enters catch block");
3102 if (ent
->in_omp_scope
)
3105 inform (input_location
, " enters OpenMP structured block");
3107 else if (flag_openmp
)
3109 cp_binding_level
*b
;
3110 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3112 if (b
== ent
->binding_level
)
3114 if (b
->kind
== sk_omp
)
3118 complained
= permerror (DECL_SOURCE_LOCATION (decl
),
3119 "jump to label %qD", decl
);
3121 inform (input_location
, " from here");
3125 inform (input_location
, " exits OpenMP structured block");
3132 /* Check that a return is ok wrt OpenMP structured blocks.
3133 Called by finish_return_stmt. Returns true if all is well. */
3136 check_omp_return (void)
3138 cp_binding_level
*b
;
3139 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3140 if (b
->kind
== sk_omp
)
3142 error ("invalid exit from OpenMP structured block");
3145 else if (b
->kind
== sk_function_parms
)
3150 /* Define a label, specifying the location in the source file.
3151 Return the LABEL_DECL node for the label. */
3154 define_label_1 (location_t location
, tree name
)
3156 struct named_label_entry
*ent
, dummy
;
3157 cp_binding_level
*p
;
3160 decl
= lookup_label (name
);
3162 dummy
.label_decl
= decl
;
3163 ent
= named_labels
->find (&dummy
);
3164 gcc_assert (ent
!= NULL
);
3166 /* After labels, make any new cleanups in the function go into their
3167 own new (temporary) binding contour. */
3168 for (p
= current_binding_level
;
3169 p
->kind
!= sk_function_parms
;
3171 p
->more_cleanups_ok
= 0;
3173 if (name
== get_identifier ("wchar_t"))
3174 permerror (input_location
, "label named wchar_t");
3176 if (DECL_INITIAL (decl
) != NULL_TREE
)
3178 error ("duplicate label %qD", decl
);
3179 return error_mark_node
;
3183 struct named_label_use_entry
*use
;
3185 /* Mark label as having been defined. */
3186 DECL_INITIAL (decl
) = error_mark_node
;
3187 /* Say where in the source. */
3188 DECL_SOURCE_LOCATION (decl
) = location
;
3190 ent
->binding_level
= current_binding_level
;
3191 ent
->names_in_scope
= current_binding_level
->names
;
3193 for (use
= ent
->uses
; use
; use
= use
->next
)
3194 check_previous_goto (decl
, use
);
3201 /* Wrapper for define_label_1. */
3204 define_label (location_t location
, tree name
)
3207 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3208 ret
= define_label_1 (location
, name
);
3209 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3216 cp_binding_level
*level
;
3217 struct cp_switch
*next
;
3218 /* The SWITCH_STMT being built. */
3220 /* A splay-tree mapping the low element of a case range to the high
3221 element, or NULL_TREE if there is no high element. Used to
3222 determine whether or not a new case label duplicates an old case
3223 label. We need a tree, rather than simply a hash table, because
3224 of the GNU case range extension. */
3226 /* Remember whether there was a case value that is outside the
3227 range of the original type of the controlling expression. */
3228 bool outside_range_p
;
3231 /* A stack of the currently active switch statements. The innermost
3232 switch statement is on the top of the stack. There is no need to
3233 mark the stack for garbage collection because it is only active
3234 during the processing of the body of a function, and we never
3235 collect at that point. */
3237 static struct cp_switch
*switch_stack
;
3239 /* Called right after a switch-statement condition is parsed.
3240 SWITCH_STMT is the switch statement being parsed. */
3243 push_switch (tree switch_stmt
)
3245 struct cp_switch
*p
= XNEW (struct cp_switch
);
3246 p
->level
= current_binding_level
;
3247 p
->next
= switch_stack
;
3248 p
->switch_stmt
= switch_stmt
;
3249 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3250 p
->outside_range_p
= false;
3257 struct cp_switch
*cs
= switch_stack
;
3258 location_t switch_location
;
3260 /* Emit warnings as needed. */
3261 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3262 const bool bool_cond_p
3263 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3264 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3265 if (!processing_template_decl
)
3266 c_do_switch_warnings (cs
->cases
, switch_location
,
3267 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3268 SWITCH_STMT_COND (cs
->switch_stmt
),
3269 bool_cond_p
, cs
->outside_range_p
);
3271 splay_tree_delete (cs
->cases
);
3272 switch_stack
= switch_stack
->next
;
3276 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3277 condition. Note that if TYPE and VALUE are already integral we don't
3278 really do the conversion because the language-independent
3279 warning/optimization code will work better that way. */
3282 case_conversion (tree type
, tree value
)
3284 if (value
== NULL_TREE
)
3287 if (cxx_dialect
>= cxx11
3288 && (SCOPED_ENUM_P (type
)
3289 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3291 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3292 type
= type_promotes_to (type
);
3293 value
= (perform_implicit_conversion_flags
3294 (type
, value
, tf_warning_or_error
,
3295 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3297 return cxx_constant_value (value
);
3300 /* Note that we've seen a definition of a case label, and complain if this
3301 is a bad place for one. */
3304 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3307 cp_binding_level
*p
;
3310 if (processing_template_decl
)
3314 /* For templates, just add the case label; we'll do semantic
3315 analysis at instantiation-time. */
3316 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3317 return add_stmt (build_case_label (low_value
, high_value
, label
));
3320 /* Find the condition on which this switch statement depends. */
3321 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3322 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3323 cond
= TREE_VALUE (cond
);
3325 if (!check_switch_goto (switch_stack
->level
))
3326 return error_mark_node
;
3328 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3330 low_value
= case_conversion (type
, low_value
);
3331 high_value
= case_conversion (type
, high_value
);
3333 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3334 low_value
, high_value
,
3335 &switch_stack
->outside_range_p
);
3337 /* After labels, make any new cleanups in the function go into their
3338 own new (temporary) binding contour. */
3339 for (p
= current_binding_level
;
3340 p
->kind
!= sk_function_parms
;
3342 p
->more_cleanups_ok
= 0;
3347 struct typename_info
{
3355 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3357 typedef typename_info
*compare_type
;
3359 /* Hash a TYPENAME_TYPE. */
3366 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3367 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3372 /* Compare two TYPENAME_TYPEs. */
3375 equal (tree t1
, const typename_info
*t2
)
3377 return (TYPE_IDENTIFIER (t1
) == t2
->name
3378 && TYPE_CONTEXT (t1
) == t2
->scope
3379 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3380 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3381 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3385 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3386 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3388 Returns the new TYPENAME_TYPE. */
3390 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3393 build_typename_type (tree context
, tree name
, tree fullname
,
3394 enum tag_types tag_type
)
3402 if (typename_htab
== NULL
)
3403 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3405 ti
.scope
= FROB_CONTEXT (context
);
3407 ti
.template_id
= fullname
;
3408 ti
.enum_p
= tag_type
== enum_type
;
3409 ti
.class_p
= (tag_type
== class_type
3410 || tag_type
== record_type
3411 || tag_type
== union_type
);
3412 hash
= (htab_hash_pointer (ti
.scope
)
3413 ^ htab_hash_pointer (ti
.name
));
3415 /* See if we already have this type. */
3416 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3421 /* Build the TYPENAME_TYPE. */
3422 t
= cxx_make_type (TYPENAME_TYPE
);
3423 TYPE_CONTEXT (t
) = ti
.scope
;
3424 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3425 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3426 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3428 /* Build the corresponding TYPE_DECL. */
3429 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3430 TYPE_NAME (TREE_TYPE (d
)) = d
;
3431 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3432 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3433 DECL_ARTIFICIAL (d
) = 1;
3435 /* Store it in the hash table. */
3438 /* TYPENAME_TYPEs must always be compared structurally, because
3439 they may or may not resolve down to another type depending on
3440 the currently open classes. */
3441 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3447 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3448 provided to name the type. Returns an appropriate type, unless an
3449 error occurs, in which case error_mark_node is returned. If we
3450 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3451 return that, rather than the _TYPE it corresponds to, in other
3452 cases we look through the type decl. If TF_ERROR is set, complain
3453 about errors, otherwise be quiet. */
3456 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3457 tsubst_flags_t complain
)
3463 if (name
== error_mark_node
3464 || context
== NULL_TREE
3465 || context
== error_mark_node
)
3466 return error_mark_node
;
3470 if (!(TYPE_LANG_SPECIFIC (name
)
3471 && (CLASSTYPE_IS_TEMPLATE (name
)
3472 || CLASSTYPE_USE_TEMPLATE (name
))))
3473 name
= TYPE_IDENTIFIER (name
);
3475 /* Create a TEMPLATE_ID_EXPR for the type. */
3476 name
= build_nt (TEMPLATE_ID_EXPR
,
3477 CLASSTYPE_TI_TEMPLATE (name
),
3478 CLASSTYPE_TI_ARGS (name
));
3480 else if (TREE_CODE (name
) == TYPE_DECL
)
3481 name
= DECL_NAME (name
);
3485 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3487 name
= TREE_OPERAND (name
, 0);
3488 if (DECL_TYPE_TEMPLATE_P (name
))
3489 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3490 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3492 if (complain
& tf_error
)
3493 error ("%qD is not a type", name
);
3494 return error_mark_node
;
3497 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3499 if (complain
& tf_error
)
3500 error ("%qD used without template parameters", name
);
3501 return error_mark_node
;
3503 gcc_assert (identifier_p (name
));
3504 gcc_assert (TYPE_P (context
));
3506 if (!MAYBE_CLASS_TYPE_P (context
))
3508 if (complain
& tf_error
)
3509 error ("%q#T is not a class", context
);
3510 return error_mark_node
;
3513 /* When the CONTEXT is a dependent type, NAME could refer to a
3514 dependent base class of CONTEXT. But look inside it anyway
3515 if CONTEXT is a currently open scope, in case it refers to a
3516 member of the current instantiation or a non-dependent base;
3517 lookup will stop when we hit a dependent base. */
3518 if (!dependent_scope_p (context
))
3519 /* We should only set WANT_TYPE when we're a nested typename type.
3520 Then we can give better diagnostics if we find a non-type. */
3521 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3525 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3526 return build_typename_type (context
, name
, fullname
, tag_type
);
3528 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3532 if (complain
& tf_error
)
3533 error (want_template
? G_("no class template named %q#T in %q#T")
3534 : G_("no type named %q#T in %q#T"), name
, context
);
3535 return error_mark_node
;
3538 /* Pull out the template from an injected-class-name (or multiple). */
3540 t
= maybe_get_template_decl_from_type_decl (t
);
3542 if (TREE_CODE (t
) == TREE_LIST
)
3544 if (complain
& tf_error
)
3546 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3547 print_candidates (t
);
3549 return error_mark_node
;
3552 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3554 if (complain
& tf_error
)
3555 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3557 return error_mark_node
;
3559 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3561 if (complain
& tf_error
)
3562 error ("%<typename %T::%D%> names %q#T, which is not a type",
3564 return error_mark_node
;
3567 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3568 return error_mark_node
;
3570 /* If we are currently parsing a template and if T is a typedef accessed
3571 through CONTEXT then we need to remember and check access of T at
3572 template instantiation time. */
3573 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3576 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3578 /*entering_scope=*/0,
3579 complain
| tf_user
);
3581 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3584 maybe_record_typedef_use (t
);
3589 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3590 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3591 in which case error_mark_node is returned.
3593 If PARM_LIST is non-NULL, also make sure that the template parameter
3594 list of TEMPLATE_DECL matches.
3596 If COMPLAIN zero, don't complain about any errors that occur. */
3599 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3600 tsubst_flags_t complain
)
3606 name
= TYPE_IDENTIFIER (name
);
3607 else if (DECL_P (name
))
3608 name
= DECL_NAME (name
);
3609 gcc_assert (identifier_p (name
));
3611 if (!dependent_type_p (context
)
3612 || currently_open_class (context
))
3614 tree tmpl
= NULL_TREE
;
3616 if (MAYBE_CLASS_TYPE_P (context
))
3617 tmpl
= lookup_field (context
, name
, 0, false);
3619 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3620 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3622 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3624 if (complain
& tf_error
)
3625 error ("no class template named %q#T in %q#T", name
, context
);
3626 return error_mark_node
;
3630 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3632 if (complain
& tf_error
)
3634 error ("template parameters do not match template %qD", tmpl
);
3635 inform (DECL_SOURCE_LOCATION (tmpl
),
3636 "%qD declared here", tmpl
);
3638 return error_mark_node
;
3641 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3643 return error_mark_node
;
3648 /* Build the UNBOUND_CLASS_TEMPLATE. */
3649 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3650 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3651 TREE_TYPE (t
) = NULL_TREE
;
3652 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3654 /* Build the corresponding TEMPLATE_DECL. */
3655 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3656 TYPE_NAME (TREE_TYPE (d
)) = d
;
3657 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3658 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3659 DECL_ARTIFICIAL (d
) = 1;
3660 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3667 /* Push the declarations of builtin types into the namespace.
3668 RID_INDEX is the index of the builtin type in the array
3669 RID_POINTERS. NAME is the name used when looking up the builtin
3670 type. TYPE is the _TYPE node for the builtin type. */
3673 record_builtin_type (enum rid rid_index
,
3677 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3678 tree tdecl
= NULL_TREE
;
3680 if ((int) rid_index
< (int) RID_MAX
)
3681 rname
= ridpointers
[(int) rid_index
];
3683 tname
= get_identifier (name
);
3685 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3686 eliminated. Built-in types should not be looked up name; their
3687 names are keywords that the parser can recognize. However, there
3688 is code in c-common.c that uses identifier_global_value to look
3689 up built-in types by name. */
3692 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3693 DECL_ARTIFICIAL (tdecl
) = 1;
3694 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3700 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3701 DECL_ARTIFICIAL (tdecl
) = 1;
3703 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3706 if (!TYPE_NAME (type
))
3707 TYPE_NAME (type
) = tdecl
;
3710 debug_hooks
->type_decl (tdecl
, 0);
3713 /* Record one of the standard Java types.
3714 * Declare it as having the given NAME.
3715 * If SIZE > 0, it is the size of one of the integral types;
3716 * otherwise it is the negative of the size of one of the other types. */
3719 record_builtin_java_type (const char* name
, int size
)
3724 type
= build_nonstandard_integer_type (size
, 0);
3725 type
= build_distinct_type_copy (type
);
3727 else if (size
> -32)
3730 /* "__java_char" or ""__java_boolean". */
3731 type
= build_nonstandard_integer_type (-size
, 1);
3732 type
= build_distinct_type_copy (type
);
3733 /* Get the signed type cached and attached to the unsigned type,
3734 so it doesn't get garbage-collected at "random" times,
3735 causing potential codegen differences out of different UIDs
3736 and different alias set numbers. */
3737 stype
= build_nonstandard_integer_type (-size
, 0);
3738 stype
= build_distinct_type_copy (stype
);
3739 TREE_CHAIN (type
) = stype
;
3740 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3743 { /* "__java_float" or ""__java_double". */
3744 type
= make_node (REAL_TYPE
);
3745 TYPE_PRECISION (type
) = - size
;
3748 record_builtin_type (RID_MAX
, name
, type
);
3749 decl
= TYPE_NAME (type
);
3751 /* Suppress generate debug symbol entries for these types,
3752 since for normal C++ they are just clutter.
3753 However, push_lang_context undoes this if extern "Java" is seen. */
3754 DECL_IGNORED_P (decl
) = 1;
3756 TYPE_FOR_JAVA (type
) = 1;
3760 /* Push a type into the namespace so that the back ends ignore it. */
3763 record_unknown_type (tree type
, const char* name
)
3765 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3766 TYPE_DECL
, get_identifier (name
), type
));
3767 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3768 DECL_IGNORED_P (decl
) = 1;
3769 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3770 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3771 TYPE_ALIGN (type
) = 1;
3772 TYPE_USER_ALIGN (type
) = 0;
3773 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3776 /* A string for which we should create an IDENTIFIER_NODE at
3779 typedef struct predefined_identifier
3781 /* The name of the identifier. */
3782 const char *const name
;
3783 /* The place where the IDENTIFIER_NODE should be stored. */
3785 /* Nonzero if this is the name of a constructor or destructor. */
3786 const int ctor_or_dtor_p
;
3787 } predefined_identifier
;
3789 /* Create all the predefined identifiers. */
3792 initialize_predefined_identifiers (void)
3794 const predefined_identifier
*pid
;
3796 /* A table of identifiers to create at startup. */
3797 static const predefined_identifier predefined_identifiers
[] = {
3798 { "C++", &lang_name_cplusplus
, 0 },
3799 { "C", &lang_name_c
, 0 },
3800 { "Java", &lang_name_java
, 0 },
3801 /* Some of these names have a trailing space so that it is
3802 impossible for them to conflict with names written by users. */
3803 { "__ct ", &ctor_identifier
, 1 },
3804 { "__base_ctor ", &base_ctor_identifier
, 1 },
3805 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3806 { "__dt ", &dtor_identifier
, 1 },
3807 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3808 { "__base_dtor ", &base_dtor_identifier
, 1 },
3809 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3810 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3811 { "nelts", &nelts_identifier
, 0 },
3812 { THIS_NAME
, &this_identifier
, 0 },
3813 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3814 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3815 { "_vptr", &vptr_identifier
, 0 },
3816 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3817 { "::", &global_scope_name
, 0 },
3818 { "std", &std_identifier
, 0 },
3822 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3824 *pid
->node
= get_identifier (pid
->name
);
3825 if (pid
->ctor_or_dtor_p
)
3826 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3830 /* Create the predefined scalar types of C,
3831 and some nodes representing standard constants (0, 1, (void *)0).
3832 Initialize the global binding level.
3833 Make definitions for built-in primitive functions. */
3836 cxx_init_decl_processing (void)
3839 tree void_ftype_ptr
;
3841 /* Create all the identifiers we need. */
3842 initialize_predefined_identifiers ();
3844 /* Create the global variables. */
3845 push_to_top_level ();
3847 current_function_decl
= NULL_TREE
;
3848 current_binding_level
= NULL
;
3849 /* Enter the global namespace. */
3850 gcc_assert (global_namespace
== NULL_TREE
);
3851 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3853 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3854 debug_hooks
->register_main_translation_unit
3855 (DECL_CONTEXT (global_namespace
));
3856 TREE_PUBLIC (global_namespace
) = 1;
3857 begin_scope (sk_namespace
, global_namespace
);
3859 if (flag_visibility_ms_compat
)
3860 default_visibility
= VISIBILITY_HIDDEN
;
3863 current_lang_name
= lang_name_c
;
3865 /* Create the `std' namespace. */
3866 push_namespace (std_identifier
);
3867 std_node
= current_namespace
;
3870 c_common_nodes_and_builtins ();
3872 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3873 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3874 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3875 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3876 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3877 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3878 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3879 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3881 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3883 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3884 truthvalue_type_node
= boolean_type_node
;
3885 truthvalue_false_node
= boolean_false_node
;
3886 truthvalue_true_node
= boolean_true_node
;
3888 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3889 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3890 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3893 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3896 delta_type_node
= ptrdiff_type_node
;
3897 vtable_index_type
= ptrdiff_type_node
;
3899 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3900 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3901 void_ftype_ptr
= build_function_type_list (void_type_node
,
3902 ptr_type_node
, NULL_TREE
);
3904 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3906 /* C++ extensions */
3908 unknown_type_node
= make_node (LANG_TYPE
);
3909 record_unknown_type (unknown_type_node
, "unknown type");
3911 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3912 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3914 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3916 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3917 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3919 init_list_type_node
= make_node (LANG_TYPE
);
3920 record_unknown_type (init_list_type_node
, "init list");
3923 /* Make sure we get a unique function type, so we can give
3924 its pointer type a name. (This wins for gdb.) */
3925 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3926 TREE_TYPE (vfunc_type
) = integer_type_node
;
3927 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3928 layout_type (vfunc_type
);
3930 vtable_entry_type
= build_pointer_type (vfunc_type
);
3932 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3935 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3936 layout_type (vtbl_type_node
);
3937 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3938 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3939 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3940 layout_type (vtbl_ptr_type_node
);
3941 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3943 push_namespace (get_identifier ("__cxxabiv1"));
3944 abi_node
= current_namespace
;
3947 global_type_node
= make_node (LANG_TYPE
);
3948 record_unknown_type (global_type_node
, "global type");
3951 current_lang_name
= lang_name_cplusplus
;
3954 tree newattrs
, extvisattr
;
3955 tree newtype
, deltype
;
3956 tree ptr_ftype_sizetype
;
3960 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3961 if (cxx_dialect
== cxx98
)
3964 tree bad_alloc_type_node
;
3965 tree bad_alloc_decl
;
3967 push_namespace (std_identifier
);
3968 bad_alloc_id
= get_identifier ("bad_alloc");
3969 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3970 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3972 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3973 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3977 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3980 new_eh_spec
= noexcept_false_spec
;
3982 /* Ensure attribs.c is initialized. */
3984 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3986 newattrs
= tree_cons (get_identifier ("alloc_size"),
3987 build_tree_list (NULL_TREE
, integer_one_node
),
3989 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3990 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3991 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3992 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3993 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
3994 DECL_IS_MALLOC (opnew
) = 1;
3995 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3996 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
3997 DECL_IS_MALLOC (opnew
) = 1;
3998 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3999 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4000 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4001 if (flag_sized_deallocation
)
4003 /* Also push the sized deallocation variants:
4004 void operator delete(void*, std::size_t) throw();
4005 void operator delete[](void*, std::size_t) throw(); */
4006 tree void_ftype_ptr_size
4007 = build_function_type_list (void_type_node
, ptr_type_node
,
4008 size_type_node
, NULL_TREE
);
4009 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4011 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4012 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4013 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4016 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4017 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4018 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4019 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4020 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4021 if (abi_version_at_least (9))
4022 TYPE_ALIGN (nullptr_type_node
) = GET_MODE_ALIGNMENT (ptr_mode
);
4023 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4024 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4025 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4029 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4030 ECF_NORETURN
| ECF_NOTHROW
);
4032 /* Perform other language dependent initializations. */
4033 init_class_processing ();
4034 init_rtti_processing ();
4035 init_template_processing ();
4037 if (flag_exceptions
)
4038 init_exception_processing ();
4040 if (! supports_one_only ())
4043 make_fname_decl
= cp_make_fname_decl
;
4044 start_fname_decls ();
4046 /* Show we use EH for cleanups. */
4047 if (flag_exceptions
)
4048 using_eh_for_cleanups ();
4051 /* Generate an initializer for a function naming variable from
4052 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4053 filled in with the type of the init. */
4056 cp_fname_init (const char* name
, tree
*type_p
)
4058 tree domain
= NULL_TREE
;
4060 tree init
= NULL_TREE
;
4065 length
= strlen (name
);
4066 domain
= build_index_type (size_int (length
));
4067 init
= build_string (length
+ 1, name
);
4070 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4071 type
= build_cplus_array_type (type
, domain
);
4076 TREE_TYPE (init
) = type
;
4078 init
= error_mark_node
;
4083 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4084 the decl, LOC is the location to give the decl, NAME is the
4085 initialization string and TYPE_DEP indicates whether NAME depended
4086 on the type of the function. We make use of that to detect
4087 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4088 at the point of first use, so we mustn't push the decl now. */
4091 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4093 const char *const name
= (type_dep
&& processing_template_decl
4094 ? NULL
: fname_as_string (type_dep
));
4096 tree init
= cp_fname_init (name
, &type
);
4097 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4100 free (CONST_CAST (char *, name
));
4102 /* As we're using pushdecl_with_scope, we must set the context. */
4103 DECL_CONTEXT (decl
) = current_function_decl
;
4105 TREE_STATIC (decl
) = 1;
4106 TREE_READONLY (decl
) = 1;
4107 DECL_ARTIFICIAL (decl
) = 1;
4109 TREE_USED (decl
) = 1;
4111 if (current_function_decl
)
4113 cp_binding_level
*b
= current_binding_level
;
4114 if (b
->kind
== sk_function_parms
)
4115 return error_mark_node
;
4116 while (b
->level_chain
->kind
!= sk_function_parms
)
4118 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
4119 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
4120 LOOKUP_ONLYCONVERTING
);
4124 DECL_THIS_STATIC (decl
) = true;
4125 pushdecl_top_level_and_finish (decl
, init
);
4132 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4134 tree id
= DECL_NAME (decl
);
4135 const char *name
= IDENTIFIER_POINTER (id
);
4137 retrofit_lang_decl (decl
);
4139 DECL_ARTIFICIAL (decl
) = 1;
4140 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
4141 SET_DECL_LANGUAGE (decl
, lang_c
);
4142 /* Runtime library routines are, by definition, available in an
4143 external shared object. */
4144 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4145 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4147 DECL_CONTEXT (decl
) = context
;
4150 pushdecl_top_level (decl
);
4154 /* A function in the user's namespace should have an explicit
4155 declaration before it is used. Mark the built-in function as
4156 anticipated but not actually declared. */
4157 if (name
[0] != '_' || name
[1] != '_')
4158 DECL_ANTICIPATED (decl
) = 1;
4159 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4161 size_t len
= strlen (name
);
4163 /* Treat __*_chk fortification functions as anticipated as well,
4164 unless they are __builtin_*. */
4165 if (len
> strlen ("___chk")
4166 && memcmp (name
+ len
- strlen ("_chk"),
4167 "_chk", strlen ("_chk") + 1) == 0)
4168 DECL_ANTICIPATED (decl
) = 1;
4175 cxx_builtin_function (tree decl
)
4177 tree id
= DECL_NAME (decl
);
4178 const char *name
= IDENTIFIER_POINTER (id
);
4179 /* All builtins that don't begin with an '_' should additionally
4180 go in the 'std' namespace. */
4183 tree decl2
= copy_node(decl
);
4184 push_namespace (std_identifier
);
4185 builtin_function_1 (decl2
, std_node
, false);
4189 return builtin_function_1 (decl
, NULL_TREE
, false);
4192 /* Like cxx_builtin_function, but guarantee the function is added to the global
4193 scope. This is to allow function specific options to add new machine
4194 dependent builtins when the target ISA changes via attribute((target(...)))
4195 which saves space on program startup if the program does not use non-generic
4199 cxx_builtin_function_ext_scope (tree decl
)
4202 tree id
= DECL_NAME (decl
);
4203 const char *name
= IDENTIFIER_POINTER (id
);
4204 /* All builtins that don't begin with an '_' should additionally
4205 go in the 'std' namespace. */
4208 tree decl2
= copy_node(decl
);
4209 push_namespace (std_identifier
);
4210 builtin_function_1 (decl2
, std_node
, true);
4214 return builtin_function_1 (decl
, NULL_TREE
, true);
4217 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4218 function. Not called directly. */
4221 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4224 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4225 DECL_EXTERNAL (fn
) = 1;
4226 TREE_PUBLIC (fn
) = 1;
4227 DECL_ARTIFICIAL (fn
) = 1;
4228 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4229 SET_DECL_LANGUAGE (fn
, lang_c
);
4230 /* Runtime library routines are, by definition, available in an
4231 external shared object. */
4232 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4233 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4234 set_call_expr_flags (fn
, ecf_flags
);
4238 /* Returns the _DECL for a library function with C++ linkage. */
4241 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4244 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4245 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4246 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4250 /* Like build_library_fn, but takes a C string instead of an
4254 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4256 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4259 /* Like build_cp_library_fn, but takes a C string instead of an
4263 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4265 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4269 /* Like build_library_fn, but also pushes the function so that we will
4270 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4271 may throw exceptions listed in RAISES. */
4274 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4279 type
= build_exception_variant (type
, raises
);
4281 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4282 pushdecl_top_level (fn
);
4286 /* Like build_cp_library_fn, but also pushes the function so that it
4287 will be found by normal lookup. */
4290 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4293 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4298 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4302 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4306 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4308 tree type
= build_function_type (void_type_node
, parmtypes
);
4309 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4312 /* Like push_library_fn, but also note that this function throws
4313 and does not return. Used for __throw_foo and the like. */
4316 push_throw_library_fn (tree name
, tree type
)
4318 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4322 /* When we call finish_struct for an anonymous union, we create
4323 default copy constructors and such. But, an anonymous union
4324 shouldn't have such things; this function undoes the damage to the
4325 anonymous union type T.
4327 (The reason that we create the synthesized methods is that we don't
4328 distinguish `union { int i; }' from `typedef union { int i; } U'.
4329 The first is an anonymous union; the second is just an ordinary
4333 fixup_anonymous_aggr (tree t
)
4337 /* Wipe out memory of synthesized methods. */
4338 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4339 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4340 TYPE_HAS_COPY_CTOR (t
) = 0;
4341 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4342 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4343 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4345 /* Splice the implicitly generated functions out of the TYPE_METHODS
4347 q
= &TYPE_METHODS (t
);
4350 if (DECL_ARTIFICIAL (*q
))
4351 *q
= TREE_CHAIN (*q
);
4353 q
= &DECL_CHAIN (*q
);
4356 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4357 if (TYPE_METHODS (t
))
4359 tree decl
= TYPE_MAIN_DECL (t
);
4361 if (TREE_CODE (t
) != UNION_TYPE
)
4362 error_at (DECL_SOURCE_LOCATION (decl
),
4363 "an anonymous struct cannot have function members");
4365 error_at (DECL_SOURCE_LOCATION (decl
),
4366 "an anonymous union cannot have function members");
4369 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4370 assignment operators (because they cannot have these methods themselves).
4371 For anonymous unions this is already checked because they are not allowed
4372 in any union, otherwise we have to check it. */
4373 if (TREE_CODE (t
) != UNION_TYPE
)
4377 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4378 if (TREE_CODE (field
) == FIELD_DECL
)
4380 type
= TREE_TYPE (field
);
4381 if (CLASS_TYPE_P (type
))
4383 if (TYPE_NEEDS_CONSTRUCTING (type
))
4384 error ("member %q+#D with constructor not allowed "
4385 "in anonymous aggregate", field
);
4386 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4387 error ("member %q+#D with destructor not allowed "
4388 "in anonymous aggregate", field
);
4389 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4390 error ("member %q+#D with copy assignment operator "
4391 "not allowed in anonymous aggregate", field
);
4397 /* Warn for an attribute located at LOCATION that appertains to the
4398 class type CLASS_TYPE that has not been properly placed after its
4399 class-key, in it class-specifier. */
4402 warn_misplaced_attr_for_class_type (source_location location
,
4405 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4407 if (warning_at (location
, OPT_Wattributes
,
4408 "attribute ignored in declaration "
4409 "of %q#T", class_type
))
4411 "attribute for %q#T must follow the %qs keyword",
4412 class_type
, class_key_or_enum_as_string (class_type
));
4415 /* Make sure that a declaration with no declarator is well-formed, i.e.
4416 just declares a tagged type or anonymous union.
4418 Returns the type declared; or NULL_TREE if none. */
4421 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4422 bool explicit_type_instantiation_p
)
4424 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4425 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4426 /* If a class, struct, or enum type is declared by the DECLSPECS
4427 (i.e, if a class-specifier, enum-specifier, or non-typename
4428 elaborated-type-specifier appears in the DECLSPECS),
4429 DECLARED_TYPE is set to the corresponding type. */
4430 tree declared_type
= NULL_TREE
;
4431 bool error_p
= false;
4433 if (declspecs
->multiple_types_p
)
4434 error ("multiple types in one declaration");
4435 else if (declspecs
->redefined_builtin_type
)
4437 if (!in_system_header_at (input_location
))
4438 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4439 "redeclaration of C++ built-in type %qT",
4440 declspecs
->redefined_builtin_type
);
4445 && TYPE_P (declspecs
->type
)
4446 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4447 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4448 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4449 declared_type
= declspecs
->type
;
4450 else if (declspecs
->type
== error_mark_node
)
4452 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4453 permerror (input_location
, "declaration does not declare anything");
4454 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4456 error ("%<auto%> can only be specified for variables "
4457 "or function declarations");
4458 return error_mark_node
;
4460 /* Check for an anonymous union. */
4461 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4462 && TYPE_ANONYMOUS_P (declared_type
))
4464 /* 7/3 In a simple-declaration, the optional init-declarator-list
4465 can be omitted only when declaring a class (clause 9) or
4466 enumeration (7.2), that is, when the decl-specifier-seq contains
4467 either a class-specifier, an elaborated-type-specifier with
4468 a class-key (9.1), or an enum-specifier. In these cases and
4469 whenever a class-specifier or enum-specifier is present in the
4470 decl-specifier-seq, the identifiers in these specifiers are among
4471 the names being declared by the declaration (as class-name,
4472 enum-names, or enumerators, depending on the syntax). In such
4473 cases, and except for the declaration of an unnamed bit-field (9.6),
4474 the decl-specifier-seq shall introduce one or more names into the
4475 program, or shall redeclare a name introduced by a previous
4476 declaration. [Example:
4477 enum { }; // ill-formed
4478 typedef class { }; // ill-formed
4482 error ("missing type-name in typedef-declaration");
4485 /* Anonymous unions are objects, so they can have specifiers. */;
4486 SET_ANON_AGGR_TYPE_P (declared_type
);
4488 if (TREE_CODE (declared_type
) != UNION_TYPE
4489 && !in_system_header_at (input_location
))
4490 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4495 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4496 error_at (declspecs
->locations
[ds_inline
],
4497 "%<inline%> can only be specified for functions");
4498 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4499 error_at (declspecs
->locations
[ds_virtual
],
4500 "%<virtual%> can only be specified for functions");
4502 && (!current_class_type
4503 || current_scope () != current_class_type
))
4504 error_at (declspecs
->locations
[ds_friend
],
4505 "%<friend%> can only be specified inside a class");
4506 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4507 error_at (declspecs
->locations
[ds_explicit
],
4508 "%<explicit%> can only be specified for constructors");
4509 else if (declspecs
->storage_class
)
4510 error_at (declspecs
->locations
[ds_storage_class
],
4511 "a storage class can only be specified for objects "
4513 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4514 error_at (declspecs
->locations
[ds_const
],
4515 "%<const%> can only be specified for objects and "
4517 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4518 error_at (declspecs
->locations
[ds_volatile
],
4519 "%<volatile%> can only be specified for objects and "
4521 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4522 error_at (declspecs
->locations
[ds_restrict
],
4523 "%<__restrict%> can only be specified for objects and "
4525 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4526 error_at (declspecs
->locations
[ds_thread
],
4527 "%<__thread%> can only be specified for objects "
4529 else if (saw_typedef
)
4530 warning_at (declspecs
->locations
[ds_typedef
], 0,
4531 "%<typedef%> was ignored in this declaration");
4532 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4533 error_at (declspecs
->locations
[ds_constexpr
],
4534 "%<constexpr%> cannot be used for type declarations");
4537 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4540 if (!CLASS_TYPE_P (declared_type
)
4541 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4542 /* For a non-template class, use the name location. */
4543 loc
= location_of (declared_type
);
4545 /* For a template class (an explicit instantiation), use the
4546 current location. */
4547 loc
= input_location
;
4549 if (explicit_type_instantiation_p
)
4550 /* [dcl.attr.grammar]/4:
4552 No attribute-specifier-seq shall appertain to an explicit
4555 if (warning_at (loc
, OPT_Wattributes
,
4556 "attribute ignored in explicit instantiation %q#T",
4559 "no attribute can be applied to "
4560 "an explicit instantiation");
4563 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4566 return declared_type
;
4569 /* Called when a declaration is seen that contains no names to declare.
4570 If its type is a reference to a structure, union or enum inherited
4571 from a containing scope, shadow that tag name for the current scope
4572 with a forward reference.
4573 If its type defines a new named structure or union
4574 or defines an enum, it is valid but we need not do anything here.
4575 Otherwise, it is an error.
4577 C++: may have to grok the declspecs to learn about static,
4578 complain for anonymous unions.
4580 Returns the TYPE declared -- or NULL_TREE if none. */
4583 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4585 tree t
= check_tag_decl (declspecs
,
4586 /*explicit_type_instantiation_p=*/false);
4591 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4594 /* This is where the variables in an anonymous union are
4595 declared. An anonymous union declaration looks like:
4597 because there is no declarator after the union, the parser
4598 sends that declaration here. */
4599 if (ANON_AGGR_TYPE_P (t
))
4601 fixup_anonymous_aggr (t
);
4603 if (TYPE_FIELDS (t
))
4605 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4606 declspecs
, NORMAL
, 0, NULL
);
4607 finish_anon_union (decl
);
4614 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4617 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4618 const cp_declarator
*declarator
,
4619 bool is_template_arg
)
4623 enum decl_context context
4624 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4625 attrs
= type_specifiers
->attributes
;
4626 type_specifiers
->attributes
= NULL_TREE
;
4627 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4628 if (attrs
&& type
!= error_mark_node
)
4630 if (CLASS_TYPE_P (type
))
4631 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4632 "outside of definition", type
);
4633 else if (MAYBE_CLASS_TYPE_P (type
))
4634 /* A template type parameter or other dependent type. */
4635 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4636 "type %qT without an associated declaration", type
);
4638 cplus_decl_attributes (&type
, attrs
, 0);
4643 /* Process a DECLARATOR for a function-scope variable declaration,
4644 namespace-scope variable declaration, or function declaration.
4645 (Function definitions go through start_function; class member
4646 declarations appearing in the body of the class go through
4647 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4648 If an error occurs, the error_mark_node is returned instead.
4650 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4651 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4652 for an explicitly defaulted function, or SD_DELETED for an explicitly
4653 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4654 implicitly initialized via a default constructor. ATTRIBUTES and
4655 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4657 The scope represented by the context of the returned DECL is pushed
4658 (if it is not the global namespace) and is assigned to
4659 *PUSHED_SCOPE_P. The caller is then responsible for calling
4660 pop_scope on *PUSHED_SCOPE_P if it is set. */
4663 start_decl (const cp_declarator
*declarator
,
4664 cp_decl_specifier_seq
*declspecs
,
4667 tree prefix_attributes
,
4668 tree
*pushed_scope_p
)
4676 *pushed_scope_p
= NULL_TREE
;
4678 /* An object declared as __attribute__((deprecated)) suppresses
4679 warnings of uses of other deprecated items. */
4680 if (lookup_attribute ("deprecated", attributes
))
4681 deprecated_state
= DEPRECATED_SUPPRESS
;
4683 attributes
= chainon (attributes
, prefix_attributes
);
4685 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4688 deprecated_state
= DEPRECATED_NORMAL
;
4690 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4691 || decl
== error_mark_node
)
4692 return error_mark_node
;
4694 context
= CP_DECL_CONTEXT (decl
);
4695 if (context
!= global_namespace
)
4696 *pushed_scope_p
= push_scope (context
);
4698 /* Is it valid for this decl to have an initializer at all?
4699 If not, set INITIALIZED to zero, which will indirectly
4700 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4702 && TREE_CODE (decl
) == TYPE_DECL
)
4704 error ("typedef %qD is initialized (use decltype instead)", decl
);
4705 return error_mark_node
;
4710 if (! toplevel_bindings_p ()
4711 && DECL_EXTERNAL (decl
))
4712 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4714 DECL_EXTERNAL (decl
) = 0;
4715 if (toplevel_bindings_p ())
4716 TREE_STATIC (decl
) = 1;
4718 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4720 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4721 record_key_method_defined (decl
);
4723 /* If this is a typedef that names the class for linkage purposes
4724 (7.1.3p8), apply any attributes directly to the type. */
4725 if (TREE_CODE (decl
) == TYPE_DECL
4726 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4727 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4728 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4732 /* Set attributes here so if duplicate decl, will have proper attributes. */
4733 cplus_decl_attributes (&decl
, attributes
, flags
);
4735 /* Dllimported symbols cannot be defined. Static data members (which
4736 can be initialized in-class and dllimported) go through grokfield,
4737 not here, so we don't need to exclude those decls when checking for
4739 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4741 error ("definition of %q#D is marked %<dllimport%>", decl
);
4742 DECL_DLLIMPORT_P (decl
) = 0;
4745 /* If #pragma weak was used, mark the decl weak now. */
4746 if (!processing_template_decl
)
4747 maybe_apply_pragma_weak (decl
);
4749 if (TREE_CODE (decl
) == FUNCTION_DECL
4750 && DECL_DECLARED_INLINE_P (decl
)
4751 && DECL_UNINLINABLE (decl
)
4752 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4753 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4754 "inline function %qD given attribute noinline", decl
);
4756 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4758 bool this_tmpl
= (processing_template_decl
4759 > template_class_depth (context
));
4762 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4763 if (field
== NULL_TREE
4764 || !(VAR_P (field
) || variable_template_p (field
)))
4765 error ("%q+#D is not a static data member of %q#T", decl
, context
);
4766 else if (variable_template_p (field
) && !this_tmpl
)
4768 if (DECL_LANG_SPECIFIC (decl
)
4769 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4770 /* OK, specialization was already checked. */;
4773 error_at (DECL_SOURCE_LOCATION (decl
),
4774 "non-member-template declaration of %qD", decl
);
4775 inform (DECL_SOURCE_LOCATION (field
), "does not match "
4776 "member template declaration here");
4777 return error_mark_node
;
4782 if (variable_template_p (field
))
4783 field
= DECL_TEMPLATE_RESULT (field
);
4785 if (DECL_CONTEXT (field
) != context
)
4787 if (!same_type_p (DECL_CONTEXT (field
), context
))
4788 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4789 "to be defined as %<%T::%D%>",
4790 DECL_CONTEXT (field
), DECL_NAME (decl
),
4791 context
, DECL_NAME (decl
));
4792 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4794 /* Static data member are tricky; an in-class initialization
4795 still doesn't provide a definition, so the in-class
4796 declaration will have DECL_EXTERNAL set, but will have an
4797 initialization. Thus, duplicate_decls won't warn
4798 about this situation, and so we check here. */
4799 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4800 error ("duplicate initialization of %qD", decl
);
4801 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4803 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4804 && !DECL_DECLARED_CONSTEXPR_P (field
))
4805 error ("%qD declared %<constexpr%> outside its class", field
);
4810 tree field
= check_classfn (context
, decl
,
4812 ? current_template_parms
4814 if (field
&& field
!= error_mark_node
4815 && duplicate_decls (decl
, field
,
4816 /*newdecl_is_friend=*/false))
4820 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4821 DECL_IN_AGGR_P (decl
) = 0;
4822 /* Do not mark DECL as an explicit specialization if it was not
4823 already marked as an instantiation; a declaration should
4824 never be marked as a specialization unless we know what
4825 template is being specialized. */
4826 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4828 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4829 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4830 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
4831 && DECL_DECLARED_INLINE_P (decl
));
4833 DECL_COMDAT (decl
) = false;
4835 /* [temp.expl.spec] An explicit specialization of a static data
4836 member of a template is a definition if the declaration
4837 includes an initializer; otherwise, it is a declaration.
4839 We check for processing_specialization so this only applies
4840 to the new specialization syntax. */
4841 if (!initialized
&& processing_specialization
)
4842 DECL_EXTERNAL (decl
) = 1;
4845 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4846 /* Aliases are definitions. */
4848 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4852 was_public
= TREE_PUBLIC (decl
);
4854 /* Enter this declaration into the symbol table. Don't push the plain
4855 VAR_DECL for a variable template. */
4856 if (!template_parm_scope_p ()
4858 decl
= maybe_push_decl (decl
);
4860 if (processing_template_decl
)
4861 decl
= push_template_decl (decl
);
4862 if (decl
== error_mark_node
)
4863 return error_mark_node
;
4866 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4867 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4869 /* This is a const variable with implicit 'static'. Set
4870 DECL_THIS_STATIC so we can tell it from variables that are
4871 !TREE_PUBLIC because of the anonymous namespace. */
4872 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4873 DECL_THIS_STATIC (decl
) = 1;
4876 if (current_function_decl
&& VAR_P (decl
)
4877 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
4880 if (CP_DECL_THREAD_LOCAL_P (decl
))
4881 error ("%qD declared %<thread_local%> in %<constexpr%> function",
4883 else if (TREE_STATIC (decl
))
4884 error ("%qD declared %<static%> in %<constexpr%> function", decl
);
4888 cp_function_chain
->invalid_constexpr
= true;
4891 if (!processing_template_decl
&& VAR_P (decl
))
4892 start_decl_1 (decl
, initialized
);
4897 /* Process the declaration of a variable DECL. INITIALIZED is true
4898 iff DECL is explicitly initialized. (INITIALIZED is false if the
4899 variable is initialized via an implicitly-called constructor.)
4900 This function must be called for ordinary variables (including, for
4901 example, implicit instantiations of templates), but must not be
4902 called for template declarations. */
4905 start_decl_1 (tree decl
, bool initialized
)
4909 bool aggregate_definition_p
;
4911 gcc_assert (!processing_template_decl
);
4913 if (error_operand_p (decl
))
4916 gcc_assert (VAR_P (decl
));
4918 type
= TREE_TYPE (decl
);
4919 complete_p
= COMPLETE_TYPE_P (type
);
4920 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4922 /* If an explicit initializer is present, or if this is a definition
4923 of an aggregate, then we need a complete type at this point.
4924 (Scalars are always complete types, so there is nothing to
4925 check.) This code just sets COMPLETE_P; errors (if necessary)
4926 are issued below. */
4927 if ((initialized
|| aggregate_definition_p
)
4929 && COMPLETE_TYPE_P (complete_type (type
)))
4932 /* We will not yet have set TREE_READONLY on DECL if the type
4933 was "const", but incomplete, before this point. But, now, we
4934 have a complete type, so we can try again. */
4935 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4939 /* Is it valid for this decl to have an initializer at all? */
4941 /* Don't allow initializations for incomplete types except for
4942 arrays which might be completed by the initialization. */
4944 ; /* A complete type is ok. */
4945 else if (type_uses_auto (type
))
4946 ; /* An auto type is ok. */
4947 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4949 error ("variable %q#D has initializer but incomplete type", decl
);
4950 type
= TREE_TYPE (decl
) = error_mark_node
;
4952 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4954 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4955 error ("elements of array %q#D have incomplete type", decl
);
4956 /* else we already gave an error in start_decl. */
4959 else if (aggregate_definition_p
&& !complete_p
)
4961 if (type_uses_auto (type
))
4962 error ("declaration of %q#D has no initializer", decl
);
4964 error ("aggregate %q#D has incomplete type and cannot be defined",
4966 /* Change the type so that assemble_variable will give
4967 DECL an rtl we can live with: (mem (const_int 0)). */
4968 type
= TREE_TYPE (decl
) = error_mark_node
;
4971 /* Create a new scope to hold this declaration if necessary.
4972 Whether or not a new scope is necessary cannot be determined
4973 until after the type has been completed; if the type is a
4974 specialization of a class template it is not until after
4975 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4976 will be set correctly. */
4977 maybe_push_cleanup_level (type
);
4980 /* Handle initialization of references. DECL, TYPE, and INIT have the
4981 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4982 but will be set to a new CLEANUP_STMT if a temporary is created
4983 that must be destroyed subsequently.
4985 Returns an initializer expression to use to initialize DECL, or
4986 NULL if the initialization can be performed statically.
4988 Quotes on semantics can be found in ARM 8.4.3. */
4991 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4993 if (init
== NULL_TREE
)
4995 if ((DECL_LANG_SPECIFIC (decl
) == 0
4996 || DECL_IN_AGGR_P (decl
) == 0)
4997 && ! DECL_THIS_EXTERN (decl
))
4998 error ("%qD declared as reference but not initialized", decl
);
5002 if (TREE_CODE (init
) == TREE_LIST
)
5003 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5004 tf_warning_or_error
);
5006 tree ttype
= TREE_TYPE (type
);
5007 if (TREE_CODE (ttype
) != ARRAY_TYPE
5008 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5009 /* Note: default conversion is only called in very special cases. */
5010 init
= decay_conversion (init
, tf_warning_or_error
);
5012 /* check_initializer handles this for non-reference variables, but for
5013 references we need to do it here or the initializer will get the
5014 incomplete array type and confuse later calls to
5015 cp_complete_array_type. */
5016 if (TREE_CODE (ttype
) == ARRAY_TYPE
5017 && TYPE_DOMAIN (ttype
) == NULL_TREE
5018 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5019 || TREE_CODE (init
) == STRING_CST
))
5021 cp_complete_array_type (&ttype
, init
, false);
5022 if (ttype
!= TREE_TYPE (type
))
5023 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5026 /* Convert INIT to the reference type TYPE. This may involve the
5027 creation of a temporary, whose lifetime must be the same as that
5028 of the reference. If so, a DECL_EXPR for the temporary will be
5029 added just after the DECL_EXPR for DECL. That's why we don't set
5030 DECL_INITIAL for local references (instead assigning to them
5031 explicitly); we need to allow the temporary to be initialized
5033 return initialize_reference (type
, init
, flags
,
5034 tf_warning_or_error
);
5037 /* Designated initializers in arrays are not supported in GNU C++.
5038 The parser cannot detect this error since it does not know whether
5039 a given brace-enclosed initializer is for a class type or for an
5040 array. This function checks that CE does not use a designated
5041 initializer. If it does, an error is issued. Returns true if CE
5042 is valid, i.e., does not have a designated initializer. */
5045 check_array_designated_initializer (constructor_elt
*ce
,
5046 unsigned HOST_WIDE_INT index
)
5048 /* Designated initializers for array elements are not supported. */
5051 /* The parser only allows identifiers as designated
5053 if (ce
->index
== error_mark_node
)
5055 error ("name used in a GNU-style designated "
5056 "initializer for an array");
5059 else if (identifier_p (ce
->index
))
5061 error ("name %qD used in a GNU-style designated "
5062 "initializer for an array", ce
->index
);
5066 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5069 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5070 && (TREE_CODE (ce_index
= maybe_constant_value (ce_index
))
5073 /* A C99 designator is OK if it matches the current index. */
5074 if (wi::eq_p (ce_index
, index
))
5077 sorry ("non-trivial designated initializers not supported");
5080 error ("C99 designator %qE is not an integral constant-expression",
5089 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5090 array until we finish parsing the initializer. If that's the
5091 situation we're in, update DECL accordingly. */
5094 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5096 tree type
= TREE_TYPE (decl
);
5098 if (TREE_CODE (type
) == ARRAY_TYPE
5099 && TYPE_DOMAIN (type
) == NULL_TREE
5100 && TREE_CODE (decl
) != TYPE_DECL
)
5102 /* do_default is really a C-ism to deal with tentative definitions.
5103 But let's leave it here to ease the eventual merge. */
5104 int do_default
= !DECL_EXTERNAL (decl
);
5105 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5108 /* Check that there are no designated initializers in INIT, as
5109 those are not supported in GNU C++, and as the middle-end
5110 will crash if presented with a non-numeric designated
5112 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5114 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5115 constructor_elt
*ce
;
5117 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5118 if (!check_array_designated_initializer (ce
, i
))
5124 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5128 error ("initializer fails to determine size of %qD", decl
);
5130 else if (failure
== 2)
5134 error ("array size missing in %qD", decl
);
5136 /* If a `static' var's size isn't known, make it extern as
5137 well as static, so it does not get allocated. If it's not
5138 `static', then don't mark it extern; finish_incomplete_decl
5139 will give it a default size and it will get allocated. */
5140 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5141 DECL_EXTERNAL (decl
) = 1;
5143 else if (failure
== 3)
5145 error ("zero-size array %qD", decl
);
5149 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5151 relayout_decl (decl
);
5155 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5156 any appropriate error messages regarding the layout. */
5159 layout_var_decl (tree decl
)
5163 type
= TREE_TYPE (decl
);
5164 if (type
== error_mark_node
)
5167 /* If we haven't already laid out this declaration, do so now.
5168 Note that we must not call complete type for an external object
5169 because it's type might involve templates that we are not
5170 supposed to instantiate yet. (And it's perfectly valid to say
5171 `extern X x' for some incomplete type `X'.) */
5172 if (!DECL_EXTERNAL (decl
))
5173 complete_type (type
);
5174 if (!DECL_SIZE (decl
)
5175 && TREE_TYPE (decl
) != error_mark_node
5176 && (COMPLETE_TYPE_P (type
)
5177 || (TREE_CODE (type
) == ARRAY_TYPE
5178 && !TYPE_DOMAIN (type
)
5179 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
5180 layout_decl (decl
, 0);
5182 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5184 /* An automatic variable with an incomplete type: that is an error.
5185 Don't talk about array types here, since we took care of that
5186 message in grokdeclarator. */
5187 error ("storage size of %qD isn%'t known", decl
);
5188 TREE_TYPE (decl
) = error_mark_node
;
5191 /* Keep this code around in case we later want to control debug info
5192 based on whether a type is "used". (jason 1999-11-11) */
5194 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5195 /* Let debugger know it should output info for this type. */
5196 note_debug_info_needed (ttype
);
5198 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5199 note_debug_info_needed (DECL_CONTEXT (decl
));
5202 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5203 && DECL_SIZE (decl
) != NULL_TREE
5204 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5206 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5207 constant_expression_warning (DECL_SIZE (decl
));
5210 error ("storage size of %qD isn%'t constant", decl
);
5211 TREE_TYPE (decl
) = error_mark_node
;
5216 /* If a local static variable is declared in an inline function, or if
5217 we have a weak definition, we must endeavor to create only one
5218 instance of the variable at link-time. */
5221 maybe_commonize_var (tree decl
)
5223 /* Static data in a function with comdat linkage also has comdat
5225 if (TREE_STATIC (decl
)
5226 /* Don't mess with __FUNCTION__. */
5227 && ! DECL_ARTIFICIAL (decl
)
5228 && DECL_FUNCTION_SCOPE_P (decl
)
5229 && vague_linkage_p (DECL_CONTEXT (decl
)))
5233 /* With weak symbols, we simply make the variable COMDAT;
5234 that will cause copies in multiple translations units to
5236 comdat_linkage (decl
);
5240 if (DECL_INITIAL (decl
) == NULL_TREE
5241 || DECL_INITIAL (decl
) == error_mark_node
)
5243 /* Without weak symbols, we can use COMMON to merge
5244 uninitialized variables. */
5245 TREE_PUBLIC (decl
) = 1;
5246 DECL_COMMON (decl
) = 1;
5250 /* While for initialized variables, we must use internal
5251 linkage -- which means that multiple copies will not
5253 TREE_PUBLIC (decl
) = 0;
5254 DECL_COMMON (decl
) = 0;
5255 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5256 "sorry: semantics of inline function static "
5257 "data %q#D are wrong (you%'ll wind up "
5258 "with multiple copies)", decl
))
5259 inform (DECL_SOURCE_LOCATION (decl
),
5260 "you can work around this by removing the initializer");
5266 /* Issue an error message if DECL is an uninitialized const variable. */
5269 check_for_uninitialized_const_var (tree decl
)
5271 tree type
= strip_array_types (TREE_TYPE (decl
));
5273 /* ``Unless explicitly declared extern, a const object does not have
5274 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5277 && TREE_CODE (type
) != REFERENCE_TYPE
5278 && (CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5279 && !DECL_INITIAL (decl
))
5281 tree field
= default_init_uninitialized_part (type
);
5285 if (CP_TYPE_CONST_P (type
))
5286 permerror (DECL_SOURCE_LOCATION (decl
),
5287 "uninitialized const %qD", decl
);
5290 error_at (DECL_SOURCE_LOCATION (decl
),
5291 "uninitialized variable %qD in %<constexpr%> function",
5293 cp_function_chain
->invalid_constexpr
= true;
5296 if (CLASS_TYPE_P (type
))
5298 tree defaulted_ctor
;
5300 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5301 "%q#T has no user-provided default constructor", type
);
5302 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5304 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5305 "constructor is not user-provided because it is "
5306 "explicitly defaulted in the class body");
5307 inform (DECL_SOURCE_LOCATION (field
),
5308 "and the implicitly-defined constructor does not "
5309 "initialize %q#D", field
);
5314 /* Structure holding the current initializer being processed by reshape_init.
5315 CUR is a pointer to the current element being processed, END is a pointer
5316 after the last element present in the initializer. */
5317 typedef struct reshape_iterator_t
5319 constructor_elt
*cur
;
5320 constructor_elt
*end
;
5323 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5325 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5326 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5327 initialized. If there are no more such fields, the return value
5331 next_initializable_field (tree field
)
5334 && (TREE_CODE (field
) != FIELD_DECL
5335 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5336 || DECL_ARTIFICIAL (field
)))
5337 field
= DECL_CHAIN (field
);
5342 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5343 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5344 INTEGER_CST representing the size of the array minus one (the maximum index),
5345 or NULL_TREE if the array was declared without specifying the size. D is
5346 the iterator within the constructor. */
5349 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5350 tsubst_flags_t complain
)
5353 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5354 unsigned HOST_WIDE_INT max_index_cst
= 0;
5355 unsigned HOST_WIDE_INT index
;
5357 /* The initializer for an array is always a CONSTRUCTOR. */
5358 new_init
= build_constructor (init_list_type_node
, NULL
);
5362 /* Minus 1 is used for zero sized arrays. */
5363 if (integer_all_onesp (max_index
))
5366 if (tree_fits_uhwi_p (max_index
))
5367 max_index_cst
= tree_to_uhwi (max_index
);
5368 /* sizetype is sign extended, not zero extended. */
5370 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5373 /* Loop until there are no more initializers. */
5375 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5379 constructor_elt
*old_cur
= d
->cur
;
5381 check_array_designated_initializer (d
->cur
, index
);
5382 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5384 if (elt_init
== error_mark_node
)
5385 return error_mark_node
;
5386 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5387 size_int (index
), elt_init
);
5388 if (!TREE_CONSTANT (elt_init
))
5389 TREE_CONSTANT (new_init
) = false;
5391 /* This can happen with an invalid initializer (c++/54501). */
5392 if (d
->cur
== old_cur
&& !sized_array_p
)
5399 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5400 Parameters are the same of reshape_init_r. */
5403 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5405 tree max_index
= NULL_TREE
;
5407 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5409 if (TYPE_DOMAIN (type
))
5410 max_index
= array_type_nelts (type
);
5412 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5415 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5416 Parameters are the same of reshape_init_r. */
5419 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5421 tree max_index
= NULL_TREE
;
5423 gcc_assert (VECTOR_TYPE_P (type
));
5425 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5427 tree value
= d
->cur
->value
;
5428 if (!same_type_p (TREE_TYPE (value
), type
))
5430 if (complain
& tf_error
)
5431 error ("invalid type %qT as initializer for a vector of type %qT",
5432 TREE_TYPE (d
->cur
->value
), type
);
5433 value
= error_mark_node
;
5439 /* For a vector, we initialize it as an array of the appropriate size. */
5440 if (VECTOR_TYPE_P (type
))
5441 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5443 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5446 /* Subroutine of reshape_init_r, processes the initializers for classes
5447 or union. Parameters are the same of reshape_init_r. */
5450 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5451 tsubst_flags_t complain
)
5456 gcc_assert (CLASS_TYPE_P (type
));
5458 /* The initializer for a class is always a CONSTRUCTOR. */
5459 new_init
= build_constructor (init_list_type_node
, NULL
);
5460 field
= next_initializable_field (TYPE_FIELDS (type
));
5466 An initializer for an aggregate member that is an
5467 empty class shall have the form of an empty
5468 initializer-list {}. */
5469 if (!first_initializer_p
)
5471 if (complain
& tf_error
)
5472 error ("initializer for %qT must be brace-enclosed", type
);
5473 return error_mark_node
;
5478 /* Loop through the initializable fields, gathering initializers. */
5479 while (d
->cur
!= d
->end
)
5482 constructor_elt
*old_cur
= d
->cur
;
5484 /* Handle designated initializers, as an extension. */
5487 if (d
->cur
->index
== error_mark_node
)
5488 return error_mark_node
;
5490 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5491 /* We already reshaped this. */
5492 gcc_assert (d
->cur
->index
== field
);
5493 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5494 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5497 if (complain
& tf_error
)
5498 error ("%<[%E] =%> used in a GNU-style designated initializer"
5499 " for class %qT", d
->cur
->index
, type
);
5500 return error_mark_node
;
5503 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5505 if (complain
& tf_error
)
5506 error ("%qT has no non-static data member named %qD", type
,
5508 return error_mark_node
;
5512 /* If we processed all the member of the class, we are done. */
5516 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5517 /*first_initializer_p=*/false, complain
);
5518 if (field_init
== error_mark_node
)
5519 return error_mark_node
;
5521 if (d
->cur
== old_cur
&& d
->cur
->index
)
5523 /* This can happen with an invalid initializer for a flexible
5524 array member (c++/54441). */
5525 if (complain
& tf_error
)
5526 error ("invalid initializer for %q#D", field
);
5527 return error_mark_node
;
5530 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5534 When a union is initialized with a brace-enclosed
5535 initializer, the braces shall only contain an
5536 initializer for the first member of the union. */
5537 if (TREE_CODE (type
) == UNION_TYPE
)
5540 field
= next_initializable_field (DECL_CHAIN (field
));
5546 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5547 designators are not valid; either complain or return true to indicate
5548 that reshape_init_r should return error_mark_node. */
5551 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5555 if (complain
& tf_error
)
5556 error ("C99 designator %qE outside aggregate initializer",
5564 /* Subroutine of reshape_init, which processes a single initializer (part of
5565 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5566 iterator within the CONSTRUCTOR which points to the initializer to process.
5567 FIRST_INITIALIZER_P is true if this is the first initializer of the
5568 outermost CONSTRUCTOR node. */
5571 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5572 tsubst_flags_t complain
)
5574 tree init
= d
->cur
->value
;
5576 if (error_operand_p (init
))
5577 return error_mark_node
;
5579 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5580 && has_designator_problem (d
, complain
))
5581 return error_mark_node
;
5583 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5585 /* A complex type can be initialized from one or two initializers,
5586 but braces are not elided. */
5588 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5590 if (CONSTRUCTOR_NELTS (init
) > 2)
5592 if (complain
& tf_error
)
5593 error ("too many initializers for %qT", type
);
5595 return error_mark_node
;
5598 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5600 vec
<constructor_elt
, va_gc
> *v
= 0;
5601 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5602 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5603 if (has_designator_problem (d
, complain
))
5604 return error_mark_node
;
5606 init
= build_constructor (init_list_type_node
, v
);
5611 /* A non-aggregate type is always initialized with a single
5613 if (!CP_AGGREGATE_TYPE_P (type
))
5615 /* It is invalid to initialize a non-aggregate type with a
5616 brace-enclosed initializer before C++0x.
5617 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5618 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5619 a CONSTRUCTOR (with a record type). */
5620 if (TREE_CODE (init
) == CONSTRUCTOR
5621 /* Don't complain about a capture-init. */
5622 && !CONSTRUCTOR_IS_DIRECT_INIT (init
)
5623 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5625 if (SCALAR_TYPE_P (type
))
5627 if (cxx_dialect
< cxx11
5628 /* Isn't value-initialization. */
5629 || CONSTRUCTOR_NELTS (init
) > 0)
5631 if (complain
& tf_error
)
5632 error ("braces around scalar initializer for type %qT",
5634 init
= error_mark_node
;
5638 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5645 /* "If T is a class type and the initializer list has a single element of
5646 type cv U, where U is T or a class derived from T, the object is
5647 initialized from that element." Even if T is an aggregate. */
5648 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5649 && first_initializer_p
5650 && d
->end
- d
->cur
== 1
5651 && reference_related_p (type
, TREE_TYPE (init
)))
5659 All implicit type conversions (clause _conv_) are considered when
5660 initializing the aggregate member with an initializer from an
5661 initializer-list. If the initializer can initialize a member,
5662 the member is initialized. Otherwise, if the member is itself a
5663 non-empty subaggregate, brace elision is assumed and the
5664 initializer is considered for the initialization of the first
5665 member of the subaggregate. */
5666 if (TREE_CODE (init
) != CONSTRUCTOR
5667 /* But don't try this for the first initializer, since that would be
5668 looking through the outermost braces; A a2 = { a1 }; is not a
5669 valid aggregate initialization. */
5670 && !first_initializer_p
5671 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5672 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5679 /* [dcl.init.string]
5681 A char array (whether plain char, signed char, or unsigned char)
5682 can be initialized by a string-literal (optionally enclosed in
5683 braces); a wchar_t array can be initialized by a wide
5684 string-literal (optionally enclosed in braces). */
5685 if (TREE_CODE (type
) == ARRAY_TYPE
5686 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5688 tree str_init
= init
;
5690 /* Strip one level of braces if and only if they enclose a single
5691 element (as allowed by [dcl.init.string]). */
5692 if (!first_initializer_p
5693 && TREE_CODE (str_init
) == CONSTRUCTOR
5694 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5696 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5699 /* If it's a string literal, then it's the initializer for the array
5700 as a whole. Otherwise, continue with normal initialization for
5701 array types (one value per array element). */
5702 if (TREE_CODE (str_init
) == STRING_CST
)
5704 if (has_designator_problem (d
, complain
))
5705 return error_mark_node
;
5711 /* The following cases are about aggregates. If we are not within a full
5712 initializer already, and there is not a CONSTRUCTOR, it means that there
5713 is a missing set of braces (that is, we are processing the case for
5714 which reshape_init exists). */
5715 if (!first_initializer_p
)
5717 if (TREE_CODE (init
) == CONSTRUCTOR
)
5719 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5720 /* There is no need to reshape pointer-to-member function
5721 initializers, as they are always constructed correctly
5722 by the front end. */
5724 else if (COMPOUND_LITERAL_P (init
))
5725 /* For a nested compound literal, there is no need to reshape since
5726 brace elision is not allowed. Even if we decided to allow it,
5727 we should add a call to reshape_init in finish_compound_literal,
5728 before calling digest_init, so changing this code would still
5729 not be necessary. */
5730 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5734 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5735 return reshape_init (type
, init
, complain
);
5739 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5743 /* Dispatch to specialized routines. */
5744 if (CLASS_TYPE_P (type
))
5745 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5746 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5747 return reshape_init_array (type
, d
, complain
);
5748 else if (VECTOR_TYPE_P (type
))
5749 return reshape_init_vector (type
, d
, complain
);
5754 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5755 brace-enclosed aggregate initializer.
5757 INIT is the CONSTRUCTOR containing the list of initializers describing
5758 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5759 It may not presently match the shape of the TYPE; for example:
5761 struct S { int a; int b; };
5762 struct S a[] = { 1, 2, 3, 4 };
5764 Here INIT will hold a vector of four elements, rather than a
5765 vector of two elements, each itself a vector of two elements. This
5766 routine transforms INIT from the former form into the latter. The
5767 revised CONSTRUCTOR node is returned. */
5770 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5772 vec
<constructor_elt
, va_gc
> *v
;
5776 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5778 v
= CONSTRUCTOR_ELTS (init
);
5780 /* An empty constructor does not need reshaping, and it is always a valid
5782 if (vec_safe_is_empty (v
))
5785 /* Recurse on this CONSTRUCTOR. */
5787 d
.end
= d
.cur
+ v
->length ();
5789 new_init
= reshape_init_r (type
, &d
, true, complain
);
5790 if (new_init
== error_mark_node
)
5791 return error_mark_node
;
5793 /* Make sure all the element of the constructor were used. Otherwise,
5794 issue an error about exceeding initializers. */
5797 if (complain
& tf_error
)
5798 error ("too many initializers for %qT", type
);
5800 return error_mark_node
;
5806 /* Verify array initializer. Returns true if errors have been reported. */
5809 check_array_initializer (tree decl
, tree type
, tree init
)
5811 tree element_type
= TREE_TYPE (type
);
5813 /* The array type itself need not be complete, because the
5814 initializer may tell us how many elements are in the array.
5815 But, the elements of the array must be complete. */
5816 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5819 error ("elements of array %q#D have incomplete type", decl
);
5821 error ("elements of array %q#T have incomplete type", type
);
5824 /* A compound literal can't have variable size. */
5826 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5827 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5829 error ("variable-sized compound literal");
5835 /* Subroutine of check_initializer; args are passed down from that function.
5836 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5839 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5842 gcc_assert (stmts_are_full_exprs_p ());
5843 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5846 /* Verify INIT (the initializer for DECL), and record the
5847 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5848 grok_reference_init.
5850 If the return value is non-NULL, it is an expression that must be
5851 evaluated dynamically to initialize DECL. */
5854 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5856 tree type
= TREE_TYPE (decl
);
5857 tree init_code
= NULL
;
5860 /* Things that are going to be initialized need to have complete
5862 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5864 if (DECL_HAS_VALUE_EXPR_P (decl
))
5866 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5867 it doesn't have storage to be initialized. */
5868 gcc_assert (init
== NULL_TREE
);
5872 if (type
== error_mark_node
)
5873 /* We will have already complained. */
5876 if (TREE_CODE (type
) == ARRAY_TYPE
)
5878 if (check_array_initializer (decl
, type
, init
))
5881 else if (!COMPLETE_TYPE_P (type
))
5883 error ("%q#D has incomplete type", decl
);
5884 TREE_TYPE (decl
) = error_mark_node
;
5888 /* There is no way to make a variable-sized class type in GNU C++. */
5889 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5891 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5893 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5894 if (SCALAR_TYPE_P (type
))
5898 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5899 init
= build_zero_init (type
, NULL_TREE
, false);
5901 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5903 error ("scalar object %qD requires one element in initializer",
5905 TREE_TYPE (decl
) = error_mark_node
;
5911 if (TREE_CODE (decl
) == CONST_DECL
)
5913 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5915 DECL_INITIAL (decl
) = init
;
5917 gcc_assert (init
!= NULL_TREE
);
5920 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5922 else if (init
|| type_build_ctor_call (type
)
5923 || TREE_CODE (type
) == REFERENCE_TYPE
)
5925 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5927 init
= grok_reference_init (decl
, type
, init
, flags
);
5928 flags
|= LOOKUP_ALREADY_DIGESTED
;
5931 check_for_uninitialized_const_var (decl
);
5932 /* Do not reshape constructors of vectors (they don't need to be
5934 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5936 if (is_std_init_list (type
))
5938 init
= perform_implicit_conversion (type
, init
,
5939 tf_warning_or_error
);
5940 flags
|= LOOKUP_ALREADY_DIGESTED
;
5942 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5944 /* Don't reshape if the class has constructors. */
5945 if (cxx_dialect
== cxx98
)
5946 error ("in C++98 %qD must be initialized by constructor, "
5950 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
5952 error ("opaque vector types cannot be initialized");
5953 init
= error_mark_node
;
5957 init
= reshape_init (type
, init
, tf_warning_or_error
);
5958 flags
|= LOOKUP_NO_NARROWING
;
5961 else if (TREE_CODE (init
) == TREE_LIST
5962 && TREE_TYPE (init
) != unknown_type_node
5963 && !MAYBE_CLASS_TYPE_P (type
))
5965 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
5967 /* We get here with code like `int a (2);' */
5968 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5969 tf_warning_or_error
);
5972 /* If DECL has an array type without a specific bound, deduce the
5973 array size from the initializer. */
5974 maybe_deduce_size_from_array_init (decl
, init
);
5975 type
= TREE_TYPE (decl
);
5976 if (type
== error_mark_node
)
5979 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5980 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5981 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5982 && CP_AGGREGATE_TYPE_P (type
)
5983 && (CLASS_TYPE_P (type
)
5984 || !TYPE_NEEDS_CONSTRUCTING (type
)
5985 || type_has_extended_temps (type
))))
5987 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5989 /* A constructor call is a non-trivial initializer even if
5990 it isn't explicitly written. */
5991 if (TREE_SIDE_EFFECTS (init_code
))
5992 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5994 /* If this is a constexpr initializer, expand_default_init will
5995 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5996 case, pull the initializer back out and pass it down into
5997 store_init_value. */
5998 while (TREE_CODE (init_code
) == EXPR_STMT
5999 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6000 init_code
= TREE_OPERAND (init_code
, 0);
6001 if (TREE_CODE (init_code
) == INIT_EXPR
)
6003 init
= TREE_OPERAND (init_code
, 1);
6004 init_code
= NULL_TREE
;
6005 /* Don't call digest_init; it's unnecessary and will complain
6006 about aggregate initialization of non-aggregate classes. */
6007 flags
|= LOOKUP_ALREADY_DIGESTED
;
6009 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6011 /* Declared constexpr, but no suitable initializer; massage
6012 init appropriately so we can pass it into store_init_value
6014 if (CLASS_TYPE_P (type
)
6015 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6017 init
= build_functional_cast (type
, init
, tf_none
);
6018 if (TREE_CODE (init
) == TARGET_EXPR
)
6019 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6021 init_code
= NULL_TREE
;
6027 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6029 /* In aggregate initialization of a variable, each element
6030 initialization is a full-expression because there is no
6031 enclosing expression. */
6032 gcc_assert (stmts_are_full_exprs_p ());
6034 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6036 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6037 && DECL_INITIAL (decl
)
6038 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6039 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6040 warning (0, "array %qD initialized by parenthesized string literal %qE",
6041 decl
, DECL_INITIAL (decl
));
6047 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6048 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6049 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6050 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6053 check_for_uninitialized_const_var (decl
);
6056 if (init
&& init
!= error_mark_node
)
6057 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6061 /* We might have set these in cp_finish_decl. */
6062 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6063 TREE_CONSTANT (decl
) = false;
6066 if (init_code
&& DECL_IN_AGGR_P (decl
))
6068 static int explained
= 0;
6070 if (cxx_dialect
< cxx11
)
6071 error ("initializer invalid for static member with constructor");
6073 error ("non-constant in-class initialization invalid for static "
6074 "member %qD", decl
);
6077 inform (input_location
,
6078 "(an out of class initialization is required)");
6087 /* If DECL is not a local variable, give it RTL. */
6090 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6092 int toplev
= toplevel_bindings_p ();
6095 /* Set the DECL_ASSEMBLER_NAME for the object. */
6098 /* The `register' keyword, when used together with an
6099 asm-specification, indicates that the variable should be
6100 placed in a particular register. */
6101 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6103 set_user_assembler_name (decl
, asmspec
);
6104 DECL_HARD_REGISTER (decl
) = 1;
6108 if (TREE_CODE (decl
) == FUNCTION_DECL
6109 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6110 set_builtin_user_assembler_name (decl
, asmspec
);
6111 set_user_assembler_name (decl
, asmspec
);
6115 /* Handle non-variables up front. */
6118 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6122 /* If we see a class member here, it should be a static data
6124 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6126 gcc_assert (TREE_STATIC (decl
));
6127 /* An in-class declaration of a static data member should be
6128 external; it is only a declaration, and not a definition. */
6129 if (init
== NULL_TREE
)
6130 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
6133 /* We don't create any RTL for local variables. */
6134 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6137 /* We defer emission of local statics until the corresponding
6138 DECL_EXPR is expanded. */
6139 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
6141 /* Defer template instantiations. */
6142 if (DECL_LANG_SPECIFIC (decl
)
6143 && DECL_IMPLICIT_INSTANTIATION (decl
))
6146 /* If we're not deferring, go ahead and assemble the variable. */
6148 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6151 /* walk_tree helper for wrap_temporary_cleanups, below. */
6154 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6156 /* Stop at types or full-expression boundaries. */
6157 if (TYPE_P (*stmt_p
)
6158 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6164 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6166 tree guard
= (tree
)data
;
6167 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6169 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6170 /* Tell honor_protect_cleanup_actions to handle this as a separate
6172 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6174 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6180 /* We're initializing a local variable which has a cleanup GUARD. If there
6181 are any temporaries used in the initializer INIT of this variable, we
6182 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6183 variable will be cleaned up properly if one of them throws.
6185 Unfortunately, there's no way to express this properly in terms of
6186 nesting, as the regions for the temporaries overlap the region for the
6187 variable itself; if there are two temporaries, the variable needs to be
6188 the first thing destroyed if either of them throws. However, we only
6189 want to run the variable's cleanup if it actually got constructed. So
6190 we need to guard the temporary cleanups with the variable's cleanup if
6191 they are run on the normal path, but not if they are run on the
6192 exceptional path. We implement this by telling
6193 honor_protect_cleanup_actions to strip the variable cleanup from the
6194 exceptional path. */
6197 wrap_temporary_cleanups (tree init
, tree guard
)
6199 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6202 /* Generate code to initialize DECL (a local variable). */
6205 initialize_local_var (tree decl
, tree init
)
6207 tree type
= TREE_TYPE (decl
);
6211 gcc_assert (VAR_P (decl
)
6212 || TREE_CODE (decl
) == RESULT_DECL
);
6213 gcc_assert (!TREE_STATIC (decl
));
6215 if (DECL_SIZE (decl
) == NULL_TREE
)
6217 /* If we used it already as memory, it must stay in memory. */
6218 DECL_INITIAL (decl
) = NULL_TREE
;
6219 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6223 if (type
== error_mark_node
)
6226 /* Compute and store the initial value. */
6227 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6228 if (TREE_USED (type
))
6229 DECL_READ_P (decl
) = 1;
6231 /* Generate a cleanup, if necessary. */
6232 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6234 /* Perform the initialization. */
6237 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6238 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6239 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6241 /* Stick simple initializers in DECL_INITIAL so that
6242 -Wno-init-self works (c++/34772). */
6243 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6244 DECL_INITIAL (decl
) = rinit
;
6246 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6250 warning_at (DECL_SOURCE_LOCATION (decl
),
6252 "reference %qD is initialized with itself", decl
);
6257 int saved_stmts_are_full_exprs_p
;
6259 /* If we're only initializing a single object, guard the
6260 destructors of any temporaries used in its initializer with
6261 its destructor. This isn't right for arrays because each
6262 element initialization is a full-expression. */
6263 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6264 wrap_temporary_cleanups (init
, cleanup
);
6266 gcc_assert (building_stmt_list_p ());
6267 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6268 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6269 finish_expr_stmt (init
);
6270 current_stmt_tree ()->stmts_are_full_exprs_p
=
6271 saved_stmts_are_full_exprs_p
;
6275 /* Set this to 0 so we can tell whether an aggregate which was
6276 initialized was ever used. Don't do this if it has a
6277 destructor, so we don't complain about the 'resource
6278 allocation is initialization' idiom. Now set
6279 attribute((unused)) on types so decls of that type will be
6280 marked used. (see TREE_USED, above.) */
6281 if (TYPE_NEEDS_CONSTRUCTING (type
)
6283 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6284 && DECL_NAME (decl
))
6285 TREE_USED (decl
) = 0;
6286 else if (already_used
)
6287 TREE_USED (decl
) = 1;
6290 finish_decl_cleanup (decl
, cleanup
);
6293 /* DECL is a VAR_DECL for a compiler-generated variable with static
6294 storage duration (like a virtual table) whose initializer is a
6295 compile-time constant. Initialize the variable and provide it to the
6299 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6302 gcc_assert (DECL_ARTIFICIAL (decl
));
6303 init
= build_constructor (TREE_TYPE (decl
), v
);
6304 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6305 DECL_INITIAL (decl
) = init
;
6306 DECL_INITIALIZED_P (decl
) = 1;
6307 determine_visibility (decl
);
6308 layout_var_decl (decl
);
6309 maybe_commonize_var (decl
);
6310 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6313 /* INIT is the initializer for a variable, as represented by the
6314 parser. Returns true iff INIT is type-dependent. */
6317 type_dependent_init_p (tree init
)
6319 if (TREE_CODE (init
) == TREE_LIST
)
6320 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6321 return any_type_dependent_elements_p (init
);
6322 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6323 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6325 vec
<constructor_elt
, va_gc
> *elts
;
6329 elts
= CONSTRUCTOR_ELTS (init
);
6330 nelts
= vec_safe_length (elts
);
6331 for (i
= 0; i
< nelts
; ++i
)
6332 if (type_dependent_init_p ((*elts
)[i
].value
))
6336 /* It must be a simple expression, e.g., int i = 3; */
6337 return type_dependent_expression_p (init
);
6342 /* INIT is the initializer for a variable, as represented by the
6343 parser. Returns true iff INIT is value-dependent. */
6346 value_dependent_init_p (tree init
)
6348 if (TREE_CODE (init
) == TREE_LIST
)
6349 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6350 return any_value_dependent_elements_p (init
);
6351 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6352 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6354 vec
<constructor_elt
, va_gc
> *elts
;
6358 elts
= CONSTRUCTOR_ELTS (init
);
6359 nelts
= vec_safe_length (elts
);
6360 for (i
= 0; i
< nelts
; ++i
)
6361 if (value_dependent_init_p ((*elts
)[i
].value
))
6365 /* It must be a simple expression, e.g., int i = 3; */
6366 return value_dependent_expression_p (init
);
6371 /* Finish processing of a declaration;
6372 install its line number and initial value.
6373 If the length of an array type is not known before,
6374 it must be determined now, from the initial value, or it is an error.
6376 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6377 true, then INIT is an integral constant expression.
6379 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6380 if the (init) syntax was used. */
6383 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6384 tree asmspec_tree
, int flags
)
6387 vec
<tree
, va_gc
> *cleanups
= NULL
;
6388 const char *asmspec
= NULL
;
6389 int was_readonly
= 0;
6390 bool var_definition_p
= false;
6393 if (decl
== error_mark_node
)
6398 error ("assignment (not initialization) in declaration");
6402 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6403 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6404 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6406 type
= TREE_TYPE (decl
);
6407 if (type
== error_mark_node
)
6410 /* If a name was specified, get the string. */
6411 if (at_namespace_scope_p ())
6412 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6413 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6414 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6416 if (current_class_type
6417 && CP_DECL_CONTEXT (decl
) == current_class_type
6418 && TYPE_BEING_DEFINED (current_class_type
)
6419 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6420 && (DECL_INITIAL (decl
) || init
))
6421 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6423 if (TREE_CODE (decl
) != FUNCTION_DECL
6424 && (auto_node
= type_uses_auto (type
)))
6427 if (init
== NULL_TREE
)
6429 if (DECL_LANG_SPECIFIC (decl
)
6430 && DECL_TEMPLATE_INSTANTIATION (decl
)
6431 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6433 /* init is null because we're deferring instantiating the
6434 initializer until we need it. Well, we need it now. */
6435 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6439 error ("declaration of %q#D has no initializer", decl
);
6440 TREE_TYPE (decl
) = error_mark_node
;
6444 if (TREE_CODE (d_init
) == TREE_LIST
)
6445 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6446 tf_warning_or_error
);
6447 d_init
= resolve_nondeduced_context (d_init
);
6448 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6450 if (type
== error_mark_node
)
6452 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6455 if (!ensure_literal_type_for_constexpr_object (decl
))
6456 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6459 && DECL_CLASS_SCOPE_P (decl
)
6460 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6461 check_static_variable_definition (decl
, type
);
6463 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6466 if (init
== ridpointers
[(int)RID_DELETE
])
6468 /* FIXME check this is 1st decl. */
6469 DECL_DELETED_FN (decl
) = 1;
6470 DECL_DECLARED_INLINE_P (decl
) = 1;
6471 DECL_INITIAL (decl
) = error_mark_node
;
6472 FOR_EACH_CLONE (clone
, decl
)
6474 DECL_DELETED_FN (clone
) = 1;
6475 DECL_DECLARED_INLINE_P (clone
) = 1;
6476 DECL_INITIAL (clone
) = error_mark_node
;
6480 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6482 if (defaultable_fn_check (decl
))
6483 DECL_DEFAULTED_FN (decl
) = 1;
6485 DECL_INITIAL (decl
) = NULL_TREE
;
6489 if (init
&& VAR_P (decl
))
6491 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6492 /* If DECL is a reference, then we want to know whether init is a
6493 reference constant; init_const_expr_p as passed tells us whether
6494 it's an rvalue constant. */
6495 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6496 init_const_expr_p
= potential_constant_expression (init
);
6497 if (init_const_expr_p
)
6499 /* Set these flags now for templates. We'll update the flags in
6500 store_init_value for instantiations. */
6501 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6502 if (decl_maybe_constant_var_p (decl
))
6503 TREE_CONSTANT (decl
) = 1;
6507 if (processing_template_decl
)
6509 bool type_dependent_p
;
6511 /* Add this declaration to the statement-tree. */
6512 if (at_function_scope_p ())
6513 add_decl_expr (decl
);
6515 type_dependent_p
= dependent_type_p (type
);
6517 if (check_for_bare_parameter_packs (init
))
6520 DECL_INITIAL (decl
) = NULL_TREE
;
6523 /* Generally, initializers in templates are expanded when the
6524 template is instantiated. But, if DECL is a variable constant
6525 then it can be used in future constant expressions, so its value
6526 must be available. */
6528 if (!VAR_P (decl
) || type_dependent_p
)
6529 /* We can't do anything if the decl has dependent type. */;
6531 && init_const_expr_p
6532 && TREE_CODE (type
) != REFERENCE_TYPE
6533 && decl_maybe_constant_var_p (decl
)
6534 && !type_dependent_init_p (init
)
6535 && !value_dependent_init_p (init
))
6537 /* This variable seems to be a non-dependent constant, so process
6538 its initializer. If check_initializer returns non-null the
6539 initialization wasn't constant after all. */
6541 cleanups
= make_tree_vector ();
6542 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6543 if (init_code
== NULL_TREE
)
6545 release_tree_vector (cleanups
);
6547 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6549 /* Deduce array size even if the initializer is dependent. */
6550 maybe_deduce_size_from_array_init (decl
, init
);
6551 /* And complain about multiple initializers. */
6552 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6553 && !MAYBE_CLASS_TYPE_P (type
))
6554 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6555 tf_warning_or_error
);
6559 DECL_INITIAL (decl
) = init
;
6563 /* Just store non-static data member initializers for later. */
6564 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6565 DECL_INITIAL (decl
) = init
;
6567 /* Take care of TYPE_DECLs up front. */
6568 if (TREE_CODE (decl
) == TYPE_DECL
)
6570 if (type
!= error_mark_node
6571 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6573 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6574 warning (0, "shadowing previous type declaration of %q#D", decl
);
6575 set_identifier_type_value (DECL_NAME (decl
), decl
);
6578 /* If we have installed this as the canonical typedef for this
6579 type, and that type has not been defined yet, delay emitting
6580 the debug information for it, as we will emit it later. */
6581 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6582 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6583 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6585 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6590 /* A reference will be modified here, as it is initialized. */
6591 if (! DECL_EXTERNAL (decl
)
6592 && TREE_READONLY (decl
)
6593 && TREE_CODE (type
) == REFERENCE_TYPE
)
6596 TREE_READONLY (decl
) = 0;
6601 /* If this is a local variable that will need a mangled name,
6602 register it now. We must do this before processing the
6603 initializer for the variable, since the initialization might
6604 require a guard variable, and since the mangled name of the
6605 guard variable will depend on the mangled name of this
6607 if (DECL_FUNCTION_SCOPE_P (decl
)
6608 && TREE_STATIC (decl
)
6609 && !DECL_ARTIFICIAL (decl
))
6611 push_local_name (decl
);
6612 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6613 || DECL_DESTRUCTOR_P (current_function_decl
))
6614 /* Normally local_decls is populated during GIMPLE lowering,
6615 but [cd]tors are never actually compiled directly. We need
6616 to put statics on the list so we can deal with the label
6617 address extension. FIXME. */
6618 add_local_decl (cfun
, decl
);
6621 /* Convert the initializer to the type of DECL, if we have not
6622 already initialized DECL. */
6623 if (!DECL_INITIALIZED_P (decl
)
6624 /* If !DECL_EXTERNAL then DECL is being defined. In the
6625 case of a static data member initialized inside the
6626 class-specifier, there can be an initializer even if DECL
6627 is *not* defined. */
6628 && (!DECL_EXTERNAL (decl
) || init
))
6630 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6633 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6634 /* Allow libjava/prims.cc define primitive classes. */
6635 if (init
!= NULL_TREE
6636 || jclass
== NULL_TREE
6637 || TREE_CODE (jclass
) != TYPE_DECL
6638 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6639 || !same_type_ignoring_top_level_qualifiers_p
6640 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6641 error ("Java object %qD not allocated with %<new%>", decl
);
6644 cleanups
= make_tree_vector ();
6645 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6651 The memory occupied by any object of static storage
6652 duration is zero-initialized at program startup before
6653 any other initialization takes place.
6655 We cannot create an appropriate initializer until after
6656 the type of DECL is finalized. If DECL_INITIAL is set,
6657 then the DECL is statically initialized, and any
6658 necessary zero-initialization has already been performed. */
6659 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6660 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6661 /*nelts=*/NULL_TREE
,
6662 /*static_storage_p=*/true);
6663 /* Remember that the initialization for this variable has
6665 DECL_INITIALIZED_P (decl
) = 1;
6666 /* This declaration is the definition of this variable,
6667 unless we are initializing a static data member within
6668 the class specifier. */
6669 if (!DECL_EXTERNAL (decl
))
6670 var_definition_p
= true;
6672 /* If the variable has an array type, lay out the type, even if
6673 there is no initializer. It is valid to index through the
6674 array, and we must get TYPE_ALIGN set correctly on the array
6676 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6679 if (TREE_STATIC (decl
)
6680 && !at_function_scope_p ()
6681 && current_function_decl
== NULL
)
6682 /* So decl is a global variable or a static member of a
6683 non local class. Record the types it uses
6684 so that we can decide later to emit debug info for them. */
6685 record_types_used_by_current_var_decl (decl
);
6687 else if (TREE_CODE (decl
) == FIELD_DECL
6688 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6689 error ("non-static data member %qD has Java class type", decl
);
6691 /* Add this declaration to the statement-tree. This needs to happen
6692 after the call to check_initializer so that the DECL_EXPR for a
6693 reference temp is added before the DECL_EXPR for the reference itself. */
6694 if (DECL_FUNCTION_SCOPE_P (decl
))
6696 /* If we're building a variable sized type, and we might be
6697 reachable other than via the top of the current binding
6698 level, then create a new BIND_EXPR so that we deallocate
6699 the object at the right time. */
6702 && !TREE_CONSTANT (DECL_SIZE (decl
))
6703 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
6706 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6707 TREE_SIDE_EFFECTS (bind
) = 1;
6709 BIND_EXPR_BODY (bind
) = push_stmt_list ();
6711 add_decl_expr (decl
);
6714 /* Let the middle end know about variables and functions -- but not
6715 static data members in uninstantiated class templates. */
6716 if (VAR_OR_FUNCTION_DECL_P (decl
))
6720 layout_var_decl (decl
);
6721 maybe_commonize_var (decl
);
6724 /* This needs to happen after the linkage is set. */
6725 determine_visibility (decl
);
6727 if (var_definition_p
&& TREE_STATIC (decl
))
6729 /* If a TREE_READONLY variable needs initialization
6730 at runtime, it is no longer readonly and we need to
6731 avoid MEM_READONLY_P being set on RTL created for it. */
6734 if (TREE_READONLY (decl
))
6735 TREE_READONLY (decl
) = 0;
6738 else if (was_readonly
)
6739 TREE_READONLY (decl
) = 1;
6741 /* Likewise if it needs destruction. */
6742 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6743 TREE_READONLY (decl
) = 0;
6746 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6748 /* Check for abstractness of the type. Notice that there is no
6749 need to strip array types here since the check for those types
6750 is already done within create_array_type_for_decl. */
6751 abstract_virtuals_error (decl
, type
);
6753 if (TREE_TYPE (decl
) == error_mark_node
)
6754 /* No initialization required. */
6756 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6760 if (init
== ridpointers
[(int)RID_DEFAULT
])
6762 /* An out-of-class default definition is defined at
6763 the point where it is explicitly defaulted. */
6764 if (DECL_DELETED_FN (decl
))
6765 maybe_explain_implicit_delete (decl
);
6766 else if (DECL_INITIAL (decl
) == error_mark_node
)
6767 synthesize_method (decl
);
6770 error ("function %q#D is initialized like a variable", decl
);
6772 /* else no initialization required. */
6774 else if (DECL_EXTERNAL (decl
)
6775 && ! (DECL_LANG_SPECIFIC (decl
)
6776 && DECL_NOT_REALLY_EXTERN (decl
)))
6779 DECL_INITIAL (decl
) = init
;
6781 /* A variable definition. */
6782 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6783 /* Initialize the local variable. */
6784 initialize_local_var (decl
, init
);
6786 /* If a variable is defined, and then a subsequent
6787 definition with external linkage is encountered, we will
6788 get here twice for the same variable. We want to avoid
6789 calling expand_static_init more than once. For variables
6790 that are not static data members, we can call
6791 expand_static_init only when we actually process the
6792 initializer. It is not legal to redeclare a static data
6793 member, so this issue does not arise in that case. */
6794 else if (var_definition_p
&& TREE_STATIC (decl
))
6795 expand_static_init (decl
, init
);
6798 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6799 reference, insert it in the statement-tree now. */
6803 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6804 push_cleanup (decl
, t
, false);
6805 release_tree_vector (cleanups
);
6809 TREE_READONLY (decl
) = 1;
6811 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6814 /* Returns a declaration for a VAR_DECL as if:
6816 extern "C" TYPE NAME;
6818 had been seen. Used to create compiler-generated global
6822 declare_global_var (tree name
, tree type
)
6826 push_to_top_level ();
6827 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6828 TREE_PUBLIC (decl
) = 1;
6829 DECL_EXTERNAL (decl
) = 1;
6830 DECL_ARTIFICIAL (decl
) = 1;
6831 /* If the user has explicitly declared this variable (perhaps
6832 because the code we are compiling is part of a low-level runtime
6833 library), then it is possible that our declaration will be merged
6834 with theirs by pushdecl. */
6835 decl
= pushdecl (decl
);
6836 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6837 pop_from_top_level ();
6842 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6843 if "__cxa_atexit" is not being used) corresponding to the function
6844 to be called when the program exits. */
6847 get_atexit_fn_ptr_type (void)
6851 if (!atexit_fn_ptr_type_node
)
6854 if (flag_use_cxa_atexit
6855 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6856 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6857 arg_type
= ptr_type_node
;
6859 /* The parameter to "atexit" is "void (*)(void)". */
6860 arg_type
= NULL_TREE
;
6862 fn_type
= build_function_type_list (void_type_node
,
6863 arg_type
, NULL_TREE
);
6864 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6867 return atexit_fn_ptr_type_node
;
6870 /* Returns a pointer to the `atexit' function. Note that if
6871 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6872 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6875 get_atexit_node (void)
6881 bool use_aeabi_atexit
;
6886 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6888 /* The declaration for `__cxa_atexit' is:
6890 int __cxa_atexit (void (*)(void *), void *, void *)
6892 We build up the argument types and then the function type
6894 tree argtype0
, argtype1
, argtype2
;
6896 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6897 /* First, build the pointer-to-function type for the first
6899 fn_ptr_type
= get_atexit_fn_ptr_type ();
6900 /* Then, build the rest of the argument types. */
6901 argtype2
= ptr_type_node
;
6902 if (use_aeabi_atexit
)
6904 argtype1
= fn_ptr_type
;
6905 argtype0
= ptr_type_node
;
6909 argtype1
= ptr_type_node
;
6910 argtype0
= fn_ptr_type
;
6912 /* And the final __cxa_atexit type. */
6913 fn_type
= build_function_type_list (integer_type_node
,
6914 argtype0
, argtype1
, argtype2
,
6916 if (use_aeabi_atexit
)
6917 name
= "__aeabi_atexit";
6919 name
= "__cxa_atexit";
6923 /* The declaration for `atexit' is:
6925 int atexit (void (*)());
6927 We build up the argument types and then the function type
6929 fn_ptr_type
= get_atexit_fn_ptr_type ();
6930 /* Build the final atexit type. */
6931 fn_type
= build_function_type_list (integer_type_node
,
6932 fn_ptr_type
, NULL_TREE
);
6936 /* Now, build the function declaration. */
6937 push_lang_context (lang_name_c
);
6938 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
6939 mark_used (atexit_fndecl
);
6940 pop_lang_context ();
6941 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6946 /* Like get_atexit_node, but for thread-local cleanups. */
6949 get_thread_atexit_node (void)
6951 /* The declaration for `__cxa_thread_atexit' is:
6953 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6954 tree fn_type
= build_function_type_list (integer_type_node
,
6955 get_atexit_fn_ptr_type (),
6956 ptr_type_node
, ptr_type_node
,
6959 /* Now, build the function declaration. */
6960 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
6961 ECF_LEAF
| ECF_NOTHROW
);
6962 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6965 /* Returns the __dso_handle VAR_DECL. */
6968 get_dso_handle_node (void)
6970 if (dso_handle_node
)
6971 return dso_handle_node
;
6973 /* Declare the variable. */
6974 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6977 #ifdef HAVE_GAS_HIDDEN
6978 if (dso_handle_node
!= error_mark_node
)
6980 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6981 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6985 return dso_handle_node
;
6988 /* Begin a new function with internal linkage whose job will be simply
6989 to destroy some particular variable. */
6991 static GTY(()) int start_cleanup_cnt
;
6994 start_cleanup_fn (void)
6999 bool use_cxa_atexit
= flag_use_cxa_atexit
7000 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
7002 push_to_top_level ();
7004 /* No need to mangle this. */
7005 push_lang_context (lang_name_c
);
7007 /* Build the name of the function. */
7008 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
7009 /* Build the function declaration. */
7010 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
7011 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
7012 /* It's a function with internal linkage, generated by the
7014 TREE_PUBLIC (fndecl
) = 0;
7015 DECL_ARTIFICIAL (fndecl
) = 1;
7016 /* Make the function `inline' so that it is only emitted if it is
7017 actually needed. It is unlikely that it will be inlined, since
7018 it is only called via a function pointer, but we avoid unnecessary
7019 emissions this way. */
7020 DECL_DECLARED_INLINE_P (fndecl
) = 1;
7021 DECL_INTERFACE_KNOWN (fndecl
) = 1;
7022 /* Build the parameter. */
7027 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
7028 DECL_CONTEXT (parmdecl
) = fndecl
;
7029 TREE_USED (parmdecl
) = 1;
7030 DECL_READ_P (parmdecl
) = 1;
7031 DECL_ARGUMENTS (fndecl
) = parmdecl
;
7035 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
7037 pop_lang_context ();
7039 return current_function_decl
;
7042 /* Finish the cleanup function begun by start_cleanup_fn. */
7045 end_cleanup_fn (void)
7047 expand_or_defer_fn (finish_function (0));
7049 pop_from_top_level ();
7052 /* Generate code to handle the destruction of DECL, an object with
7053 static storage duration. */
7056 register_dtor_fn (tree decl
)
7063 bool ob_parm
, dso_parm
, use_dtor
;
7064 tree arg0
, arg1
, arg2
;
7067 type
= TREE_TYPE (decl
);
7068 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7071 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7072 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7073 destructor to "__cxa_atexit"; we don't have to build a temporary
7074 function to do the cleanup. */
7075 dso_parm
= (flag_use_cxa_atexit
7076 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7077 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7078 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7083 /* Find the destructor. */
7084 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
7085 gcc_assert (idx
>= 0);
7086 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
7087 /* Make sure it is accessible. */
7088 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7089 tf_warning_or_error
);
7093 /* Call build_cleanup before we enter the anonymous function so
7094 that any access checks will be done relative to the current
7095 scope, rather than the scope of the anonymous function. */
7096 build_cleanup (decl
);
7098 /* Now start the function. */
7099 cleanup
= start_cleanup_fn ();
7101 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7102 to the original function, rather than the anonymous one. That
7103 will make the back end think that nested functions are in use,
7104 which causes confusion. */
7105 push_deferring_access_checks (dk_no_check
);
7106 fcall
= build_cleanup (decl
);
7107 pop_deferring_access_checks ();
7109 /* Create the body of the anonymous function. */
7110 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7111 finish_expr_stmt (fcall
);
7112 finish_compound_stmt (compound_stmt
);
7116 /* Call atexit with the cleanup function. */
7117 mark_used (cleanup
);
7118 cleanup
= build_address (cleanup
);
7120 if (CP_DECL_THREAD_LOCAL_P (decl
))
7121 atex_node
= get_thread_atexit_node ();
7123 atex_node
= get_atexit_node ();
7127 /* We must convert CLEANUP to the type that "__cxa_atexit"
7129 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7130 /* "__cxa_atexit" will pass the address of DECL to the
7131 cleanup function. */
7133 addr
= build_address (decl
);
7134 /* The declared type of the parameter to "__cxa_atexit" is
7135 "void *". For plain "T*", we could just let the
7136 machinery in cp_build_function_call convert it -- but if the
7137 type is "cv-qualified T *", then we need to convert it
7138 before passing it in, to avoid spurious errors. */
7139 addr
= build_nop (ptr_type_node
, addr
);
7142 /* Since the cleanup functions we build ignore the address
7143 they're given, there's no reason to pass the actual address
7144 in, and, in general, it's cheaper to pass NULL than any
7146 addr
= null_pointer_node
;
7149 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7150 tf_warning_or_error
);
7152 /* Just pass NULL to the dso handle parm if we don't actually
7153 have a DSO handle on this target. */
7154 arg2
= null_pointer_node
;
7160 if (!CP_DECL_THREAD_LOCAL_P (decl
)
7161 && targetm
.cxx
.use_aeabi_atexit ())
7177 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7178 arg0
, arg1
, arg2
, NULL_TREE
);
7181 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7182 is its initializer. Generate code to handle the construction
7183 and destruction of DECL. */
7186 expand_static_init (tree decl
, tree init
)
7188 gcc_assert (VAR_P (decl
));
7189 gcc_assert (TREE_STATIC (decl
));
7191 /* Some variables require no dynamic initialization. */
7192 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7194 /* Make sure the destructor is callable. */
7195 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7200 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7201 && !DECL_FUNCTION_SCOPE_P (decl
))
7204 error ("non-local variable %qD declared %<__thread%> "
7205 "needs dynamic initialization", decl
);
7207 error ("non-local variable %qD declared %<__thread%> "
7208 "has a non-trivial destructor", decl
);
7209 static bool informed
;
7212 inform (DECL_SOURCE_LOCATION (decl
),
7213 "C++11 %<thread_local%> allows dynamic initialization "
7220 if (DECL_FUNCTION_SCOPE_P (decl
))
7222 /* Emit code to perform this initialization but once. */
7223 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7224 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7225 tree guard
, guard_addr
;
7227 /* We don't need thread-safety code for thread-local vars. */
7228 bool thread_guard
= (flag_threadsafe_statics
7229 && !CP_DECL_THREAD_LOCAL_P (decl
));
7231 /* Emit code to perform this initialization but once. This code
7234 static <type> guard;
7235 if (!__atomic_load (guard.first_byte)) {
7236 if (__cxa_guard_acquire (&guard)) {
7239 // Do initialization.
7240 flag = true; __cxa_guard_release (&guard);
7241 // Register variable for destruction at end of program.
7243 if (!flag) __cxa_guard_abort (&guard);
7247 Note that the `flag' variable is only set to 1 *after* the
7248 initialization is complete. This ensures that an exception,
7249 thrown during the construction, will cause the variable to
7250 reinitialized when we pass through this code again, as per:
7254 If the initialization exits by throwing an exception, the
7255 initialization is not complete, so it will be tried again
7256 the next time control enters the declaration.
7258 This process should be thread-safe, too; multiple threads
7259 should not be able to initialize the variable more than
7262 /* Create the guard variable. */
7263 guard
= get_guard (decl
);
7265 /* Begin the conditional initialization. */
7266 if_stmt
= begin_if_stmt ();
7268 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
7269 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7273 tree vfntype
= NULL_TREE
;
7274 tree acquire_name
, release_name
, abort_name
;
7275 tree acquire_fn
, release_fn
, abort_fn
;
7276 guard_addr
= build_address (guard
);
7278 acquire_name
= get_identifier ("__cxa_guard_acquire");
7279 release_name
= get_identifier ("__cxa_guard_release");
7280 abort_name
= get_identifier ("__cxa_guard_abort");
7281 acquire_fn
= identifier_global_value (acquire_name
);
7282 release_fn
= identifier_global_value (release_name
);
7283 abort_fn
= identifier_global_value (abort_name
);
7285 acquire_fn
= push_library_fn
7286 (acquire_name
, build_function_type_list (integer_type_node
,
7287 TREE_TYPE (guard_addr
),
7289 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7290 if (!release_fn
|| !abort_fn
)
7291 vfntype
= build_function_type_list (void_type_node
,
7292 TREE_TYPE (guard_addr
),
7295 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7296 ECF_NOTHROW
| ECF_LEAF
);
7298 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7299 ECF_NOTHROW
| ECF_LEAF
);
7301 inner_if_stmt
= begin_if_stmt ();
7302 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7305 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7306 begin
= get_target_expr (boolean_false_node
);
7307 flag
= TARGET_EXPR_SLOT (begin
);
7309 TARGET_EXPR_CLEANUP (begin
)
7310 = build3 (COND_EXPR
, void_type_node
, flag
,
7312 build_call_n (abort_fn
, 1, guard_addr
));
7313 CLEANUP_EH_ONLY (begin
) = 1;
7315 /* Do the initialization itself. */
7316 init
= add_stmt_to_compound (begin
, init
);
7317 init
= add_stmt_to_compound
7318 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7319 init
= add_stmt_to_compound
7320 (init
, build_call_n (release_fn
, 1, guard_addr
));
7323 init
= add_stmt_to_compound (init
, set_guard (guard
));
7325 /* Use atexit to register a function for destroying this static
7327 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7329 finish_expr_stmt (init
);
7333 finish_compound_stmt (inner_then_clause
);
7334 finish_then_clause (inner_if_stmt
);
7335 finish_if_stmt (inner_if_stmt
);
7338 finish_compound_stmt (then_clause
);
7339 finish_then_clause (if_stmt
);
7340 finish_if_stmt (if_stmt
);
7342 else if (CP_DECL_THREAD_LOCAL_P (decl
))
7343 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7345 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7349 /* Make TYPE a complete type based on INITIAL_VALUE.
7350 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7351 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7352 3 if the initializer list is empty (in pedantic mode). */
7355 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7358 tree type
, elt_type
;
7360 /* Don't get confused by a CONSTRUCTOR for some other type. */
7361 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
7362 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
))
7367 unsigned HOST_WIDE_INT i
;
7370 /* An array of character type can be initialized from a
7371 brace-enclosed string constant.
7373 FIXME: this code is duplicated from reshape_init. Probably
7374 we should just call reshape_init here? */
7375 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7376 && TREE_CODE (initial_value
) == CONSTRUCTOR
7377 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7379 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7380 tree value
= (*v
)[0].value
;
7382 if (TREE_CODE (value
) == STRING_CST
7383 && v
->length () == 1)
7384 initial_value
= value
;
7387 /* If any of the elements are parameter packs, we can't actually
7388 complete this type now because the array size is dependent. */
7389 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7391 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7394 if (PACK_EXPANSION_P (value
))
7400 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7402 /* We can create the array before the element type is complete, which
7403 means that we didn't have these two bits set in the original type
7404 either. In completing the type, we are expected to propagate these
7405 bits. See also complete_type which does the same thing for arrays
7408 if (TYPE_DOMAIN (type
))
7410 elt_type
= TREE_TYPE (type
);
7411 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7412 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7413 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7419 /* As above, but either give an error or reject zero-size arrays, depending
7423 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7424 bool do_default
, tsubst_flags_t complain
)
7427 bool sfinae
= !(complain
& tf_error
);
7428 /* In SFINAE context we can't be lenient about zero-size arrays. */
7431 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7437 /* Not an error. */;
7438 else if (failure
== 1)
7439 error ("initializer fails to determine size of %qT", *ptype
);
7440 else if (failure
== 2)
7443 error ("array size missing in %qT", *ptype
);
7445 else if (failure
== 3)
7446 error ("zero-size array %qT", *ptype
);
7447 *ptype
= error_mark_node
;
7452 /* Return zero if something is declared to be a member of type
7453 CTYPE when in the context of CUR_TYPE. STRING is the error
7454 message to print in that case. Otherwise, quietly return 1. */
7457 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7459 if (ctype
&& ctype
!= cur_type
)
7461 if (flags
== DTOR_FLAG
)
7462 error ("destructor for alien class %qT cannot be a member", ctype
);
7464 error ("constructor for alien class %qT cannot be a member", ctype
);
7470 /* Subroutine of `grokdeclarator'. */
7472 /* Generate errors possibly applicable for a given set of specifiers.
7473 This is for ARM $7.1.2. */
7476 bad_specifiers (tree object
,
7477 enum bad_spec_place type
,
7488 error ("%qD declared as a %<virtual%> variable", object
);
7490 error ("%qD declared as an %<inline%> variable", object
);
7492 error ("%<const%> and %<volatile%> function specifiers on "
7493 "%qD invalid in variable declaration", object
);
7497 error ("%qD declared as a %<virtual%> parameter", object
);
7499 error ("%qD declared as an %<inline%> parameter", object
);
7501 error ("%<const%> and %<volatile%> function specifiers on "
7502 "%qD invalid in parameter declaration", object
);
7506 error ("%qD declared as a %<virtual%> type", object
);
7508 error ("%qD declared as an %<inline%> type", object
);
7510 error ("%<const%> and %<volatile%> function specifiers on "
7511 "%qD invalid in type declaration", object
);
7515 error ("%qD declared as a %<virtual%> field", object
);
7517 error ("%qD declared as an %<inline%> field", object
);
7519 error ("%<const%> and %<volatile%> function specifiers on "
7520 "%qD invalid in field declaration", object
);
7526 error ("%q+D declared as a friend", object
);
7528 && (TREE_CODE (object
) == TYPE_DECL
7529 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7530 && !TYPE_REFFN_P (TREE_TYPE (object
))
7531 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7532 error ("%q+D declared with an exception specification", object
);
7535 /* DECL is a member function or static data member and is presently
7536 being defined. Check that the definition is taking place in a
7540 check_class_member_definition_namespace (tree decl
)
7542 /* These checks only apply to member functions and static data
7544 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7545 /* We check for problems with specializations in pt.c in
7546 check_specialization_namespace, where we can issue better
7548 if (processing_specialization
)
7550 /* There are no restrictions on the placement of
7551 explicit instantiations. */
7552 if (processing_explicit_instantiation
)
7556 A member function definition that appears outside of the
7557 class definition shall appear in a namespace scope enclosing
7558 the class definition.
7562 The definition for a static data member shall appear in a
7563 namespace scope enclosing the member's class definition. */
7564 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7565 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7566 decl
, DECL_CONTEXT (decl
));
7569 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7570 METHOD_TYPE for a non-static member function; QUALS are the
7571 cv-qualifiers that apply to the function. */
7574 build_this_parm (tree type
, cp_cv_quals quals
)
7579 cp_cv_quals this_quals
;
7581 if (CLASS_TYPE_P (type
))
7584 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7585 this_type
= build_pointer_type (this_type
);
7588 this_type
= type_of_this_parm (type
);
7589 /* The `this' parameter is implicitly `const'; it cannot be
7591 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7592 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7593 parm
= build_artificial_parm (this_identifier
, qual_type
);
7594 cp_apply_type_quals_to_decl (this_quals
, parm
);
7598 /* DECL is a static member function. Complain if it was declared
7599 with function-cv-quals. */
7602 check_static_quals (tree decl
, cp_cv_quals quals
)
7604 if (quals
!= TYPE_UNQUALIFIED
)
7605 error ("static member function %q#D declared with type qualifiers",
7609 /* Helper function. Replace the temporary this parameter injected
7610 during cp_finish_omp_declare_simd with the real this parameter. */
7613 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7615 tree this_parm
= (tree
) data
;
7616 if (TREE_CODE (*tp
) == PARM_DECL
7617 && DECL_NAME (*tp
) == this_identifier
7618 && *tp
!= this_parm
)
7620 else if (TYPE_P (*tp
))
7625 /* CTYPE is class type, or null if non-class.
7626 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7628 DECLARATOR is the function's name.
7629 PARMS is a chain of PARM_DECLs for the function.
7630 VIRTUALP is truthvalue of whether the function is virtual or not.
7631 FLAGS are to be passed through to `grokclassfn'.
7632 QUALS are qualifiers indicating whether the function is `const'
7634 RAISES is a list of exceptions that this function can raise.
7635 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7636 not look, and -1 if we should not call `grokclassfn' at all.
7638 SFK is the kind of special function (if any) for the new function.
7640 Returns `NULL_TREE' if something goes wrong, after issuing
7641 applicable error messages. */
7644 grokfndecl (tree ctype
,
7648 tree orig_declarator
,
7650 enum overload_flags flags
,
7652 cp_ref_qualifier rqual
,
7659 special_function_kind sfk
,
7664 location_t location
)
7667 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7671 type
= build_ref_qualified_type (type
, rqual
);
7673 type
= build_exception_variant (type
, raises
);
7675 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7677 /* If we have an explicit location, use it, otherwise use whatever
7678 build_lang_decl used (probably input_location). */
7679 if (location
!= UNKNOWN_LOCATION
)
7680 DECL_SOURCE_LOCATION (decl
) = location
;
7682 if (TREE_CODE (type
) == METHOD_TYPE
)
7685 parm
= build_this_parm (type
, quals
);
7686 DECL_CHAIN (parm
) = parms
;
7689 DECL_ARGUMENTS (decl
) = parms
;
7690 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7691 DECL_CONTEXT (t
) = decl
;
7692 /* Propagate volatile out from type to decl. */
7693 if (TYPE_VOLATILE (type
))
7694 TREE_THIS_VOLATILE (decl
) = 1;
7696 /* Setup decl according to sfk. */
7699 case sfk_constructor
:
7700 case sfk_copy_constructor
:
7701 case sfk_move_constructor
:
7702 DECL_CONSTRUCTOR_P (decl
) = 1;
7704 case sfk_destructor
:
7705 DECL_DESTRUCTOR_P (decl
) = 1;
7711 /* If pointers to member functions use the least significant bit to
7712 indicate whether a function is virtual, ensure a pointer
7713 to this function will have that bit clear. */
7714 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7715 && TREE_CODE (type
) == METHOD_TYPE
7716 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7717 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7720 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7724 ("defining explicit specialization %qD in friend declaration",
7728 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7729 tree args
= TREE_OPERAND (orig_declarator
, 1);
7731 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7733 /* Something like `template <class T> friend void f<T>()'. */
7734 error ("invalid use of template-id %qD in declaration "
7735 "of primary template",
7741 /* A friend declaration of the form friend void f<>(). Record
7742 the information in the TEMPLATE_ID_EXPR. */
7743 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7745 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7746 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7748 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7749 if (TREE_PURPOSE (t
)
7750 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7752 error ("default arguments are not allowed in declaration "
7753 "of friend template specialization %qD",
7760 error ("%<inline%> is not allowed in declaration of friend "
7761 "template specialization %qD",
7768 /* If this decl has namespace scope, set that up. */
7770 set_decl_namespace (decl
, in_namespace
, friendp
);
7772 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7774 /* `main' and builtins have implicit 'C' linkage. */
7775 if ((MAIN_NAME_P (declarator
)
7776 || (IDENTIFIER_LENGTH (declarator
) > 10
7777 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7778 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7779 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
7780 || (targetcm
.cxx_implicit_extern_c
7781 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
7782 && current_lang_name
== lang_name_cplusplus
7783 && ctype
== NULL_TREE
7784 && DECL_FILE_SCOPE_P (decl
))
7785 SET_DECL_LANGUAGE (decl
, lang_c
);
7787 /* Should probably propagate const out from type to decl I bet (mrs). */
7790 DECL_STATIC_FUNCTION_P (decl
) = 1;
7791 DECL_CONTEXT (decl
) = ctype
;
7795 DECL_DELETED_FN (decl
) = 1;
7799 DECL_CONTEXT (decl
) = ctype
;
7801 check_class_member_definition_namespace (decl
);
7804 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7806 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7807 error ("cannot declare %<::main%> to be a template");
7809 error ("cannot declare %<::main%> to be inline");
7811 error ("cannot declare %<::main%> to be constexpr");
7813 error ("cannot declare %<::main%> to be static");
7818 /* Members of anonymous types and local classes have no linkage; make
7819 them internal. If a typedef is made later, this will be changed. */
7820 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
7821 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7824 if (publicp
&& cxx_dialect
== cxx98
)
7826 /* [basic.link]: A name with no linkage (notably, the name of a class
7827 or enumeration declared in a local scope) shall not be used to
7828 declare an entity with linkage.
7830 DR 757 relaxes this restriction for C++0x. */
7831 no_linkage_error (decl
);
7834 TREE_PUBLIC (decl
) = publicp
;
7837 DECL_INTERFACE_KNOWN (decl
) = 1;
7838 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7841 /* If the declaration was declared inline, mark it as such. */
7844 DECL_DECLARED_INLINE_P (decl
) = 1;
7846 DECL_COMDAT (decl
) = 1;
7849 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7851 DECL_EXTERNAL (decl
) = 1;
7852 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7857 ? G_("static member function %qD cannot have cv-qualifier")
7858 : G_("non-member function %qD cannot have cv-qualifier"),
7860 quals
= TYPE_UNQUALIFIED
;
7866 ? G_("static member function %qD cannot have ref-qualifier")
7867 : G_("non-member function %qD cannot have ref-qualifier"),
7869 rqual
= REF_QUAL_NONE
;
7873 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7874 && !grok_op_properties (decl
, /*complain=*/true))
7876 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7878 bool long_long_unsigned_p
;
7880 const char *suffix
= NULL
;
7881 /* [over.literal]/6: Literal operators shall not have C linkage. */
7882 if (DECL_LANGUAGE (decl
) == lang_c
)
7884 error ("literal operator with C linkage");
7888 if (DECL_NAMESPACE_SCOPE_P (decl
))
7890 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7893 error ("%qD has invalid argument list", decl
);
7897 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7898 if (long_long_unsigned_p
)
7900 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7901 warning (0, "integer suffix %<%s%>"
7902 " shadowed by implementation", suffix
);
7904 else if (long_double_p
)
7906 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7907 warning (0, "floating point suffix %<%s%>"
7908 " shadowed by implementation", suffix
);
7913 error ("%qD must be a non-member function", decl
);
7919 /* Make the init_value nonzero so pushdecl knows this is not
7920 tentative. error_mark_node is replaced later with the BLOCK. */
7921 DECL_INITIAL (decl
) = error_mark_node
;
7923 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7924 TREE_NOTHROW (decl
) = 1;
7926 if (flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
7928 /* Adjust "omp declare simd" attributes. */
7929 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
7933 for (attr
= ods
; attr
;
7934 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
7936 if (TREE_CODE (type
) == METHOD_TYPE
)
7937 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
7938 DECL_ARGUMENTS (decl
), NULL
);
7939 if (TREE_VALUE (attr
) != NULL_TREE
)
7941 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
7942 cl
= c_omp_declare_simd_clauses_to_numbers
7943 (DECL_ARGUMENTS (decl
), cl
);
7945 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
7947 TREE_VALUE (attr
) = NULL_TREE
;
7953 /* Caller will do the rest of this. */
7957 if (ctype
!= NULL_TREE
)
7958 grokclassfn (ctype
, decl
, flags
);
7961 if (cxx_dialect
>= cxx11
7962 && DECL_DESTRUCTOR_P (decl
)
7963 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7964 && !processing_template_decl
)
7965 deduce_noexcept_on_destructor (decl
);
7967 decl
= check_explicit_specialization (orig_declarator
, decl
,
7970 4 * (friendp
!= 0));
7971 if (decl
== error_mark_node
)
7974 if (DECL_STATIC_FUNCTION_P (decl
))
7975 check_static_quals (decl
, quals
);
7979 cplus_decl_attributes (&decl
, *attrlist
, 0);
7980 *attrlist
= NULL_TREE
;
7983 /* Check main's type after attributes have been applied. */
7984 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7986 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7989 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7991 error ("%<::main%> must return %<int%>");
7992 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7993 TREE_TYPE (decl
) = newtype
;
7996 check_main_parameter_types (decl
);
7999 if (ctype
!= NULL_TREE
8000 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8003 tree old_decl
= check_classfn (ctype
, decl
,
8004 (processing_template_decl
8005 > template_class_depth (ctype
))
8006 ? current_template_parms
8009 if (old_decl
== error_mark_node
)
8017 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8018 /* Because grokfndecl is always supposed to return a
8019 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8020 here. We depend on our callers to figure out that its
8021 really a template that's being returned. */
8022 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8024 if (DECL_STATIC_FUNCTION_P (old_decl
)
8025 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8027 /* Remove the `this' parm added by grokclassfn. */
8028 revert_static_member_fn (decl
);
8029 check_static_quals (decl
, quals
);
8031 if (DECL_ARTIFICIAL (old_decl
))
8033 error ("definition of implicitly-declared %qD", old_decl
);
8036 else if (DECL_DEFAULTED_FN (old_decl
))
8038 error ("definition of explicitly-defaulted %q+D", decl
);
8039 error ("%q+#D explicitly defaulted here", old_decl
);
8043 /* Since we've smashed OLD_DECL to its
8044 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8045 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8046 decl
= DECL_TEMPLATE_RESULT (decl
);
8048 /* Attempt to merge the declarations. This can fail, in
8049 the case of some invalid specialization declarations. */
8050 pushed_scope
= push_scope (ctype
);
8051 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8053 pop_scope (pushed_scope
);
8056 error ("no %q#D member function declared in class %qT",
8060 if (ok
== error_mark_node
)
8066 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8069 if (ctype
== NULL_TREE
|| check
)
8073 DECL_VIRTUAL_P (decl
) = 1;
8078 /* decl is a FUNCTION_DECL.
8079 specifiers are the parsed virt-specifiers.
8081 Set flags to reflect the virt-specifiers.
8086 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8088 if (decl
== NULL_TREE
)
8090 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8091 DECL_OVERRIDE_P (decl
) = 1;
8092 if (specifiers
& VIRT_SPEC_FINAL
)
8093 DECL_FINAL_P (decl
) = 1;
8097 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8098 the linkage that DECL will receive in the object file. */
8101 set_linkage_for_static_data_member (tree decl
)
8103 /* A static data member always has static storage duration and
8104 external linkage. Note that static data members are forbidden in
8105 local classes -- the only situation in which a class has
8106 non-external linkage. */
8107 TREE_PUBLIC (decl
) = 1;
8108 TREE_STATIC (decl
) = 1;
8109 /* For non-template classes, static data members are always put
8110 out in exactly those files where they are defined, just as
8111 with ordinary namespace-scope variables. */
8112 if (!processing_template_decl
)
8113 DECL_INTERFACE_KNOWN (decl
) = 1;
8116 /* Create a VAR_DECL named NAME with the indicated TYPE.
8118 If SCOPE is non-NULL, it is the class type or namespace containing
8119 the variable. If SCOPE is NULL, the variable should is created in
8120 the innermost enclosing scope. */
8123 grokvardecl (tree type
,
8125 tree orig_declarator
,
8126 const cp_decl_specifier_seq
*declspecs
,
8133 tree explicit_scope
;
8135 gcc_assert (!name
|| identifier_p (name
));
8137 /* Compute the scope in which to place the variable, but remember
8138 whether or not that scope was explicitly specified by the user. */
8139 explicit_scope
= scope
;
8142 /* An explicit "extern" specifier indicates a namespace-scope
8144 if (declspecs
->storage_class
== sc_extern
)
8145 scope
= current_decl_namespace ();
8146 else if (!at_function_scope_p ())
8147 scope
= current_scope ();
8151 && (/* If the variable is a namespace-scope variable declared in a
8152 template, we need DECL_LANG_SPECIFIC. */
8153 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8154 /* Similarly for namespace-scope variables with language linkage
8156 || (TREE_CODE (scope
) == NAMESPACE_DECL
8157 && current_lang_name
!= lang_name_cplusplus
)
8158 /* Similarly for static data members. */
8160 /* Similarly for explicit specializations. */
8162 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8163 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8165 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8167 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8168 set_decl_namespace (decl
, explicit_scope
, 0);
8170 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
8172 if (declspecs
->storage_class
== sc_extern
)
8174 DECL_THIS_EXTERN (decl
) = 1;
8175 DECL_EXTERNAL (decl
) = !initialized
;
8178 if (DECL_CLASS_SCOPE_P (decl
))
8180 set_linkage_for_static_data_member (decl
);
8181 /* This function is only called with out-of-class definitions. */
8182 DECL_EXTERNAL (decl
) = 0;
8183 check_class_member_definition_namespace (decl
);
8185 /* At top level, either `static' or no s.c. makes a definition
8186 (perhaps tentative), and absence of `static' makes it public. */
8187 else if (toplevel_bindings_p ())
8189 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
8190 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8191 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8193 /* Not at top level, only `static' makes a static definition. */
8196 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
8197 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8200 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
8202 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
8204 CP_DECL_THREAD_LOCAL_P (decl
) = true;
8205 if (!processing_template_decl
)
8206 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
8208 if (declspecs
->gnu_thread_keyword_p
)
8209 SET_DECL_GNU_TLS_P (decl
);
8212 /* If the type of the decl has no linkage, make sure that we'll
8213 notice that in mark_used. */
8214 if (cxx_dialect
> cxx98
8215 && decl_linkage (decl
) != lk_none
8216 && DECL_LANG_SPECIFIC (decl
) == NULL
8217 && !DECL_EXTERN_C_P (decl
)
8218 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
8219 retrofit_lang_decl (decl
);
8221 if (TREE_PUBLIC (decl
))
8223 /* [basic.link]: A name with no linkage (notably, the name of a class
8224 or enumeration declared in a local scope) shall not be used to
8225 declare an entity with linkage.
8227 DR 757 relaxes this restriction for C++0x. */
8228 if (cxx_dialect
< cxx11
)
8229 no_linkage_error (decl
);
8232 DECL_INTERFACE_KNOWN (decl
) = 1;
8234 // Handle explicit specializations and instantiations of variable templates.
8235 if (orig_declarator
)
8236 decl
= check_explicit_specialization (orig_declarator
, decl
,
8239 return decl
!= error_mark_node
? decl
: NULL_TREE
;
8242 /* Create and return a canonical pointer to member function type, for
8243 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8246 build_ptrmemfunc_type (tree type
)
8251 if (type
== error_mark_node
)
8254 /* Make sure that we always have the unqualified pointer-to-member
8256 if (cp_cv_quals quals
= cp_type_quals (type
))
8258 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8259 return cp_build_qualified_type (unqual
, quals
);
8262 /* If a canonical type already exists for this type, use it. We use
8263 this method instead of type_hash_canon, because it only does a
8264 simple equality check on the list of field members. */
8266 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8269 t
= make_node (RECORD_TYPE
);
8271 /* Let the front end know this is a pointer to member function. */
8272 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8274 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8277 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8279 DECL_CHAIN (field
) = fields
;
8282 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8284 /* Zap out the name so that the back end will give us the debugging
8285 information for this anonymous RECORD_TYPE. */
8286 TYPE_NAME (t
) = NULL_TREE
;
8288 /* Cache this pointer-to-member type so that we can find it again
8290 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8292 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8293 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8294 else if (TYPE_CANONICAL (type
) != type
)
8295 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8300 /* Create and return a pointer to data member type. */
8303 build_ptrmem_type (tree class_type
, tree member_type
)
8305 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8307 cp_cv_quals quals
= type_memfn_quals (member_type
);
8308 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8309 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8310 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8314 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8315 return build_offset_type (class_type
, member_type
);
8319 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8320 Check to see that the definition is valid. Issue appropriate error
8321 messages. Return 1 if the definition is particularly bad, or 0
8325 check_static_variable_definition (tree decl
, tree type
)
8327 /* Can't check yet if we don't know the type. */
8328 if (dependent_type_p (type
))
8330 /* If DECL is declared constexpr, we'll do the appropriate checks
8331 in check_initializer. */
8332 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8334 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8336 if (!COMPLETE_TYPE_P (type
))
8337 error ("in-class initialization of static data member %q#D of "
8338 "incomplete type", decl
);
8339 else if (literal_type_p (type
))
8340 permerror (input_location
,
8341 "%<constexpr%> needed for in-class initialization of "
8342 "static data member %q#D of non-integral type", decl
);
8344 error ("in-class initialization of static data member %q#D of "
8345 "non-literal type", decl
);
8349 /* Motion 10 at San Diego: If a static const integral data member is
8350 initialized with an integral constant expression, the initializer
8351 may appear either in the declaration (within the class), or in
8352 the definition, but not both. If it appears in the class, the
8353 member is a member constant. The file-scope definition is always
8355 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8357 error ("invalid in-class initialization of static data member "
8358 "of non-integral type %qT",
8362 else if (!CP_TYPE_CONST_P (type
))
8363 error ("ISO C++ forbids in-class initialization of non-const "
8364 "static member %qD",
8366 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8367 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8368 "%qD of non-integral type %qT", decl
, type
);
8373 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8374 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8375 expressions out into temporary variables so that walk_tree doesn't
8376 step into them (c++/15764). */
8379 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8381 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
8382 tree expr
= *expr_p
;
8383 if (TREE_CODE (expr
) == SAVE_EXPR
)
8385 tree op
= TREE_OPERAND (expr
, 0);
8386 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8387 if (TREE_SIDE_EFFECTS (op
))
8388 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8391 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8396 /* Entry point for the above. */
8399 stabilize_vla_size (tree size
)
8401 hash_set
<tree
> pset
;
8402 /* Break out any function calls into temporary variables. */
8403 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
8406 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8407 not inside of SAVE_EXPR and fold them. */
8410 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8412 tree expr
= *expr_p
;
8413 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8415 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8417 *(bool *)data
= true;
8418 if (SIZEOF_EXPR_TYPE_P (expr
))
8419 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8420 SIZEOF_EXPR
, false);
8421 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8422 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8425 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8427 if (expr
== error_mark_node
)
8428 expr
= size_one_node
;
8435 /* Given the SIZE (i.e., number of elements) in an array, compute an
8436 appropriate index type for the array. If non-NULL, NAME is the
8437 name of the thing being declared. */
8440 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8445 if (error_operand_p (size
))
8446 return error_mark_node
;
8448 if (!type_dependent_expression_p (size
))
8450 tree type
= TREE_TYPE (size
);
8452 mark_rvalue_use (size
);
8454 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8455 && TREE_SIDE_EFFECTS (size
))
8456 /* In C++98, we mark a non-constant array bound with a magic
8457 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8460 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
8462 if (CLASS_TYPE_P (type
)
8463 && CLASSTYPE_LITERAL_P (type
))
8465 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8468 if (!(complain
& tf_error
))
8469 return error_mark_node
;
8471 error ("size of array %qD has non-integral type %qT",
8474 error ("size of array has non-integral type %qT", type
);
8475 size
= integer_one_node
;
8477 if (size
== error_mark_node
)
8478 return error_mark_node
;
8479 type
= TREE_TYPE (size
);
8482 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8483 size
= maybe_constant_value (size
);
8485 if (!TREE_CONSTANT (size
))
8489 if (error_operand_p (size
))
8490 return error_mark_node
;
8492 /* The array bound must be an integer type. */
8493 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8495 if (!(complain
& tf_error
))
8496 return error_mark_node
;
8498 error ("size of array %qD has non-integral type %qT", name
, type
);
8500 error ("size of array has non-integral type %qT", type
);
8501 size
= integer_one_node
;
8502 type
= TREE_TYPE (size
);
8506 /* A type is dependent if it is...an array type constructed from any
8507 dependent type or whose size is specified by a constant expression
8508 that is value-dependent. */
8509 /* We can only call value_dependent_expression_p on integral constant
8510 expressions; treat non-constant expressions as dependent, too. */
8511 if (processing_template_decl
8512 && (type_dependent_expression_p (size
)
8513 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8515 /* We cannot do any checking for a SIZE that isn't known to be
8516 constant. Just build the index type and mark that it requires
8517 structural equality checks. */
8518 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8519 size
, size_one_node
));
8520 TYPE_DEPENDENT_P (itype
) = 1;
8521 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8522 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8526 /* Normally, the array-bound will be a constant. */
8527 if (TREE_CODE (size
) == INTEGER_CST
)
8529 /* Check to see if the array bound overflowed. Make that an
8530 error, no matter how generous we're being. */
8531 constant_expression_error (size
);
8533 /* An array must have a positive number of elements. */
8534 if (tree_int_cst_lt (size
, integer_zero_node
))
8536 if (!(complain
& tf_error
))
8537 return error_mark_node
;
8539 error ("size of array %qD is negative", name
);
8541 error ("size of array is negative");
8542 size
= integer_one_node
;
8544 /* As an extension we allow zero-sized arrays. */
8545 else if (integer_zerop (size
))
8547 if (!(complain
& tf_error
))
8548 /* We must fail if performing argument deduction (as
8549 indicated by the state of complain), so that
8550 another substitution can be found. */
8551 return error_mark_node
;
8552 else if (in_system_header_at (input_location
))
8553 /* Allow them in system headers because glibc uses them. */;
8555 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8557 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8560 else if (TREE_CONSTANT (size
)
8561 /* We don't allow VLAs at non-function scopes, or during
8562 tentative template substitution. */
8563 || !at_function_scope_p ()
8564 || !(complain
& tf_error
))
8566 if (!(complain
& tf_error
))
8567 return error_mark_node
;
8568 /* `(int) &fn' is not a valid array bound. */
8570 error ("size of array %qD is not an integral constant-expression",
8573 error ("size of array is not an integral constant-expression");
8574 size
= integer_one_node
;
8576 else if (pedantic
&& warn_vla
!= 0)
8579 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8581 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8583 else if (warn_vla
> 0)
8587 "variable length array %qD is used", name
);
8590 "variable length array is used");
8593 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8594 /* A variable sized array. */
8595 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8598 HOST_WIDE_INT saved_processing_template_decl
;
8600 /* Compute the index of the largest element in the array. It is
8601 one less than the number of elements in the array. We save
8602 and restore PROCESSING_TEMPLATE_DECL so that computations in
8603 cp_build_binary_op will be appropriately folded. */
8604 saved_processing_template_decl
= processing_template_decl
;
8605 processing_template_decl
= 0;
8606 itype
= cp_build_binary_op (input_location
,
8608 cp_convert (ssizetype
, size
, complain
),
8609 cp_convert (ssizetype
, integer_one_node
,
8612 itype
= fold (itype
);
8613 processing_template_decl
= saved_processing_template_decl
;
8615 if (!TREE_CONSTANT (itype
))
8617 /* A variable sized array. */
8618 itype
= variable_size (itype
);
8620 if (TREE_CODE (itype
) != SAVE_EXPR
)
8622 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8623 they might survive till gimplification. */
8624 tree newitype
= itype
;
8626 cp_walk_tree_without_duplicates (&newitype
,
8627 fold_sizeof_expr_r
, &found
);
8629 itype
= variable_size (fold (newitype
));
8632 stabilize_vla_size (itype
);
8634 if (flag_sanitize
& SANITIZE_VLA
8635 && do_ubsan_in_current_function ())
8637 /* We have to add 1 -- in the ubsan routine we generate
8638 LE_EXPR rather than LT_EXPR. */
8639 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8640 build_one_cst (TREE_TYPE (itype
)));
8641 t
= ubsan_instrument_vla (input_location
, t
);
8642 finish_expr_stmt (t
);
8645 /* Make sure that there was no overflow when creating to a signed
8646 index type. (For example, on a 32-bit machine, an array with
8647 size 2^32 - 1 is too big.) */
8648 else if (TREE_CODE (itype
) == INTEGER_CST
8649 && TREE_OVERFLOW (itype
))
8651 if (!(complain
& tf_error
))
8652 return error_mark_node
;
8653 error ("overflow in array dimension");
8654 TREE_OVERFLOW (itype
) = 0;
8658 /* Create and return the appropriate index type. */
8659 itype
= build_index_type (itype
);
8661 /* If the index type were dependent, we would have returned early, so
8662 remember that it isn't. */
8663 TYPE_DEPENDENT_P (itype
) = 0;
8664 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8668 /* Returns the scope (if any) in which the entity declared by
8669 DECLARATOR will be located. If the entity was declared with an
8670 unqualified name, NULL_TREE is returned. */
8673 get_scope_of_declarator (const cp_declarator
*declarator
)
8675 while (declarator
&& declarator
->kind
!= cdk_id
)
8676 declarator
= declarator
->declarator
;
8678 /* If the declarator-id is a SCOPE_REF, the scope in which the
8679 declaration occurs is the first operand. */
8681 && declarator
->u
.id
.qualifying_scope
)
8682 return declarator
->u
.id
.qualifying_scope
;
8684 /* Otherwise, the declarator is not a qualified name; the entity will
8685 be declared in the current scope. */
8689 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8690 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8694 create_array_type_for_decl (tree name
, tree type
, tree size
)
8696 tree itype
= NULL_TREE
;
8698 /* If things have already gone awry, bail now. */
8699 if (type
== error_mark_node
|| size
== error_mark_node
)
8700 return error_mark_node
;
8702 /* 8.3.4/1: If the type of the identifier of D contains the auto
8703 type-specifier, the program is ill-formed. */
8704 if (type_uses_auto (type
))
8706 error ("%qD declared as array of %qT", name
, type
);
8707 return error_mark_node
;
8710 /* If there are some types which cannot be array elements,
8711 issue an error-message and return. */
8712 switch (TREE_CODE (type
))
8716 error ("declaration of %qD as array of void", name
);
8718 error ("creating array of void");
8719 return error_mark_node
;
8723 error ("declaration of %qD as array of functions", name
);
8725 error ("creating array of functions");
8726 return error_mark_node
;
8728 case REFERENCE_TYPE
:
8730 error ("declaration of %qD as array of references", name
);
8732 error ("creating array of references");
8733 return error_mark_node
;
8737 error ("declaration of %qD as array of function members", name
);
8739 error ("creating array of function members");
8740 return error_mark_node
;
8748 The constant expressions that specify the bounds of the arrays
8749 can be omitted only for the first member of the sequence. */
8750 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8753 error ("declaration of %qD as multidimensional array must "
8754 "have bounds for all dimensions except the first",
8757 error ("multidimensional array must have bounds for all "
8758 "dimensions except the first");
8760 return error_mark_node
;
8763 /* Figure out the index type for the array. */
8765 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8768 T is called the array element type; this type shall not be [...] an
8769 abstract class type. */
8770 abstract_virtuals_error (name
, type
);
8772 return build_cplus_array_type (type
, itype
);
8775 /* Check that it's OK to declare a function with the indicated TYPE.
8776 SFK indicates the kind of special function (if any) that this
8777 function is. OPTYPE is the type given in a conversion operator
8778 declaration, or the class type for a constructor/destructor.
8779 Returns the actual return type of the function; that
8780 may be different than TYPE if an error occurs, or for certain
8781 special functions. */
8784 check_special_function_return_type (special_function_kind sfk
,
8790 case sfk_constructor
:
8792 error ("return type specification for constructor invalid");
8794 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8795 type
= build_pointer_type (optype
);
8797 type
= void_type_node
;
8800 case sfk_destructor
:
8802 error ("return type specification for destructor invalid");
8803 /* We can't use the proper return type here because we run into
8804 problems with ambiguous bases and covariant returns.
8805 Java classes are left unchanged because (void *) isn't a valid
8806 Java type, and we don't want to change the Java ABI. */
8807 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8808 type
= build_pointer_type (void_type_node
);
8810 type
= void_type_node
;
8813 case sfk_conversion
:
8815 error ("return type specified for %<operator %T%>", optype
);
8826 /* A variable or data member (whose unqualified name is IDENTIFIER)
8827 has been declared with the indicated TYPE. If the TYPE is not
8828 acceptable, issue an error message and return a type to use for
8829 error-recovery purposes. */
8832 check_var_type (tree identifier
, tree type
)
8834 if (VOID_TYPE_P (type
))
8837 error ("unnamed variable or field declared void");
8838 else if (identifier_p (identifier
))
8840 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8841 error ("variable or field %qE declared void", identifier
);
8844 error ("variable or field declared void");
8845 type
= error_mark_node
;
8851 /* Given declspecs and a declarator (abstract or otherwise), determine
8852 the name and type of the object declared and construct a DECL node
8855 DECLSPECS points to the representation of declaration-specifier
8856 sequence that precedes declarator.
8858 DECL_CONTEXT says which syntactic context this declaration is in:
8859 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8860 FUNCDEF for a function definition. Like NORMAL but a few different
8861 error messages in each case. Return value may be zero meaning
8862 this definition is too screwy to try to parse.
8863 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8864 handle member functions (which have FIELD context).
8865 Return value may be zero meaning this definition is too screwy to
8867 PARM for a parameter declaration (either within a function prototype
8868 or before a function body). Make a PARM_DECL, or return void_type_node.
8869 TPARM for a template parameter declaration.
8870 CATCHPARM for a parameter declaration before a catch clause.
8871 TYPENAME if for a typename (in a cast or sizeof).
8872 Don't make a DECL node; just return the ..._TYPE node.
8873 FIELD for a struct or union field; make a FIELD_DECL.
8874 BITFIELD for a field with specified width.
8876 INITIALIZED is as for start_decl.
8878 ATTRLIST is a pointer to the list of attributes, which may be NULL
8879 if there are none; *ATTRLIST may be modified if attributes from inside
8880 the declarator should be applied to the declaration.
8882 When this function is called, scoping variables (such as
8883 CURRENT_CLASS_TYPE) should reflect the scope in which the
8884 declaration occurs, not the scope in which the new declaration will
8885 be placed. For example, on:
8889 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8892 Returns a DECL (if a declarator is present), a TYPE (if there is no
8893 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8897 grokdeclarator (const cp_declarator
*declarator
,
8898 cp_decl_specifier_seq
*declspecs
,
8899 enum decl_context decl_context
,
8903 tree type
= NULL_TREE
;
8905 int explicit_intN
= 0;
8906 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8907 int explicit_int
= 0;
8908 int explicit_char
= 0;
8909 int defaulted_int
= 0;
8911 tree typedef_decl
= NULL_TREE
;
8912 const char *name
= NULL
;
8913 tree typedef_type
= NULL_TREE
;
8914 /* True if this declarator is a function definition. */
8915 bool funcdef_flag
= false;
8916 cp_declarator_kind innermost_code
= cdk_error
;
8919 /* See the code below that used this. */
8920 tree decl_attr
= NULL_TREE
;
8923 /* Keep track of what sort of function is being processed
8924 so that we can warn about default return values, or explicit
8925 return values which do not match prescribed defaults. */
8926 special_function_kind sfk
= sfk_none
;
8928 tree dname
= NULL_TREE
;
8929 tree ctor_return_type
= NULL_TREE
;
8930 enum overload_flags flags
= NO_SPECIAL
;
8931 /* cv-qualifiers that apply to the declarator, for a declaration of
8932 a member function. */
8933 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8934 /* virt-specifiers that apply to the declarator, for a declaration of
8935 a member function. */
8936 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8937 /* ref-qualifier that applies to the declarator, for a declaration of
8938 a member function. */
8939 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
8940 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8942 tree raises
= NULL_TREE
;
8943 int template_count
= 0;
8944 tree returned_attrs
= NULL_TREE
;
8945 tree parms
= NULL_TREE
;
8946 const cp_declarator
*id_declarator
;
8947 /* The unqualified name of the declarator; either an
8948 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8949 tree unqualified_id
;
8950 /* The class type, if any, in which this entity is located,
8951 or NULL_TREE if none. Note that this value may be different from
8952 the current class type; for example if an attempt is made to declare
8953 "A::f" inside "B", this value will be "A". */
8954 tree ctype
= current_class_type
;
8955 /* The NAMESPACE_DECL for the namespace in which this entity is
8956 located. If an unqualified name is used to declare the entity,
8957 this value will be NULL_TREE, even if the entity is located at
8959 tree in_namespace
= NULL_TREE
;
8960 cp_storage_class storage_class
;
8961 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8962 bool type_was_error_mark_node
= false;
8963 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8964 bool template_type_arg
= false;
8965 bool template_parm_flag
= false;
8966 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
8967 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8968 bool late_return_type_p
= false;
8969 bool array_parameter_p
= false;
8970 source_location saved_loc
= input_location
;
8973 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8974 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8975 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8976 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8977 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8978 explicit_intN
= declspecs
->explicit_intN_p
;
8979 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8981 if (decl_context
== FUNCDEF
)
8982 funcdef_flag
= true, decl_context
= NORMAL
;
8983 else if (decl_context
== MEMFUNCDEF
)
8984 funcdef_flag
= true, decl_context
= FIELD
;
8985 else if (decl_context
== BITFIELD
)
8986 bitfield
= 1, decl_context
= FIELD
;
8987 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8988 template_type_arg
= true, decl_context
= TYPENAME
;
8989 else if (decl_context
== TPARM
)
8990 template_parm_flag
= true, decl_context
= PARM
;
8992 if (initialized
> 1)
8993 funcdef_flag
= true;
8995 /* Look inside a declarator for the name being declared
8996 and get it as a string, for an error message. */
8997 for (id_declarator
= declarator
;
8999 id_declarator
= id_declarator
->declarator
)
9001 if (id_declarator
->kind
!= cdk_id
)
9002 innermost_code
= id_declarator
->kind
;
9004 switch (id_declarator
->kind
)
9007 if (id_declarator
->declarator
9008 && id_declarator
->declarator
->kind
== cdk_id
)
9010 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
9011 if (sfk
== sfk_destructor
)
9018 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
9019 tree decl
= id_declarator
->u
.id
.unqualified_name
;
9022 if (qualifying_scope
)
9024 if (at_function_scope_p ())
9028 A declarator-id shall not be qualified except
9031 None of the cases are permitted in block
9033 if (qualifying_scope
== global_namespace
)
9034 error ("invalid use of qualified-name %<::%D%>",
9036 else if (TYPE_P (qualifying_scope
))
9037 error ("invalid use of qualified-name %<%T::%D%>",
9038 qualifying_scope
, decl
);
9040 error ("invalid use of qualified-name %<%D::%D%>",
9041 qualifying_scope
, decl
);
9042 return error_mark_node
;
9044 else if (TYPE_P (qualifying_scope
))
9046 ctype
= qualifying_scope
;
9047 if (!MAYBE_CLASS_TYPE_P (ctype
))
9049 error ("%q#T is not a class or a namespace", ctype
);
9052 else if (innermost_code
!= cdk_function
9053 && current_class_type
9054 && !uniquely_derived_from_p (ctype
,
9055 current_class_type
))
9057 error ("invalid use of qualified-name %<%T::%D%>",
9058 qualifying_scope
, decl
);
9059 return error_mark_node
;
9062 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
9063 in_namespace
= qualifying_scope
;
9065 switch (TREE_CODE (decl
))
9071 if (innermost_code
!= cdk_function
)
9073 error ("declaration of %qD as non-function", decl
);
9074 return error_mark_node
;
9076 else if (!qualifying_scope
9077 && !(current_class_type
&& at_class_scope_p ()))
9079 error ("declaration of %qD as non-member", decl
);
9080 return error_mark_node
;
9083 type
= TREE_OPERAND (decl
, 0);
9085 type
= constructor_name (type
);
9086 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
9091 case TEMPLATE_ID_EXPR
:
9093 tree fns
= TREE_OPERAND (decl
, 0);
9096 if (!identifier_p (dname
))
9098 if (variable_template_p (dname
))
9099 dname
= DECL_NAME (dname
);
9102 gcc_assert (is_overloaded_fn (dname
));
9103 dname
= DECL_NAME (get_first_fn (dname
));
9109 case IDENTIFIER_NODE
:
9110 if (identifier_p (decl
))
9113 if (C_IS_RESERVED_WORD (dname
))
9115 error ("declarator-id missing; using reserved word %qD",
9117 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9119 else if (!IDENTIFIER_TYPENAME_P (dname
))
9120 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9123 gcc_assert (flags
== NO_SPECIAL
);
9124 flags
= TYPENAME_FLAG
;
9125 ctor_return_type
= TREE_TYPE (dname
);
9126 sfk
= sfk_conversion
;
9127 if (is_typename_at_global_scope (dname
))
9128 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9130 name
= "<invalid operator>";
9147 return error_mark_node
;
9152 if (id_declarator
->kind
== cdk_id
)
9158 The declarator in a function-definition shall have the form
9159 D1 ( parameter-declaration-clause) ... */
9160 if (funcdef_flag
&& innermost_code
!= cdk_function
)
9162 error ("function definition does not declare parameters");
9163 return error_mark_node
;
9166 if (flags
== TYPENAME_FLAG
9167 && innermost_code
!= cdk_function
9168 && ! (ctype
&& !declspecs
->any_specifiers_p
))
9170 error ("declaration of %qD as non-function", dname
);
9171 return error_mark_node
;
9175 && identifier_p (dname
)
9176 && UDLIT_OPER_P (dname
)
9177 && innermost_code
!= cdk_function
)
9179 error ("declaration of %qD as non-function", dname
);
9180 return error_mark_node
;
9183 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9187 error ("declaration of %qD as %<typedef%>", dname
);
9188 return error_mark_node
;
9190 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9192 error ("declaration of %qD as parameter", dname
);
9193 return error_mark_node
;
9197 /* Anything declared one level down from the top level
9198 must be one of the parameters of a function
9199 (because the body is at least two levels down). */
9201 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9202 by not allowing C++ class definitions to specify their parameters
9203 with xdecls (must be spec.d in the parmlist).
9205 Since we now wait to push a class scope until we are sure that
9206 we are in a legitimate method context, we must set oldcname
9207 explicitly (since current_class_name is not yet alive).
9209 We also want to avoid calling this a PARM if it is in a namespace. */
9211 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9213 cp_binding_level
*b
= current_binding_level
;
9214 current_binding_level
= b
->level_chain
;
9215 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9216 decl_context
= PARM
;
9217 current_binding_level
= b
;
9221 name
= decl_context
== PARM
? "parameter" : "type name";
9223 if (constexpr_p
&& typedef_p
)
9225 error ("%<constexpr%> cannot appear in a typedef declaration");
9226 return error_mark_node
;
9229 /* If there were multiple types specified in the decl-specifier-seq,
9230 issue an error message. */
9231 if (declspecs
->multiple_types_p
)
9233 error ("two or more data types in declaration of %qs", name
);
9234 return error_mark_node
;
9237 if (declspecs
->conflicting_specifiers_p
)
9239 error ("conflicting specifiers in declaration of %qs", name
);
9240 return error_mark_node
;
9243 /* Extract the basic type from the decl-specifier-seq. */
9244 type
= declspecs
->type
;
9245 if (type
== error_mark_node
)
9248 type_was_error_mark_node
= true;
9250 /* If the entire declaration is itself tagged as deprecated then
9251 suppress reports of deprecated items. */
9252 if (type
&& TREE_DEPRECATED (type
)
9253 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9254 warn_deprecated_use (type
, NULL_TREE
);
9255 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9257 typedef_decl
= type
;
9258 type
= TREE_TYPE (typedef_decl
);
9259 if (TREE_DEPRECATED (type
)
9260 && DECL_ARTIFICIAL (typedef_decl
)
9261 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9262 warn_deprecated_use (type
, NULL_TREE
);
9264 /* No type at all: default to `int', and set DEFAULTED_INT
9265 because it was not a user-defined typedef. */
9266 if (type
== NULL_TREE
)
9268 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
9270 /* These imply 'int'. */
9271 type
= integer_type_node
;
9274 /* If we just have "complex", it is equivalent to "complex double". */
9275 else if (!longlong
&& !explicit_intN
9276 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9278 type
= double_type_node
;
9279 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
9280 "ISO C++ does not support plain %<complex%> meaning "
9281 "%<double complex%>");
9285 explicit_int
= declspecs
->explicit_int_p
;
9286 explicit_char
= declspecs
->explicit_char_p
;
9289 /* See the code below that used this. */
9291 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9293 typedef_type
= type
;
9296 if (sfk
!= sfk_conversion
)
9297 ctor_return_type
= ctype
;
9299 if (sfk
!= sfk_none
)
9300 type
= check_special_function_return_type (sfk
, type
,
9302 else if (type
== NULL_TREE
)
9308 /* We handle `main' specially here, because 'main () { }' is so
9309 common. With no options, it is allowed. With -Wreturn-type,
9310 it is a warning. It is only an error with -pedantic-errors. */
9311 is_main
= (funcdef_flag
9312 && dname
&& identifier_p (dname
)
9313 && MAIN_NAME_P (dname
)
9314 && ctype
== NULL_TREE
9315 && in_namespace
== NULL_TREE
9316 && current_namespace
== global_namespace
);
9318 if (type_was_error_mark_node
)
9319 /* We've already issued an error, don't complain more. */;
9320 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9321 /* Allow it, sigh. */;
9323 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9325 pedwarn (input_location
, OPT_Wpedantic
,
9326 "ISO C++ forbids declaration of %qs with no type", name
);
9328 warning (OPT_Wreturn_type
,
9329 "ISO C++ forbids declaration of %qs with no type", name
);
9331 if (type_was_error_mark_node
&& template_parm_flag
)
9332 /* FIXME we should be able to propagate the error_mark_node as is
9333 for other contexts too. */
9334 type
= error_mark_node
;
9336 type
= integer_type_node
;
9343 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
9345 error ("%<__int%d%> is not supported by this target",
9346 int_n_data
[declspecs
->int_n_idx
].bitsize
);
9347 explicit_intN
= false;
9349 else if (pedantic
&& ! in_system_header_at (input_location
))
9350 pedwarn (input_location
, OPT_Wpedantic
,
9351 "ISO C++ does not support %<__int%d%> for %qs",
9352 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
9355 /* Now process the modifiers that were specified
9356 and check for invalid combinations. */
9358 /* Long double is a special combination. */
9359 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9362 type
= cp_build_qualified_type (long_double_type_node
,
9363 cp_type_quals (type
));
9366 /* Check all other uses of type modifiers. */
9368 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9372 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9373 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9374 else if (signed_p
&& unsigned_p
)
9375 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9376 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9377 error ("%<long long%> invalid for %qs", name
);
9378 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9379 error ("%<long%> invalid for %qs", name
);
9380 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9381 error ("%<short%> invalid for %qs", name
);
9382 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9383 error ("%<long%> or %<short%> invalid for %qs", name
);
9384 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
9385 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9386 else if ((long_p
|| short_p
) && explicit_char
)
9387 error ("%<long%> or %<short%> specified with char for %qs", name
);
9388 else if (long_p
&& short_p
)
9389 error ("%<long%> and %<short%> specified together for %qs", name
);
9390 else if (type
== char16_type_node
|| type
== char32_type_node
)
9392 if (signed_p
|| unsigned_p
)
9393 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9394 else if (short_p
|| long_p
)
9395 error ("%<short%> or %<long%> invalid for %qs", name
);
9400 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
9402 pedwarn (input_location
, OPT_Wpedantic
,
9403 "long, short, signed or unsigned used invalidly for %qs",
9405 if (flag_pedantic_errors
)
9410 /* Discard the type modifiers if they are invalid. */
9421 /* Decide whether an integer type is signed or not.
9422 Optionally treat bitfields as signed by default. */
9426 It is implementation-defined whether a plain (neither
9427 explicitly signed or unsigned) char, short, int, or long
9428 bit-field is signed or unsigned.
9430 Naturally, we extend this to long long as well. Note that
9431 this does not include wchar_t. */
9432 || (bitfield
&& !flag_signed_bitfields
9434 /* A typedef for plain `int' without `signed' can be
9435 controlled just like plain `int', but a typedef for
9436 `signed int' cannot be so controlled. */
9438 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9439 && TREE_CODE (type
) == INTEGER_TYPE
9440 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9443 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
9445 type
= long_long_unsigned_type_node
;
9447 type
= long_unsigned_type_node
;
9449 type
= short_unsigned_type_node
;
9450 else if (type
== char_type_node
)
9451 type
= unsigned_char_type_node
;
9452 else if (typedef_decl
)
9453 type
= unsigned_type_for (type
);
9455 type
= unsigned_type_node
;
9457 else if (signed_p
&& type
== char_type_node
)
9458 type
= signed_char_type_node
;
9459 else if (explicit_intN
)
9460 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
9462 type
= long_long_integer_type_node
;
9464 type
= long_integer_type_node
;
9466 type
= short_integer_type_node
;
9468 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9470 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9471 error ("complex invalid for %qs", name
);
9472 /* If a modifier is specified, the resulting complex is the complex
9473 form of TYPE. E.g, "complex short" is "complex short int". */
9474 else if (type
== integer_type_node
)
9475 type
= complex_integer_type_node
;
9476 else if (type
== float_type_node
)
9477 type
= complex_float_type_node
;
9478 else if (type
== double_type_node
)
9479 type
= complex_double_type_node
;
9480 else if (type
== long_double_type_node
)
9481 type
= complex_long_double_type_node
;
9483 type
= build_complex_type (type
);
9486 type_quals
= TYPE_UNQUALIFIED
;
9487 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9488 type_quals
|= TYPE_QUAL_CONST
;
9489 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9490 type_quals
|= TYPE_QUAL_VOLATILE
;
9491 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9492 type_quals
|= TYPE_QUAL_RESTRICT
;
9493 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9494 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9497 /* If we're using the injected-class-name to form a compound type or a
9498 declaration, replace it with the underlying class so we don't get
9499 redundant typedefs in the debug output. But if we are returning the
9500 type unchanged, leave it alone so that it's available to
9501 maybe_get_template_decl_from_type_decl. */
9502 if (CLASS_TYPE_P (type
)
9503 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9504 && type
== TREE_TYPE (TYPE_NAME (type
))
9505 && (declarator
|| type_quals
))
9506 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9508 type_quals
|= cp_type_quals (type
);
9509 type
= cp_build_qualified_type_real
9510 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
9511 || declspecs
->decltype_p
)
9512 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9513 /* We might have ignored or rejected some of the qualifiers. */
9514 type_quals
= cp_type_quals (type
);
9517 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9518 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9519 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9521 storage_class
= declspecs
->storage_class
;
9522 if (storage_class
== sc_static
)
9523 staticp
= 1 + (decl_context
== FIELD
);
9525 if (virtualp
&& staticp
== 2)
9527 error ("member %qD cannot be declared both virtual and static", dname
);
9528 storage_class
= sc_none
;
9531 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9533 /* Issue errors about use of storage classes for parameters. */
9534 if (decl_context
== PARM
)
9538 error ("typedef declaration invalid in parameter declaration");
9539 return error_mark_node
;
9541 else if (template_parm_flag
&& storage_class
!= sc_none
)
9543 error ("storage class specified for template parameter %qs", name
);
9544 return error_mark_node
;
9546 else if (storage_class
== sc_static
9547 || storage_class
== sc_extern
9549 error ("storage class specifiers invalid in parameter declarations");
9551 /* Function parameters cannot be constexpr. If we saw one, moan
9552 and pretend it wasn't there. */
9555 error ("a parameter cannot be declared %<constexpr%>");
9560 /* Give error if `virtual' is used outside of class declaration. */
9562 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9564 error_at (declspecs
->locations
[ds_virtual
],
9565 "%<virtual%> outside class declaration");
9569 /* Static anonymous unions are dealt with here. */
9570 if (staticp
&& decl_context
== TYPENAME
9572 && ANON_AGGR_TYPE_P (declspecs
->type
))
9573 decl_context
= FIELD
;
9575 /* Warn about storage classes that are invalid for certain
9576 kinds of declarations (parameters, typenames, etc.). */
9579 && storage_class
!= sc_extern
9580 && storage_class
!= sc_static
)
9583 error ("multiple storage classes in declaration of %qs", name
);
9586 if (decl_context
!= NORMAL
9587 && ((storage_class
!= sc_none
9588 && storage_class
!= sc_mutable
)
9591 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9592 && (storage_class
== sc_register
9593 || storage_class
== sc_auto
))
9597 else if (decl_context
== FIELD
9598 /* C++ allows static class elements. */
9599 && storage_class
== sc_static
)
9600 /* C++ also allows inlines and signed and unsigned elements,
9601 but in those cases we don't come in here. */
9605 if (decl_context
== FIELD
)
9606 error ("storage class specified for %qs", name
);
9609 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9610 error ("storage class specified for parameter %qs", name
);
9612 error ("storage class specified for typename");
9614 if (storage_class
== sc_register
9615 || storage_class
== sc_auto
9616 || storage_class
== sc_extern
9618 storage_class
= sc_none
;
9621 else if (storage_class
== sc_extern
&& funcdef_flag
9622 && ! toplevel_bindings_p ())
9623 error ("nested function %qs declared %<extern%>", name
);
9624 else if (toplevel_bindings_p ())
9626 if (storage_class
== sc_auto
)
9627 error ("top-level declaration of %qs specifies %<auto%>", name
);
9630 && storage_class
!= sc_extern
9631 && storage_class
!= sc_static
)
9633 if (declspecs
->gnu_thread_keyword_p
)
9634 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9635 "declared %<__thread%>", name
);
9637 /* When thread_local is applied to a variable of block scope the
9638 storage-class-specifier static is implied if it does not appear
9640 storage_class
= declspecs
->storage_class
= sc_static
;
9644 if (storage_class
&& friendp
)
9646 error ("storage class specifiers invalid in friend function declarations");
9647 storage_class
= sc_none
;
9652 unqualified_id
= NULL_TREE
;
9655 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9656 switch (TREE_CODE (unqualified_id
))
9659 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9660 if (TYPE_P (unqualified_id
))
9661 unqualified_id
= constructor_name (unqualified_id
);
9664 case IDENTIFIER_NODE
:
9665 case TEMPLATE_ID_EXPR
:
9673 if (declspecs
->std_attributes
)
9675 /* Apply the c++11 attributes to the type preceding them. */
9676 input_location
= declspecs
->locations
[ds_std_attribute
];
9677 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9678 input_location
= saved_loc
;
9681 /* Determine the type of the entity declared by recurring on the
9683 for (; declarator
; declarator
= declarator
->declarator
)
9685 const cp_declarator
*inner_declarator
;
9688 if (type
== error_mark_node
)
9689 return error_mark_node
;
9691 attrs
= declarator
->attributes
;
9697 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9698 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9699 if (declarator
->kind
== cdk_function
)
9700 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9701 if (declarator
->kind
== cdk_array
)
9702 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9703 returned_attrs
= decl_attributes (&type
,
9704 chainon (returned_attrs
, attrs
),
9708 if (declarator
->kind
== cdk_id
)
9711 inner_declarator
= declarator
->declarator
;
9713 switch (declarator
->kind
)
9716 type
= create_array_type_for_decl (dname
, type
,
9717 declarator
->u
.array
.bounds
);
9718 if (declarator
->std_attributes
)
9721 The optional attribute-specifier-seq appertains to the
9723 returned_attrs
= chainon (returned_attrs
,
9724 declarator
->std_attributes
);
9732 /* Declaring a function type.
9733 Make sure we have a valid type for the function to return. */
9735 if (type_quals
!= TYPE_UNQUALIFIED
)
9737 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9738 warning (OPT_Wignored_qualifiers
,
9739 "type qualifiers ignored on function return type");
9740 /* We now know that the TYPE_QUALS don't apply to the
9741 decl, but to its return type. */
9742 type_quals
= TYPE_UNQUALIFIED
;
9744 errmsg
= targetm
.invalid_return_type (type
);
9748 type
= integer_type_node
;
9751 /* Error about some types functions can't return. */
9753 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9755 error ("%qs declared as function returning a function", name
);
9756 return error_mark_node
;
9758 if (TREE_CODE (type
) == ARRAY_TYPE
)
9760 error ("%qs declared as function returning an array", name
);
9761 return error_mark_node
;
9764 input_location
= declspecs
->locations
[ds_type_spec
];
9765 abstract_virtuals_error (ACU_RETURN
, type
);
9766 input_location
= saved_loc
;
9768 /* Pick up type qualifiers which should be applied to `this'. */
9769 memfn_quals
= declarator
->u
.function
.qualifiers
;
9770 /* Pick up virt-specifiers. */
9771 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9772 /* And ref-qualifier, too */
9773 rqual
= declarator
->u
.function
.ref_qualifier
;
9774 /* Pick up the exception specifications. */
9775 raises
= declarator
->u
.function
.exception_specification
;
9776 /* If the exception-specification is ill-formed, let's pretend
9777 there wasn't one. */
9778 if (raises
== error_mark_node
)
9781 /* Say it's a definition only for the CALL_EXPR
9782 closest to the identifier. */
9783 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9785 /* Handle a late-specified return type. */
9788 if (type_uses_auto (type
))
9790 if (!declarator
->u
.function
.late_return_type
)
9792 if (current_class_type
9793 && LAMBDA_TYPE_P (current_class_type
))
9794 /* OK for C++11 lambdas. */;
9795 else if (cxx_dialect
< cxx14
)
9797 error ("%qs function uses "
9798 "%<auto%> type specifier without trailing "
9799 "return type", name
);
9800 inform (input_location
, "deduced return type "
9801 "only available with -std=c++14 or "
9806 error ("virtual function cannot "
9807 "have deduced return type");
9811 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
9813 error ("%qs function with trailing return type has"
9814 " %qT as its type rather than plain %<auto%>",
9816 return error_mark_node
;
9819 else if (declarator
->u
.function
.late_return_type
9820 && sfk
!= sfk_conversion
)
9822 if (cxx_dialect
< cxx11
)
9823 /* Not using maybe_warn_cpp0x because this should
9824 always be an error. */
9825 error ("trailing return type only available with "
9826 "-std=c++11 or -std=gnu++11");
9828 error ("%qs function with trailing return type not "
9829 "declared with %<auto%> type specifier", name
);
9830 return error_mark_node
;
9833 type
= splice_late_return_type
9834 (type
, declarator
->u
.function
.late_return_type
);
9835 if (type
== error_mark_node
)
9836 return error_mark_node
;
9838 if (declarator
->u
.function
.late_return_type
)
9839 late_return_type_p
= true;
9841 if (ctype
== NULL_TREE
9842 && decl_context
== FIELD
9845 ctype
= current_class_type
;
9847 if (ctype
&& (sfk
== sfk_constructor
9848 || sfk
== sfk_destructor
))
9850 /* We are within a class's scope. If our declarator name
9851 is the same as the class name, and we are defining
9852 a function, then it is a constructor/destructor, and
9853 therefore returns a void type. */
9855 /* ISO C++ 12.4/2. A destructor may not be declared
9856 const or volatile. A destructor may not be static.
9857 A destructor may not be declared with ref-qualifier.
9859 ISO C++ 12.1. A constructor may not be declared
9860 const or volatile. A constructor may not be
9861 virtual. A constructor may not be static.
9862 A constructor may not be declared with ref-qualifier. */
9864 error ((flags
== DTOR_FLAG
)
9865 ? G_("destructor cannot be static member function")
9866 : G_("constructor cannot be static member function"));
9869 error ((flags
== DTOR_FLAG
)
9870 ? G_("destructors may not be cv-qualified")
9871 : G_("constructors may not be cv-qualified"));
9872 memfn_quals
= TYPE_UNQUALIFIED
;
9877 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
9878 error ((flags
== DTOR_FLAG
)
9879 ? "destructors may not be ref-qualified"
9880 : "constructors may not be ref-qualified");
9881 rqual
= REF_QUAL_NONE
;
9884 if (decl_context
== FIELD
9885 && !member_function_or_else (ctype
,
9888 return error_mark_node
;
9890 if (flags
!= DTOR_FLAG
)
9892 /* It's a constructor. */
9897 permerror (input_location
, "constructors cannot be declared virtual");
9900 if (decl_context
== FIELD
9901 && sfk
!= sfk_constructor
)
9902 return error_mark_node
;
9904 if (decl_context
== FIELD
)
9911 /* Cannot be both friend and virtual. */
9912 error ("virtual functions cannot be friends");
9915 if (decl_context
== NORMAL
)
9916 error ("friend declaration not in class definition");
9917 if (current_function_decl
&& funcdef_flag
)
9918 error ("can%'t define friend function %qs in a local "
9922 else if (ctype
&& sfk
== sfk_conversion
)
9926 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9929 if (late_return_type_p
)
9930 error ("a conversion function cannot have a trailing return type");
9933 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9936 if (inner_declarator
9937 && inner_declarator
->kind
== cdk_id
9938 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9939 && arg_types
!= void_list_node
)
9941 error ("destructors may not have parameters");
9942 arg_types
= void_list_node
;
9946 type
= build_function_type (type
, arg_types
);
9947 if (declarator
->std_attributes
)
9950 The optional attribute-specifier-seq appertains to
9951 the function type. */
9952 decl_attributes (&type
, declarator
->std_attributes
,
9960 /* Filter out pointers-to-references and references-to-references.
9961 We can get these if a TYPE_DECL is used. */
9963 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9965 if (declarator
->kind
!= cdk_reference
)
9967 error ("cannot declare pointer to %q#T", type
);
9968 type
= TREE_TYPE (type
);
9971 /* In C++0x, we allow reference to reference declarations
9972 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9973 and template type arguments [14.3.1/4 temp.arg.type]. The
9974 check for direct reference to reference declarations, which
9975 are still forbidden, occurs below. Reasoning behind the change
9976 can be found in DR106, DR540, and the rvalue reference
9978 else if (cxx_dialect
== cxx98
)
9980 error ("cannot declare reference to %q#T", type
);
9981 type
= TREE_TYPE (type
);
9984 else if (VOID_TYPE_P (type
))
9986 if (declarator
->kind
== cdk_reference
)
9987 error ("cannot declare reference to %q#T", type
);
9988 else if (declarator
->kind
== cdk_ptrmem
)
9989 error ("cannot declare pointer to %q#T member", type
);
9992 /* We now know that the TYPE_QUALS don't apply to the decl,
9993 but to the target of the pointer. */
9994 type_quals
= TYPE_UNQUALIFIED
;
9996 /* This code used to handle METHOD_TYPE, but I don't think it's
9997 possible to get it here anymore. */
9998 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9999 if (declarator
->kind
== cdk_ptrmem
10000 && TREE_CODE (type
) == FUNCTION_TYPE
)
10002 memfn_quals
|= type_memfn_quals (type
);
10003 type
= build_memfn_type (type
,
10004 declarator
->u
.pointer
.class_type
,
10007 if (type
== error_mark_node
)
10008 return error_mark_node
;
10010 rqual
= REF_QUAL_NONE
;
10011 memfn_quals
= TYPE_UNQUALIFIED
;
10014 if (TREE_CODE (type
) == FUNCTION_TYPE
10015 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
10016 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
10017 error (declarator
->kind
== cdk_reference
10018 ? G_("cannot declare reference to qualified function type %qT")
10019 : G_("cannot declare pointer to qualified function type %qT"),
10022 /* When the pointed-to type involves components of variable size,
10023 care must be taken to ensure that the size evaluation code is
10024 emitted early enough to dominate all the possible later uses
10025 and late enough for the variables on which it depends to have
10028 This is expected to happen automatically when the pointed-to
10029 type has a name/declaration of it's own, but special attention
10030 is required if the type is anonymous.
10032 We handle the NORMAL and FIELD contexts here by inserting a
10033 dummy statement that just evaluates the size at a safe point
10034 and ensures it is not deferred until e.g. within a deeper
10035 conditional context (c++/43555).
10037 We expect nothing to be needed here for PARM or TYPENAME.
10038 Evaluating the size at this point for TYPENAME would
10039 actually be incorrect, as we might be in the middle of an
10040 expression with side effects on the pointed-to type size
10041 "arguments" prior to the pointer declaration point and the
10042 size evaluation could end up prior to the side effects. */
10044 if (!TYPE_NAME (type
)
10045 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
10046 && at_function_scope_p ()
10047 && variably_modified_type_p (type
, NULL_TREE
))
10048 /* Force evaluation of the SAVE_EXPR. */
10049 finish_expr_stmt (TYPE_SIZE (type
));
10051 if (declarator
->kind
== cdk_reference
)
10053 /* In C++0x, the type we are creating a reference to might be
10054 a typedef which is itself a reference type. In that case,
10055 we follow the reference collapsing rules in
10056 [7.1.3/8 dcl.typedef] to create the final reference type:
10058 "If a typedef TD names a type that is a reference to a type
10059 T, an attempt to create the type 'lvalue reference to cv TD'
10060 creates the type 'lvalue reference to T,' while an attempt
10061 to create the type "rvalue reference to cv TD' creates the
10064 if (VOID_TYPE_P (type
))
10065 /* We already gave an error. */;
10066 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10068 if (declarator
->u
.reference
.rvalue_ref
)
10069 /* Leave type alone. */;
10071 type
= cp_build_reference_type (TREE_TYPE (type
), false);
10074 type
= cp_build_reference_type
10075 (type
, declarator
->u
.reference
.rvalue_ref
);
10077 /* In C++0x, we need this check for direct reference to
10078 reference declarations, which are forbidden by
10079 [8.3.2/5 dcl.ref]. Reference to reference declarations
10080 are only allowed indirectly through typedefs and template
10081 type arguments. Example:
10083 void foo(int & &); // invalid ref-to-ref decl
10085 typedef int & int_ref;
10086 void foo(int_ref &); // valid ref-to-ref decl
10088 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
10089 error ("cannot declare reference to %q#T, which is not "
10090 "a typedef or a template type argument", type
);
10092 else if (TREE_CODE (type
) == METHOD_TYPE
)
10093 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10094 else if (declarator
->kind
== cdk_ptrmem
)
10096 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
10097 != NAMESPACE_DECL
);
10098 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
10099 /* We will already have complained. */
10100 type
= error_mark_node
;
10102 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
10106 type
= build_pointer_type (type
);
10108 /* Process a list of type modifier keywords (such as
10109 const or volatile) that were given inside the `*' or `&'. */
10111 if (declarator
->u
.pointer
.qualifiers
)
10114 = cp_build_qualified_type (type
,
10115 declarator
->u
.pointer
.qualifiers
);
10116 type_quals
= cp_type_quals (type
);
10119 /* Apply C++11 attributes to the pointer, and not to the
10120 type pointed to. This is unlike what is done for GNU
10121 attributes above. It is to comply with [dcl.ptr]/1:
10123 [the optional attribute-specifier-seq (7.6.1) appertains
10124 to the pointer and not to the object pointed to]. */
10125 if (declarator
->std_attributes
)
10126 decl_attributes (&type
, declarator
->std_attributes
,
10136 gcc_unreachable ();
10140 /* A `constexpr' specifier used in an object declaration declares
10141 the object as `const'. */
10142 if (constexpr_p
&& innermost_code
!= cdk_function
)
10144 /* DR1688 says that a `constexpr' specifier in combination with
10145 `volatile' is valid. */
10147 if (TREE_CODE (type
) != REFERENCE_TYPE
)
10149 type_quals
|= TYPE_QUAL_CONST
;
10150 type
= cp_build_qualified_type (type
, type_quals
);
10154 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
10155 && TREE_CODE (type
) != FUNCTION_TYPE
10156 && TREE_CODE (type
) != METHOD_TYPE
10157 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
10159 error ("template-id %qD used as a declarator",
10161 unqualified_id
= dname
;
10164 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10165 qualified with a class-name, turn it into a METHOD_TYPE, unless
10166 we know that the function is static. We take advantage of this
10167 opportunity to do other processing that pertains to entities
10168 explicitly declared to be class members. Note that if DECLARATOR
10169 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10170 would not have exited the loop above. */
10172 && declarator
->u
.id
.qualifying_scope
10173 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
10175 ctype
= declarator
->u
.id
.qualifying_scope
;
10176 ctype
= TYPE_MAIN_VARIANT (ctype
);
10177 template_count
= num_template_headers_for_class (ctype
);
10179 if (ctype
== current_class_type
)
10183 permerror (input_location
, "member functions are implicitly friends of their class");
10187 permerror (declarator
->id_loc
,
10188 "extra qualification %<%T::%> on member %qs",
10191 else if (/* If the qualifying type is already complete, then we
10192 can skip the following checks. */
10193 !COMPLETE_TYPE_P (ctype
)
10194 && (/* If the function is being defined, then
10195 qualifying type must certainly be complete. */
10197 /* A friend declaration of "T::f" is OK, even if
10198 "T" is a template parameter. But, if this
10199 function is not a friend, the qualifying type
10200 must be a class. */
10201 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10202 /* For a declaration, the type need not be
10203 complete, if either it is dependent (since there
10204 is no meaningful definition of complete in that
10205 case) or the qualifying class is currently being
10207 || !(dependent_type_p (ctype
)
10208 || currently_open_class (ctype
)))
10209 /* Check that the qualifying type is complete. */
10210 && !complete_type_or_else (ctype
, NULL_TREE
))
10211 return error_mark_node
;
10212 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10214 if (current_class_type
10215 && (!friendp
|| funcdef_flag
))
10217 error (funcdef_flag
10218 ? G_("cannot define member function %<%T::%s%> "
10220 : G_("cannot declare member function %<%T::%s%> "
10222 ctype
, name
, current_class_type
);
10223 return error_mark_node
;
10226 else if (typedef_p
&& current_class_type
)
10228 error ("cannot declare member %<%T::%s%> within %qT",
10229 ctype
, name
, current_class_type
);
10230 return error_mark_node
;
10234 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10235 ctype
= current_class_type
;
10237 /* Now TYPE has the actual type. */
10239 if (returned_attrs
)
10242 *attrlist
= chainon (returned_attrs
, *attrlist
);
10244 attrlist
= &returned_attrs
;
10248 && declarator
->kind
== cdk_id
10249 && declarator
->std_attributes
)
10250 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10251 a declarator-id appertains to the entity that is declared. */
10252 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10254 /* Handle parameter packs. */
10255 if (parameter_pack_p
)
10257 if (decl_context
== PARM
)
10258 /* Turn the type into a pack expansion.*/
10259 type
= make_pack_expansion (type
);
10261 error ("non-parameter %qs cannot be a parameter pack", name
);
10264 /* Did array size calculations overflow or does the array cover more
10265 than half of the address-space? */
10266 if (TREE_CODE (type
) == ARRAY_TYPE
10267 && COMPLETE_TYPE_P (type
)
10268 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
10269 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
10271 error ("size of array %qs is too large", name
);
10272 /* If we proceed with the array type as it is, we'll eventually
10273 crash in tree_to_[su]hwi(). */
10274 type
= error_mark_node
;
10277 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10278 && !processing_template_decl
10279 && variably_modified_type_p (type
, NULL_TREE
))
10281 if (decl_context
== FIELD
)
10282 error ("data member may not have variably modified type %qT", type
);
10284 error ("parameter may not have variably modified type %qT", type
);
10285 type
= error_mark_node
;
10288 if (explicitp
== 1 || (explicitp
&& friendp
))
10290 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10291 in the declaration of a constructor or conversion function within
10292 a class definition. */
10293 if (!current_class_type
)
10294 error_at (declspecs
->locations
[ds_explicit
],
10295 "%<explicit%> outside class declaration");
10297 error_at (declspecs
->locations
[ds_explicit
],
10298 "%<explicit%> in friend declaration");
10300 error_at (declspecs
->locations
[ds_explicit
],
10301 "only declarations of constructors and conversion operators "
10302 "can be %<explicit%>");
10306 if (storage_class
== sc_mutable
)
10308 if (decl_context
!= FIELD
|| friendp
)
10310 error ("non-member %qs cannot be declared %<mutable%>", name
);
10311 storage_class
= sc_none
;
10313 else if (decl_context
== TYPENAME
|| typedef_p
)
10315 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10316 storage_class
= sc_none
;
10318 else if (TREE_CODE (type
) == FUNCTION_TYPE
10319 || TREE_CODE (type
) == METHOD_TYPE
)
10321 error ("function %qs cannot be declared %<mutable%>", name
);
10322 storage_class
= sc_none
;
10326 error ("static %qs cannot be declared %<mutable%>", name
);
10327 storage_class
= sc_none
;
10329 else if (type_quals
& TYPE_QUAL_CONST
)
10331 error ("const %qs cannot be declared %<mutable%>", name
);
10332 storage_class
= sc_none
;
10334 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10336 permerror (input_location
, "reference %qs cannot be declared "
10337 "%<mutable%>", name
);
10338 storage_class
= sc_none
;
10342 /* If this is declaring a typedef name, return a TYPE_DECL. */
10343 if (typedef_p
&& decl_context
!= TYPENAME
)
10347 /* Note that the grammar rejects storage classes
10348 in typenames, fields or parameters. */
10349 if (current_lang_name
== lang_name_java
)
10350 TYPE_FOR_JAVA (type
) = 1;
10352 /* This declaration:
10354 typedef void f(int) const;
10356 declares a function type which is not a member of any
10357 particular class, but which is cv-qualified; for
10358 example "f S::*" declares a pointer to a const-qualified
10359 member function of S. We record the cv-qualification in the
10361 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10363 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10365 /* We have now dealt with these qualifiers. */
10366 memfn_quals
= TYPE_UNQUALIFIED
;
10367 rqual
= REF_QUAL_NONE
;
10370 if (type_uses_auto (type
))
10372 error ("typedef declared %<auto%>");
10373 type
= error_mark_node
;
10376 if (decl_context
== FIELD
)
10377 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10379 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10380 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10381 error_at (DECL_SOURCE_LOCATION (decl
),
10382 "typedef name may not be a nested-name-specifier");
10383 TREE_TYPE (decl
) = error_mark_node
;
10386 if (decl_context
!= FIELD
)
10388 if (!current_function_decl
)
10389 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10390 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10391 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10392 (current_function_decl
)))
10393 /* The TYPE_DECL is "abstract" because there will be
10394 clones of this constructor/destructor, and there will
10395 be copies of this TYPE_DECL generated in those
10396 clones. The decloning optimization (for space) may
10397 revert this subsequently if it determines that
10398 the clones should share a common implementation. */
10399 DECL_ABSTRACT_P (decl
) = true;
10401 else if (current_class_type
10402 && constructor_name_p (unqualified_id
, current_class_type
))
10403 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10404 "as enclosing class",
10407 /* If the user declares "typedef struct {...} foo" then the
10408 struct will have an anonymous name. Fill that name in now.
10409 Nothing can refer to it, so nothing needs know about the name
10411 if (type
!= error_mark_node
10413 && TYPE_NAME (type
)
10414 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10415 && TYPE_ANONYMOUS_P (type
)
10416 && declspecs
->type_definition_p
10417 && attributes_naming_typedef_ok (*attrlist
)
10418 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10422 /* Replace the anonymous name with the real name everywhere. */
10423 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10425 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
10426 /* We do not rename the debug info representing the
10427 anonymous tagged type because the standard says in
10428 [dcl.typedef] that the naming applies only for
10429 linkage purposes. */
10430 /*debug_hooks->set_name (t, decl);*/
10431 TYPE_NAME (t
) = decl
;
10434 if (TYPE_LANG_SPECIFIC (type
))
10435 TYPE_WAS_ANONYMOUS (type
) = 1;
10437 /* If this is a typedef within a template class, the nested
10438 type is a (non-primary) template. The name for the
10439 template needs updating as well. */
10440 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10441 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10442 = TYPE_IDENTIFIER (type
);
10444 /* Adjust linkage now that we aren't anonymous anymore. */
10445 reset_type_linkage (type
);
10447 /* FIXME remangle member functions; member functions of a
10448 type with external linkage have external linkage. */
10452 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10453 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10455 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10456 memfn_quals
!= TYPE_UNQUALIFIED
,
10457 inlinep
, friendp
, raises
!= NULL_TREE
);
10459 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10460 /* Acknowledge that this was written:
10461 `using analias = atype;'. */
10462 TYPE_DECL_ALIAS_P (decl
) = 1;
10467 /* Detect the case of an array type of unspecified size
10468 which came, as such, direct from a typedef name.
10469 We must copy the type, so that the array's domain can be
10470 individually set by the object's initializer. */
10472 if (type
&& typedef_type
10473 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10474 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10475 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10477 /* Detect where we're using a typedef of function type to declare a
10478 function. PARMS will not be set, so we must create it now. */
10480 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10482 tree decls
= NULL_TREE
;
10485 for (args
= TYPE_ARG_TYPES (type
);
10486 args
&& args
!= void_list_node
;
10487 args
= TREE_CHAIN (args
))
10489 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10491 DECL_CHAIN (decl
) = decls
;
10495 parms
= nreverse (decls
);
10497 if (decl_context
!= TYPENAME
)
10499 /* The qualifiers on the function type become the qualifiers on
10500 the non-static member function. */
10501 memfn_quals
|= type_memfn_quals (type
);
10502 rqual
= type_memfn_rqual (type
);
10503 type_quals
= TYPE_UNQUALIFIED
;
10507 /* If this is a type name (such as, in a cast or sizeof),
10508 compute the type and return it now. */
10510 if (decl_context
== TYPENAME
)
10512 /* Note that here we don't care about type_quals. */
10514 /* Special case: "friend class foo" looks like a TYPENAME context. */
10519 error ("%<inline%> specified for friend class declaration");
10525 /* Don't allow friend declaration without a class-key. */
10526 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10527 permerror (input_location
, "template parameters cannot be friends");
10528 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10529 permerror (input_location
, "friend declaration requires class-key, "
10530 "i.e. %<friend class %T::%D%>",
10531 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10533 permerror (input_location
, "friend declaration requires class-key, "
10534 "i.e. %<friend %#T%>",
10538 /* Only try to do this stuff if we didn't already give up. */
10539 if (type
!= integer_type_node
)
10541 /* A friendly class? */
10542 if (current_class_type
)
10543 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10544 /*complain=*/true);
10546 error ("trying to make class %qT a friend of global scope",
10549 type
= void_type_node
;
10552 else if (memfn_quals
|| rqual
)
10554 if (ctype
== NULL_TREE
10555 && TREE_CODE (type
) == METHOD_TYPE
)
10556 ctype
= TYPE_METHOD_BASETYPE (type
);
10559 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10560 /* Core issue #547: need to allow this in template type args.
10561 Allow it in general in C++11 for alias-declarations. */
10562 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10563 && TREE_CODE (type
) == FUNCTION_TYPE
)
10564 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10566 error ("invalid qualifiers on non-member function type");
10571 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10572 && decl_context
!= CATCHPARM
10573 && TREE_CODE (type
) != UNION_TYPE
10576 error ("abstract declarator %qT used as declaration", type
);
10577 return error_mark_node
;
10580 /* Only functions may be declared using an operator-function-id. */
10582 && IDENTIFIER_OPNAME_P (unqualified_id
)
10583 && TREE_CODE (type
) != FUNCTION_TYPE
10584 && TREE_CODE (type
) != METHOD_TYPE
)
10586 error ("declaration of %qD as non-function", unqualified_id
);
10587 return error_mark_node
;
10590 /* We don't check parameter types here because we can emit a better
10591 error message later. */
10592 if (decl_context
!= PARM
)
10594 type
= check_var_type (unqualified_id
, type
);
10595 if (type
== error_mark_node
)
10596 return error_mark_node
;
10599 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10600 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10602 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10604 if (ctype
|| in_namespace
)
10605 error ("cannot use %<::%> in parameter declaration");
10607 if (type_uses_auto (type
))
10609 if (cxx_dialect
>= cxx14
)
10610 error ("%<auto%> parameter not permitted in this context");
10612 error ("parameter declared %<auto%>");
10613 type
= error_mark_node
;
10616 /* A parameter declared as an array of T is really a pointer to T.
10617 One declared as a function is really a pointer to a function.
10618 One declared as a member is really a pointer to member. */
10620 if (TREE_CODE (type
) == ARRAY_TYPE
)
10622 /* Transfer const-ness of array into that of type pointed to. */
10623 type
= build_pointer_type (TREE_TYPE (type
));
10624 type_quals
= TYPE_UNQUALIFIED
;
10625 array_parameter_p
= true;
10627 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10628 type
= build_pointer_type (type
);
10631 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10632 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10634 cp_cv_quals real_quals
= memfn_quals
;
10635 if (cxx_dialect
< cxx14
&& constexpr_p
10636 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10637 real_quals
|= TYPE_QUAL_CONST
;
10638 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10644 if (decl_context
== PARM
)
10646 decl
= cp_build_parm_decl (unqualified_id
, type
);
10647 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
10649 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10650 memfn_quals
!= TYPE_UNQUALIFIED
,
10651 inlinep
, friendp
, raises
!= NULL_TREE
);
10653 else if (decl_context
== FIELD
)
10655 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
10656 && type_uses_auto (type
))
10658 error ("non-static data member declared %<auto%>");
10659 type
= error_mark_node
;
10662 /* The C99 flexible array extension. */
10663 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10664 && TYPE_DOMAIN (type
) == NULL_TREE
)
10666 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10667 tf_warning_or_error
);
10668 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10671 if (type
== error_mark_node
)
10673 /* Happens when declaring arrays of sizes which
10674 are error_mark_node, for example. */
10677 else if (in_namespace
&& !friendp
)
10679 /* Something like struct S { int N::j; }; */
10680 error ("invalid use of %<::%>");
10681 return error_mark_node
;
10683 else if (TREE_CODE (type
) == FUNCTION_TYPE
10684 || TREE_CODE (type
) == METHOD_TYPE
)
10687 tree function_context
;
10691 /* This should never happen in pure C++ (the check
10692 could be an assert). It could happen in
10693 Objective-C++ if someone writes invalid code that
10694 uses a function declaration for an instance
10695 variable or property (instance variables and
10696 properties are parsed as FIELD_DECLs, but they are
10697 part of an Objective-C class, not a C++ class).
10698 That code is invalid and is caught by this
10702 error ("declaration of function %qD in invalid context",
10704 return error_mark_node
;
10707 /* ``A union may [ ... ] not [ have ] virtual functions.''
10709 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10711 error ("function %qD declared virtual inside a union",
10713 return error_mark_node
;
10716 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10720 error ("%qD cannot be declared virtual, since it "
10721 "is always static",
10728 /* Check that the name used for a destructor makes sense. */
10729 if (sfk
== sfk_destructor
)
10731 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10735 gcc_assert (friendp
);
10736 error ("expected qualified name in friend declaration "
10737 "for destructor %qD", uqname
);
10738 return error_mark_node
;
10741 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10743 error ("declaration of %qD as member of %qT",
10745 return error_mark_node
;
10749 error ("a destructor cannot be %<constexpr%>");
10750 return error_mark_node
;
10753 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10755 error ("expected qualified name in friend declaration "
10756 "for constructor %qD",
10757 id_declarator
->u
.id
.unqualified_name
);
10758 return error_mark_node
;
10761 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10763 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
10764 if (variable_template_p (tmpl
))
10766 error ("specialization of variable template %qD "
10767 "declared as function", tmpl
);
10768 inform (DECL_SOURCE_LOCATION (tmpl
),
10769 "variable template declared here");
10770 return error_mark_node
;
10774 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10775 function_context
= (ctype
!= NULL_TREE
) ?
10776 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10777 publicp
= (! friendp
|| ! staticp
)
10778 && function_context
== NULL_TREE
;
10780 if (late_return_type_p
)
10781 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
10783 decl
= grokfndecl (ctype
, type
,
10784 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10785 ? unqualified_id
: dname
,
10788 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10789 friendp
? -1 : 0, friendp
, publicp
,
10790 inlinep
| (2 * constexpr_p
),
10791 initialized
== SD_DELETED
, sfk
,
10792 funcdef_flag
, template_count
, in_namespace
,
10793 attrlist
, declarator
->id_loc
);
10794 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10795 if (decl
== NULL_TREE
)
10796 return error_mark_node
;
10798 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10799 /* The decl and setting of decl_attr is also turned off. */
10800 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10803 /* [class.conv.ctor]
10805 A constructor declared without the function-specifier
10806 explicit that can be called with a single parameter
10807 specifies a conversion from the type of its first
10808 parameter to the type of its class. Such a constructor
10809 is called a converting constructor. */
10810 if (explicitp
== 2)
10811 DECL_NONCONVERTING_P (decl
) = 1;
10813 else if (!staticp
&& !dependent_type_p (type
)
10814 && !COMPLETE_TYPE_P (complete_type (type
))
10815 && (TREE_CODE (type
) != ARRAY_TYPE
10816 || !COMPLETE_TYPE_P (TREE_TYPE (type
))
10817 || initialized
== 0))
10819 if (unqualified_id
)
10821 error ("field %qD has incomplete type %qT",
10822 unqualified_id
, type
);
10823 cxx_incomplete_type_inform (strip_array_types (type
));
10826 error ("name %qT has incomplete type", type
);
10828 type
= error_mark_node
;
10835 error ("%qE is neither function nor member function; "
10836 "cannot be declared friend", unqualified_id
);
10844 /* Friends are treated specially. */
10845 if (ctype
== current_class_type
)
10846 ; /* We already issued a permerror. */
10847 else if (decl
&& DECL_NAME (decl
))
10849 if (template_class_depth (current_class_type
) == 0)
10851 decl
= check_explicit_specialization
10852 (unqualified_id
, decl
, template_count
,
10853 2 * funcdef_flag
+ 4);
10854 if (decl
== error_mark_node
)
10855 return error_mark_node
;
10858 decl
= do_friend (ctype
, unqualified_id
, decl
,
10864 return error_mark_node
;
10867 /* Structure field. It may not be a function, except for C++. */
10869 if (decl
== NULL_TREE
)
10873 /* C++ allows static class members. All other work
10874 for this is done by grokfield. */
10875 decl
= build_lang_decl_loc (declarator
10876 ? declarator
->id_loc
10878 VAR_DECL
, unqualified_id
, type
);
10879 set_linkage_for_static_data_member (decl
);
10880 /* Even if there is an in-class initialization, DECL
10881 is considered undefined until an out-of-class
10882 definition is provided. */
10883 DECL_EXTERNAL (decl
) = 1;
10887 CP_DECL_THREAD_LOCAL_P (decl
) = true;
10888 if (!processing_template_decl
)
10889 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
10890 if (declspecs
->gnu_thread_keyword_p
)
10891 SET_DECL_GNU_TLS_P (decl
);
10894 if (constexpr_p
&& !initialized
)
10896 error ("constexpr static data member %qD must have an "
10897 "initializer", decl
);
10898 constexpr_p
= false;
10905 error ("non-static data member %qE declared %<constexpr%>",
10907 constexpr_p
= false;
10909 decl
= build_decl (input_location
,
10910 FIELD_DECL
, unqualified_id
, type
);
10911 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10912 if (bitfield
&& !unqualified_id
)
10913 TREE_NO_WARNING (decl
) = 1;
10915 if (storage_class
== sc_mutable
)
10917 DECL_MUTABLE_P (decl
) = 1;
10918 storage_class
= sc_none
;
10923 /* An attempt is being made to initialize a non-static
10924 member. This is new in C++11. */
10925 maybe_warn_cpp0x (CPP0X_NSDMI
);
10927 /* If this has been parsed with static storage class, but
10928 errors forced staticp to be cleared, ensure NSDMI is
10930 if (declspecs
->storage_class
== sc_static
)
10931 DECL_INITIAL (decl
) = error_mark_node
;
10935 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10936 memfn_quals
!= TYPE_UNQUALIFIED
,
10937 inlinep
, friendp
, raises
!= NULL_TREE
);
10940 else if (TREE_CODE (type
) == FUNCTION_TYPE
10941 || TREE_CODE (type
) == METHOD_TYPE
)
10943 tree original_name
;
10946 if (!unqualified_id
)
10947 return error_mark_node
;
10949 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10950 original_name
= dname
;
10952 original_name
= unqualified_id
;
10954 if (storage_class
== sc_auto
)
10955 error ("storage class %<auto%> invalid for function %qs", name
);
10956 else if (storage_class
== sc_register
)
10957 error ("storage class %<register%> invalid for function %qs", name
);
10960 if (declspecs
->gnu_thread_keyword_p
)
10961 error ("storage class %<__thread%> invalid for function %qs",
10964 error ("storage class %<thread_local%> invalid for function %qs",
10968 if (virt_specifiers
)
10969 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10970 /* Function declaration not at top level.
10971 Storage classes other than `extern' are not allowed
10972 and `extern' makes no difference. */
10973 if (! toplevel_bindings_p ()
10974 && (storage_class
== sc_static
10975 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10978 if (storage_class
== sc_static
)
10979 pedwarn (input_location
, OPT_Wpedantic
,
10980 "%<static%> specified invalid for function %qs "
10981 "declared out of global scope", name
);
10983 pedwarn (input_location
, OPT_Wpedantic
,
10984 "%<inline%> specifier invalid for function %qs "
10985 "declared out of global scope", name
);
10988 if (ctype
== NULL_TREE
)
10992 error ("virtual non-class function %qs", name
);
10995 else if (sfk
== sfk_constructor
10996 || sfk
== sfk_destructor
)
10998 error (funcdef_flag
10999 ? G_("%qs defined in a non-class scope")
11000 : G_("%qs declared in a non-class scope"), name
);
11005 /* Record whether the function is public. */
11006 publicp
= (ctype
!= NULL_TREE
11007 || storage_class
!= sc_static
);
11009 if (late_return_type_p
)
11010 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11012 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
11013 virtualp
, flags
, memfn_quals
, rqual
, raises
,
11015 publicp
, inlinep
| (2 * constexpr_p
),
11016 initialized
== SD_DELETED
, sfk
,
11018 template_count
, in_namespace
, attrlist
,
11019 declarator
->id_loc
);
11020 if (decl
== NULL_TREE
)
11021 return error_mark_node
;
11025 int invalid_static
= 0;
11027 /* Don't allow a static member function in a class, and forbid
11028 declaring main to be static. */
11029 if (TREE_CODE (type
) == METHOD_TYPE
)
11031 permerror (input_location
, "cannot declare member function %qD to have "
11032 "static linkage", decl
);
11033 invalid_static
= 1;
11035 else if (current_function_decl
)
11037 /* FIXME need arm citation */
11038 error ("cannot declare static function inside another function");
11039 invalid_static
= 1;
11042 if (invalid_static
)
11045 storage_class
= sc_none
;
11051 /* It's a variable. */
11053 /* An uninitialized decl with `extern' is a reference. */
11054 decl
= grokvardecl (type
, dname
, unqualified_id
,
11057 (type_quals
& TYPE_QUAL_CONST
) != 0,
11059 ctype
? ctype
: in_namespace
);
11060 if (decl
== NULL_TREE
)
11061 return error_mark_node
;
11063 bad_specifiers (decl
, BSP_VAR
, virtualp
,
11064 memfn_quals
!= TYPE_UNQUALIFIED
,
11065 inlinep
, friendp
, raises
!= NULL_TREE
);
11069 DECL_CONTEXT (decl
) = ctype
;
11072 permerror (input_location
, "%<static%> may not be used when defining "
11073 "(as opposed to declaring) a static data member");
11075 storage_class
= sc_none
;
11077 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
11079 error ("static member %qD declared %<register%>", decl
);
11080 storage_class
= sc_none
;
11082 if (storage_class
== sc_extern
&& pedantic
)
11084 pedwarn (input_location
, OPT_Wpedantic
,
11085 "cannot explicitly declare member %q#D to have "
11086 "extern linkage", decl
);
11087 storage_class
= sc_none
;
11090 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
11092 error ("declaration of constexpr variable %qD is not a definition",
11094 constexpr_p
= false;
11098 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
11100 if (toplevel_bindings_p ())
11102 /* It's common practice (and completely valid) to have a const
11103 be initialized and declared extern. */
11104 if (!(type_quals
& TYPE_QUAL_CONST
))
11105 warning (0, "%qs initialized and declared %<extern%>", name
);
11109 error ("%qs has both %<extern%> and initializer", name
);
11110 return error_mark_node
;
11114 /* Record `register' declaration for warnings on &
11115 and in case doing stupid register allocation. */
11117 if (storage_class
== sc_register
)
11118 DECL_REGISTER (decl
) = 1;
11119 else if (storage_class
== sc_extern
)
11120 DECL_THIS_EXTERN (decl
) = 1;
11121 else if (storage_class
== sc_static
)
11122 DECL_THIS_STATIC (decl
) = 1;
11124 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11125 if (constexpr_p
&& VAR_P (decl
))
11126 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
11128 /* Record constancy and volatility on the DECL itself . There's
11129 no need to do this when processing a template; we'll do this
11130 for the instantiated declaration based on the type of DECL. */
11131 if (!processing_template_decl
)
11132 cp_apply_type_quals_to_decl (type_quals
, decl
);
11138 /* Subroutine of start_function. Ensure that each of the parameter
11139 types (as listed in PARMS) is complete, as is required for a
11140 function definition. */
11143 require_complete_types_for_parms (tree parms
)
11145 for (; parms
; parms
= DECL_CHAIN (parms
))
11147 if (dependent_type_p (TREE_TYPE (parms
)))
11149 if (!VOID_TYPE_P (TREE_TYPE (parms
))
11150 && complete_type_or_else (TREE_TYPE (parms
), parms
))
11152 relayout_decl (parms
);
11153 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
11156 /* grokparms or complete_type_or_else will have already issued
11158 TREE_TYPE (parms
) = error_mark_node
;
11162 /* Returns nonzero if T is a local variable. */
11165 local_variable_p (const_tree t
)
11168 /* A VAR_DECL with a context that is a _TYPE is a static data
11170 && !TYPE_P (CP_DECL_CONTEXT (t
))
11171 /* Any other non-local variable must be at namespace scope. */
11172 && !DECL_NAMESPACE_SCOPE_P (t
))
11173 || (TREE_CODE (t
) == PARM_DECL
))
11179 /* Like local_variable_p, but suitable for use as a tree-walking
11183 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
11186 if (local_variable_p (*tp
)
11187 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
11189 else if (TYPE_P (*tp
))
11190 *walk_subtrees
= 0;
11195 /* Check that ARG, which is a default-argument expression for a
11196 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11197 something goes wrong. DECL may also be a _TYPE node, rather than a
11198 DECL, if there is no DECL available. */
11201 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
11206 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11207 /* We get a DEFAULT_ARG when looking at an in-class declaration
11208 with a default argument. Ignore the argument for now; we'll
11209 deal with it after the class is complete. */
11218 decl_type
= TREE_TYPE (decl
);
11220 if (arg
== error_mark_node
11221 || decl
== error_mark_node
11222 || TREE_TYPE (arg
) == error_mark_node
11223 || decl_type
== error_mark_node
)
11224 /* Something already went wrong. There's no need to check
11226 return error_mark_node
;
11228 /* [dcl.fct.default]
11230 A default argument expression is implicitly converted to the
11232 ++cp_unevaluated_operand
;
11233 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
11235 --cp_unevaluated_operand
;
11237 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
11239 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
11240 && null_ptr_cst_p (arg
))
11241 return nullptr_node
;
11243 /* [dcl.fct.default]
11245 Local variables shall not be used in default argument
11248 The keyword `this' shall not be used in a default argument of a
11249 member function. */
11250 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11253 if (complain
& tf_warning_or_error
)
11255 if (DECL_NAME (var
) == this_identifier
)
11256 permerror (input_location
, "default argument %qE uses %qD",
11259 error ("default argument %qE uses local variable %qD", arg
, var
);
11261 return error_mark_node
;
11268 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11271 type_is_deprecated (tree type
)
11273 enum tree_code code
;
11274 if (TREE_DEPRECATED (type
))
11276 if (TYPE_NAME (type
)
11277 && TREE_DEPRECATED (TYPE_NAME (type
)))
11280 /* Do warn about using typedefs to a deprecated class. */
11281 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11282 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11284 code
= TREE_CODE (type
);
11286 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11287 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11288 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11289 return type_is_deprecated (TREE_TYPE (type
));
11291 if (TYPE_PTRMEMFUNC_P (type
))
11292 return type_is_deprecated
11293 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11298 /* Decode the list of parameter types for a function type.
11299 Given the list of things declared inside the parens,
11300 return a list of types.
11302 If this parameter does not end with an ellipsis, we append
11305 *PARMS is set to the chain of PARM_DECLs created. */
11308 grokparms (tree parmlist
, tree
*parms
)
11310 tree result
= NULL_TREE
;
11311 tree decls
= NULL_TREE
;
11315 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11317 tree type
= NULL_TREE
;
11318 tree init
= TREE_PURPOSE (parm
);
11319 tree decl
= TREE_VALUE (parm
);
11320 const char *errmsg
;
11322 if (parm
== void_list_node
)
11325 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11328 type
= TREE_TYPE (decl
);
11329 if (VOID_TYPE_P (type
))
11331 if (same_type_p (type
, void_type_node
)
11333 && !DECL_NAME (decl
) && !result
11334 && TREE_CHAIN (parm
) == void_list_node
)
11335 /* DR 577: A parameter list consisting of a single
11336 unnamed parameter of non-dependent type 'void'. */
11338 else if (cv_qualified_p (type
))
11339 error_at (DECL_SOURCE_LOCATION (decl
),
11340 "invalid use of cv-qualified type %qT in "
11341 "parameter declaration", type
);
11343 error_at (DECL_SOURCE_LOCATION (decl
),
11344 "invalid use of type %<void%> in parameter "
11346 /* It's not a good idea to actually create parameters of
11347 type `void'; other parts of the compiler assume that a
11348 void type terminates the parameter list. */
11349 type
= error_mark_node
;
11350 TREE_TYPE (decl
) = error_mark_node
;
11353 if (type
!= error_mark_node
11354 && TYPE_FOR_JAVA (type
)
11355 && MAYBE_CLASS_TYPE_P (type
))
11357 error ("parameter %qD has Java class type", decl
);
11358 type
= error_mark_node
;
11359 TREE_TYPE (decl
) = error_mark_node
;
11363 if (type
!= error_mark_node
11364 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11367 type
= error_mark_node
;
11368 TREE_TYPE (decl
) = error_mark_node
;
11371 if (type
!= error_mark_node
)
11373 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11375 tree deptype
= type_is_deprecated (type
);
11377 warn_deprecated_use (deptype
, NULL_TREE
);
11380 /* Top-level qualifiers on the parameters are
11381 ignored for function types. */
11382 type
= cp_build_qualified_type (type
, 0);
11383 if (TREE_CODE (type
) == METHOD_TYPE
)
11385 error ("parameter %qD invalidly declared method type", decl
);
11386 type
= build_pointer_type (type
);
11387 TREE_TYPE (decl
) = type
;
11389 else if (abstract_virtuals_error (decl
, type
))
11390 any_error
= 1; /* Seems like a good idea. */
11391 else if (POINTER_TYPE_P (type
))
11393 /* [dcl.fct]/6, parameter types cannot contain pointers
11394 (references) to arrays of unknown bound. */
11395 tree t
= TREE_TYPE (type
);
11396 int ptr
= TYPE_PTR_P (type
);
11400 if (TYPE_PTR_P (t
))
11402 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11404 else if (!TYPE_DOMAIN (t
))
11408 if (TREE_CODE (t
) == ARRAY_TYPE
)
11410 ? G_("parameter %qD includes pointer to array of "
11411 "unknown bound %qT")
11412 : G_("parameter %qD includes reference to array of "
11413 "unknown bound %qT"),
11419 else if (init
&& !processing_template_decl
)
11420 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11423 DECL_CHAIN (decl
) = decls
;
11425 result
= tree_cons (init
, type
, result
);
11427 decls
= nreverse (decls
);
11428 result
= nreverse (result
);
11430 result
= chainon (result
, void_list_node
);
11437 /* D is a constructor or overloaded `operator='.
11439 Let T be the class in which D is declared. Then, this function
11442 -1 if D's is an ill-formed constructor or copy assignment operator
11443 whose first parameter is of type `T'.
11444 0 if D is not a copy constructor or copy assignment
11446 1 if D is a copy constructor or copy assignment operator whose
11447 first parameter is a reference to non-const qualified T.
11448 2 if D is a copy constructor or copy assignment operator whose
11449 first parameter is a reference to const qualified T.
11451 This function can be used as a predicate. Positive values indicate
11452 a copy constructor and nonzero values indicate a copy assignment
11456 copy_fn_p (const_tree d
)
11462 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11464 if (TREE_CODE (d
) == TEMPLATE_DECL
11465 || (DECL_TEMPLATE_INFO (d
)
11466 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11467 /* Instantiations of template member functions are never copy
11468 functions. Note that member functions of templated classes are
11469 represented as template functions internally, and we must
11470 accept those as copy functions. */
11473 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11477 arg_type
= TREE_VALUE (args
);
11478 if (arg_type
== error_mark_node
)
11481 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11483 /* Pass by value copy assignment operator. */
11486 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11487 && !TYPE_REF_IS_RVALUE (arg_type
)
11488 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11490 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11496 args
= TREE_CHAIN (args
);
11498 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11499 /* There are more non-optional args. */
11505 /* D is a constructor or overloaded `operator='.
11507 Let T be the class in which D is declared. Then, this function
11508 returns true when D is a move constructor or move assignment
11509 operator, false otherwise. */
11512 move_fn_p (const_tree d
)
11514 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11516 if (cxx_dialect
== cxx98
)
11517 /* There are no move constructors if we are in C++98 mode. */
11520 if (TREE_CODE (d
) == TEMPLATE_DECL
11521 || (DECL_TEMPLATE_INFO (d
)
11522 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11523 /* Instantiations of template member functions are never move
11524 functions. Note that member functions of templated classes are
11525 represented as template functions internally, and we must
11526 accept those as move functions. */
11529 return move_signature_fn_p (d
);
11532 /* D is a constructor or overloaded `operator='.
11534 Then, this function returns true when D has the same signature as a move
11535 constructor or move assignment operator (because either it is such a
11536 ctor/op= or it is a template specialization with the same signature),
11537 false otherwise. */
11540 move_signature_fn_p (const_tree d
)
11544 bool result
= false;
11546 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11550 arg_type
= TREE_VALUE (args
);
11551 if (arg_type
== error_mark_node
)
11554 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11555 && TYPE_REF_IS_RVALUE (arg_type
)
11556 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11560 args
= TREE_CHAIN (args
);
11562 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11563 /* There are more non-optional args. */
11569 /* Remember any special properties of member function DECL. */
11572 grok_special_member_properties (tree decl
)
11576 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11579 class_type
= DECL_CONTEXT (decl
);
11580 if (DECL_CONSTRUCTOR_P (decl
))
11582 int ctor
= copy_fn_p (decl
);
11584 if (!DECL_ARTIFICIAL (decl
))
11585 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11591 A non-template constructor for class X is a copy
11592 constructor if its first parameter is of type X&, const
11593 X&, volatile X& or const volatile X&, and either there
11594 are no other parameters or else all other parameters have
11595 default arguments. */
11596 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11597 if (user_provided_p (decl
))
11598 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11600 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11602 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11603 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11604 else if (move_fn_p (decl
) && user_provided_p (decl
))
11605 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11606 else if (is_list_ctor (decl
))
11607 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11609 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11610 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11611 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11613 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11617 A non-template assignment operator for class X is a copy
11618 assignment operator if its parameter is of type X, X&, const
11619 X&, volatile X& or const volatile X&. */
11621 int assop
= copy_fn_p (decl
);
11625 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11626 if (user_provided_p (decl
))
11627 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11629 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11631 else if (move_fn_p (decl
) && user_provided_p (decl
))
11632 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11634 /* Destructors are handled in check_methods. */
11637 /* Check a constructor DECL has the correct form. Complains
11638 if the class has a constructor of the form X(X). */
11641 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11643 int ctor_parm
= copy_fn_p (decl
);
11649 A declaration of a constructor for a class X is ill-formed if
11650 its first parameter is of type (optionally cv-qualified) X
11651 and either there are no other parameters or else all other
11652 parameters have default arguments.
11654 We *don't* complain about member template instantiations that
11655 have this form, though; they can occur as we try to decide
11656 what constructor to use during overload resolution. Since
11657 overload resolution will never prefer such a constructor to
11658 the non-template copy constructor (which is either explicitly
11659 or implicitly defined), there's no need to worry about their
11660 existence. Theoretically, they should never even be
11661 instantiated, but that's hard to forestall. */
11662 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11670 /* An operator with this code is unary, but can also be binary. */
11673 ambi_op_p (enum tree_code code
)
11675 return (code
== INDIRECT_REF
11676 || code
== ADDR_EXPR
11677 || code
== UNARY_PLUS_EXPR
11678 || code
== NEGATE_EXPR
11679 || code
== PREINCREMENT_EXPR
11680 || code
== PREDECREMENT_EXPR
);
11683 /* An operator with this name can only be unary. */
11686 unary_op_p (enum tree_code code
)
11688 return (code
== TRUTH_NOT_EXPR
11689 || code
== BIT_NOT_EXPR
11690 || code
== COMPONENT_REF
11691 || code
== TYPE_EXPR
);
11694 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11695 errors are issued for invalid declarations. */
11698 grok_op_properties (tree decl
, bool complain
)
11700 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11702 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11703 tree name
= DECL_NAME (decl
);
11704 enum tree_code operator_code
;
11709 /* Count the number of arguments and check for ellipsis. */
11710 for (argtype
= argtypes
, arity
= 0;
11711 argtype
&& argtype
!= void_list_node
;
11712 argtype
= TREE_CHAIN (argtype
))
11714 ellipsis_p
= !argtype
;
11716 class_type
= DECL_CONTEXT (decl
);
11717 if (class_type
&& !CLASS_TYPE_P (class_type
))
11718 class_type
= NULL_TREE
;
11720 if (DECL_CONV_FN_P (decl
))
11721 operator_code
= TYPE_EXPR
;
11725 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11726 if (ansi_opname (CODE) == name) \
11728 operator_code = (CODE); \
11731 else if (ansi_assopname (CODE) == name) \
11733 operator_code = (CODE); \
11734 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11738 #include "operators.def"
11739 #undef DEF_OPERATOR
11741 gcc_unreachable ();
11744 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11745 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11748 switch (operator_code
)
11751 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11755 TYPE_GETS_DELETE (class_type
) |= 1;
11759 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11762 case VEC_DELETE_EXPR
:
11763 TYPE_GETS_DELETE (class_type
) |= 2;
11770 /* [basic.std.dynamic.allocation]/1:
11772 A program is ill-formed if an allocation function is declared
11773 in a namespace scope other than global scope or declared static
11776 The same also holds true for deallocation functions. */
11777 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11778 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11780 if (DECL_NAMESPACE_SCOPE_P (decl
))
11782 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11784 error ("%qD may not be declared within a namespace", decl
);
11787 else if (!TREE_PUBLIC (decl
))
11789 error ("%qD may not be declared as static", decl
);
11795 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11797 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11798 DECL_IS_OPERATOR_NEW (decl
) = 1;
11800 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11801 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11804 /* An operator function must either be a non-static member function
11805 or have at least one parameter of a class, a reference to a class,
11806 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11807 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11809 if (operator_code
== TYPE_EXPR
11810 || operator_code
== CALL_EXPR
11811 || operator_code
== COMPONENT_REF
11812 || operator_code
== ARRAY_REF
11813 || operator_code
== NOP_EXPR
)
11815 error ("%qD must be a nonstatic member function", decl
);
11822 if (DECL_STATIC_FUNCTION_P (decl
))
11824 error ("%qD must be either a non-static member "
11825 "function or a non-member function", decl
);
11829 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11831 tree arg
= non_reference (TREE_VALUE (p
));
11832 if (arg
== error_mark_node
)
11835 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11836 because these checks are performed even on
11837 template functions. */
11838 if (MAYBE_CLASS_TYPE_P (arg
)
11839 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11843 if (!p
|| p
== void_list_node
)
11846 error ("%qD must have an argument of class or "
11847 "enumerated type", decl
);
11853 /* There are no restrictions on the arguments to an overloaded
11855 if (operator_code
== CALL_EXPR
)
11858 /* Warn about conversion operators that will never be used. */
11859 if (IDENTIFIER_TYPENAME_P (name
)
11860 && ! DECL_TEMPLATE_INFO (decl
)
11862 /* Warn only declaring the function; there is no need to
11863 warn again about out-of-class definitions. */
11864 && class_type
== current_class_type
)
11866 tree t
= TREE_TYPE (name
);
11867 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11870 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11872 if (VOID_TYPE_P (t
))
11873 warning (OPT_Wconversion
,
11875 ? G_("conversion to a reference to void "
11876 "will never use a type conversion operator")
11877 : G_("conversion to void "
11878 "will never use a type conversion operator"));
11879 else if (class_type
)
11881 if (t
== class_type
)
11882 warning (OPT_Wconversion
,
11884 ? G_("conversion to a reference to the same type "
11885 "will never use a type conversion operator")
11886 : G_("conversion to the same type "
11887 "will never use a type conversion operator"));
11888 /* Don't force t to be complete here. */
11889 else if (MAYBE_CLASS_TYPE_P (t
)
11890 && COMPLETE_TYPE_P (t
)
11891 && DERIVED_FROM_P (t
, class_type
))
11892 warning (OPT_Wconversion
,
11894 ? G_("conversion to a reference to a base class "
11895 "will never use a type conversion operator")
11896 : G_("conversion to a base class "
11897 "will never use a type conversion operator"));
11902 if (operator_code
== COND_EXPR
)
11905 error ("ISO C++ prohibits overloading operator ?:");
11908 else if (ellipsis_p
)
11910 error ("%qD must not have variable number of arguments", decl
);
11913 else if (ambi_op_p (operator_code
))
11916 /* We pick the one-argument operator codes by default, so
11917 we don't have to change anything. */
11919 else if (arity
== 2)
11921 /* If we thought this was a unary operator, we now know
11922 it to be a binary operator. */
11923 switch (operator_code
)
11926 operator_code
= MULT_EXPR
;
11930 operator_code
= BIT_AND_EXPR
;
11933 case UNARY_PLUS_EXPR
:
11934 operator_code
= PLUS_EXPR
;
11938 operator_code
= MINUS_EXPR
;
11941 case PREINCREMENT_EXPR
:
11942 operator_code
= POSTINCREMENT_EXPR
;
11945 case PREDECREMENT_EXPR
:
11946 operator_code
= POSTDECREMENT_EXPR
;
11950 gcc_unreachable ();
11953 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11955 if ((operator_code
== POSTINCREMENT_EXPR
11956 || operator_code
== POSTDECREMENT_EXPR
)
11957 && ! processing_template_decl
11958 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11961 error ("postfix %qD must take %<int%> as its argument",
11964 error ("postfix %qD must take %<int%> as its second "
11972 error ("%qD must take either zero or one argument", decl
);
11974 error ("%qD must take either one or two arguments", decl
);
11978 /* More Effective C++ rule 6. */
11980 && (operator_code
== POSTINCREMENT_EXPR
11981 || operator_code
== POSTDECREMENT_EXPR
11982 || operator_code
== PREINCREMENT_EXPR
11983 || operator_code
== PREDECREMENT_EXPR
))
11985 tree arg
= TREE_VALUE (argtypes
);
11986 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11987 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11988 arg
= TREE_TYPE (arg
);
11989 arg
= TYPE_MAIN_VARIANT (arg
);
11990 if (operator_code
== PREINCREMENT_EXPR
11991 || operator_code
== PREDECREMENT_EXPR
)
11993 if (TREE_CODE (ret
) != REFERENCE_TYPE
11994 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11996 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11997 build_reference_type (arg
));
12001 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12002 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
12006 else if (unary_op_p (operator_code
))
12011 error ("%qD must take %<void%>", decl
);
12013 error ("%qD must take exactly one argument", decl
);
12017 else /* if (binary_op_p (operator_code)) */
12022 error ("%qD must take exactly one argument", decl
);
12024 error ("%qD must take exactly two arguments", decl
);
12028 /* More Effective C++ rule 7. */
12030 && (operator_code
== TRUTH_ANDIF_EXPR
12031 || operator_code
== TRUTH_ORIF_EXPR
12032 || operator_code
== COMPOUND_EXPR
))
12033 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
12037 /* Effective C++ rule 23. */
12040 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
12041 && (operator_code
== PLUS_EXPR
12042 || operator_code
== MINUS_EXPR
12043 || operator_code
== TRUNC_DIV_EXPR
12044 || operator_code
== MULT_EXPR
12045 || operator_code
== TRUNC_MOD_EXPR
)
12046 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12047 warning (OPT_Weffc__
, "%qD should return by value", decl
);
12049 /* [over.oper]/8 */
12050 for (; argtypes
&& argtypes
!= void_list_node
;
12051 argtypes
= TREE_CHAIN (argtypes
))
12052 if (TREE_PURPOSE (argtypes
))
12054 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12055 if (operator_code
== POSTINCREMENT_EXPR
12056 || operator_code
== POSTDECREMENT_EXPR
)
12058 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
12063 error ("%qD cannot have default arguments", decl
);
12071 /* Return a string giving the keyword associate with CODE. */
12073 static const char *
12074 tag_name (enum tag_types code
)
12086 case typename_type
:
12089 gcc_unreachable ();
12093 /* Name lookup in an elaborated-type-specifier (after the keyword
12094 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12095 elaborated-type-specifier is invalid, issue a diagnostic and return
12096 error_mark_node; otherwise, return the *_TYPE to which it referred.
12097 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12100 check_elaborated_type_specifier (enum tag_types tag_code
,
12102 bool allow_template_p
)
12108 struct S { struct S *p; };
12110 name lookup will find the TYPE_DECL for the implicit "S::S"
12111 typedef. Adjust for that here. */
12112 if (DECL_SELF_REFERENCE_P (decl
))
12113 decl
= TYPE_NAME (TREE_TYPE (decl
));
12115 type
= TREE_TYPE (decl
);
12117 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12118 is false for this case as well. */
12119 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12121 error ("using template type parameter %qT after %qs",
12122 type
, tag_name (tag_code
));
12123 return error_mark_node
;
12125 /* Accept template template parameters. */
12126 else if (allow_template_p
12127 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
12128 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
12132 If the identifier resolves to a typedef-name or the
12133 simple-template-id resolves to an alias template
12134 specialization, the elaborated-type-specifier is ill-formed.
12136 In other words, the only legitimate declaration to use in the
12137 elaborated type specifier is the implicit typedef created when
12138 the type is declared. */
12139 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
12140 && !DECL_SELF_REFERENCE_P (decl
)
12141 && tag_code
!= typename_type
)
12143 if (alias_template_specialization_p (type
))
12144 error ("using alias template specialization %qT after %qs",
12145 type
, tag_name (tag_code
));
12147 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
12148 inform (DECL_SOURCE_LOCATION (decl
),
12149 "%qD has a previous declaration here", decl
);
12150 return error_mark_node
;
12152 else if (TREE_CODE (type
) != RECORD_TYPE
12153 && TREE_CODE (type
) != UNION_TYPE
12154 && tag_code
!= enum_type
12155 && tag_code
!= typename_type
)
12157 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
12158 inform (input_location
, "%q+T has a previous declaration here", type
);
12159 return error_mark_node
;
12161 else if (TREE_CODE (type
) != ENUMERAL_TYPE
12162 && tag_code
== enum_type
)
12164 error ("%qT referred to as enum", type
);
12165 inform (input_location
, "%q+T has a previous declaration here", type
);
12166 return error_mark_node
;
12168 else if (!allow_template_p
12169 && TREE_CODE (type
) == RECORD_TYPE
12170 && CLASSTYPE_IS_TEMPLATE (type
))
12172 /* If a class template appears as elaborated type specifier
12173 without a template header such as:
12175 template <class T> class C {};
12176 void f(class C); // No template header here
12178 then the required template argument is missing. */
12179 error ("template argument required for %<%s %T%>",
12180 tag_name (tag_code
),
12181 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
12182 return error_mark_node
;
12188 /* Lookup NAME in elaborate type specifier in scope according to
12189 SCOPE and issue diagnostics if necessary.
12190 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12191 found, and ERROR_MARK_NODE for type error. */
12194 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
12195 tag_scope scope
, bool template_header_p
)
12199 if (scope
== ts_global
)
12201 /* First try ordinary name lookup, ignoring hidden class name
12202 injected via friend declaration. */
12203 decl
= lookup_name_prefer_type (name
, 2);
12204 decl
= strip_using_decl (decl
);
12205 /* If that fails, the name will be placed in the smallest
12206 non-class, non-function-prototype scope according to 3.3.1/5.
12207 We may already have a hidden name declared as friend in this
12208 scope. So lookup again but not ignoring hidden names.
12209 If we find one, that name will be made visible rather than
12210 creating a new tag. */
12212 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
12215 decl
= lookup_type_scope (name
, scope
);
12218 && (DECL_CLASS_TEMPLATE_P (decl
)
12219 /* If scope is ts_current we're defining a class, so ignore a
12220 template template parameter. */
12221 || (scope
!= ts_current
12222 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
12223 decl
= DECL_TEMPLATE_RESULT (decl
);
12225 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
12227 /* Look for invalid nested type:
12231 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
12233 error ("%qD has the same name as the class in which it is "
12236 return error_mark_node
;
12239 /* Two cases we need to consider when deciding if a class
12240 template is allowed as an elaborated type specifier:
12241 1. It is a self reference to its own class.
12242 2. It comes with a template header.
12246 template <class T> class C {
12247 class C *c1; // DECL_SELF_REFERENCE_P is true
12250 template <class U> class C; // template_header_p is true
12251 template <class T> class C<T>::D {
12252 class C *c2; // DECL_SELF_REFERENCE_P is true
12255 t
= check_elaborated_type_specifier (tag_code
,
12258 | DECL_SELF_REFERENCE_P (decl
));
12261 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12263 error ("reference to %qD is ambiguous", name
);
12264 print_candidates (decl
);
12265 return error_mark_node
;
12271 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12272 Define the tag as a forward-reference if it is not defined.
12274 If a declaration is given, process it here, and report an error if
12275 multiple declarations are not identical.
12277 SCOPE is TS_CURRENT when this is also a definition. Only look in
12278 the current frame for the name (since C++ allows new names in any
12279 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12280 declaration. Only look beginning from the current scope outward up
12281 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12283 TEMPLATE_HEADER_P is true when this declaration is preceded by
12284 a set of template parameters. */
12287 xref_tag_1 (enum tag_types tag_code
, tree name
,
12288 tag_scope orig_scope
, bool template_header_p
)
12290 enum tree_code code
;
12292 tree context
= NULL_TREE
;
12295 gcc_assert (identifier_p (name
));
12301 code
= RECORD_TYPE
;
12307 code
= ENUMERAL_TYPE
;
12310 gcc_unreachable ();
12313 if (orig_scope
== ts_lambda
)
12314 scope
= ts_current
;
12316 scope
= orig_scope
;
12318 /* In case of anonymous name, xref_tag is only called to
12319 make type node and push name. Name lookup is not required. */
12320 if (anon_aggrname_p (name
))
12323 t
= lookup_and_check_tag (tag_code
, name
,
12324 scope
, template_header_p
);
12326 if (t
== error_mark_node
)
12327 return error_mark_node
;
12329 if (scope
!= ts_current
&& t
&& current_class_type
12330 && template_class_depth (current_class_type
)
12331 && template_header_p
)
12333 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12336 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12337 definition of this tag. Since, in addition, we are currently
12338 processing a (member) template declaration of a template
12339 class, we must be very careful; consider:
12346 { template <class V>
12347 friend struct S1; };
12349 Here, the S2::S1 declaration should not be confused with the
12350 outer declaration. In particular, the inner version should
12351 have a template parameter of level 2, not level 1. This
12352 would be particularly important if the member declaration
12355 template <class V = U> friend struct S1;
12357 say, when we should tsubst into `U' when instantiating
12358 S2. On the other hand, when presented with:
12368 we must find the inner binding eventually. We
12369 accomplish this by making sure that the new type we
12370 create to represent this declaration has the right
12372 context
= TYPE_CONTEXT (t
);
12378 /* If no such tag is yet defined, create a forward-reference node
12379 and record it as the "definition".
12380 When a real declaration of this type is found,
12381 the forward-reference will be altered into a real type. */
12382 if (code
== ENUMERAL_TYPE
)
12384 error ("use of enum %q#D without previous declaration", name
);
12385 return error_mark_node
;
12389 t
= make_class_type (code
);
12390 TYPE_CONTEXT (t
) = context
;
12391 if (orig_scope
== ts_lambda
)
12392 /* Remember that we're declaring a lambda to avoid bogus errors
12393 in push_template_decl. */
12394 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12395 t
= pushtag (name
, t
, scope
);
12400 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12402 if (!redeclare_class_template (t
, current_template_parms
))
12403 return error_mark_node
;
12405 else if (!processing_template_decl
12406 && CLASS_TYPE_P (t
)
12407 && CLASSTYPE_IS_TEMPLATE (t
))
12409 error ("redeclaration of %qT as a non-template", t
);
12410 error ("previous declaration %q+D", t
);
12411 return error_mark_node
;
12414 /* Make injected friend class visible. */
12415 if (scope
!= ts_within_enclosing_non_class
12416 && hidden_name_p (TYPE_NAME (t
)))
12418 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12419 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12421 if (TYPE_TEMPLATE_INFO (t
))
12423 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12424 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12432 /* Wrapper for xref_tag_1. */
12435 xref_tag (enum tag_types tag_code
, tree name
,
12436 tag_scope scope
, bool template_header_p
)
12440 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12441 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12442 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12448 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12450 enum tag_types tag_kind
;
12452 if (TREE_CODE (old
) == RECORD_TYPE
)
12453 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12455 tag_kind
= union_type
;
12457 if (id
== NULL_TREE
)
12458 id
= TYPE_IDENTIFIER (old
);
12460 return xref_tag (tag_kind
, id
, scope
, false);
12463 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12464 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12465 access_* node, and the TREE_VALUE is the type of the base-class.
12466 Non-NULL TREE_TYPE indicates virtual inheritance.
12468 Returns true if the binfo hierarchy was successfully created,
12469 false if an error was detected. */
12472 xref_basetypes (tree ref
, tree base_list
)
12475 tree binfo
, base_binfo
;
12476 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12477 unsigned max_bases
= 0; /* Maximum direct bases. */
12479 tree default_access
;
12480 tree igo_prev
; /* Track Inheritance Graph Order. */
12482 if (ref
== error_mark_node
)
12485 /* The base of a derived class is private by default, all others are
12487 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12488 && CLASSTYPE_DECLARED_CLASS (ref
)
12489 ? access_private_node
: access_public_node
);
12491 /* First, make sure that any templates in base-classes are
12492 instantiated. This ensures that if we call ourselves recursively
12493 we do not get confused about which classes are marked and which
12495 basep
= &base_list
;
12498 tree basetype
= TREE_VALUE (*basep
);
12500 /* The dependent_type_p call below should really be dependent_scope_p
12501 so that we give a hard error about using an incomplete type as a
12502 base, but we allow it with a pedwarn for backward
12504 if (processing_template_decl
12505 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12506 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12507 if (!dependent_type_p (basetype
)
12508 && !complete_type_or_else (basetype
, NULL
))
12509 /* An incomplete type. Remove it from the list. */
12510 *basep
= TREE_CHAIN (*basep
);
12514 if (TREE_TYPE (*basep
))
12516 if (CLASS_TYPE_P (basetype
))
12517 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12518 basep
= &TREE_CHAIN (*basep
);
12522 TYPE_MARKED_P (ref
) = 1;
12524 /* The binfo slot should be empty, unless this is an (ill-formed)
12526 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12528 error ("redefinition of %q#T", ref
);
12532 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12534 binfo
= make_tree_binfo (max_bases
);
12536 TYPE_BINFO (ref
) = binfo
;
12537 BINFO_OFFSET (binfo
) = size_zero_node
;
12538 BINFO_TYPE (binfo
) = ref
;
12540 /* Apply base-class info set up to the variants of this type. */
12541 fixup_type_variants (ref
);
12545 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12546 /* An aggregate cannot have baseclasses. */
12547 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12549 if (TREE_CODE (ref
) == UNION_TYPE
)
12551 error ("derived union %qT invalid", ref
);
12558 if (TYPE_FOR_JAVA (ref
))
12560 error ("Java class %qT cannot have multiple bases", ref
);
12567 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12569 if (TYPE_FOR_JAVA (ref
))
12571 error ("Java class %qT cannot have virtual bases", ref
);
12576 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12578 tree access
= TREE_PURPOSE (base_list
);
12579 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12580 tree basetype
= TREE_VALUE (base_list
);
12582 if (access
== access_default_node
)
12583 access
= default_access
;
12585 if (PACK_EXPANSION_P (basetype
))
12586 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12587 if (TREE_CODE (basetype
) == TYPE_DECL
)
12588 basetype
= TREE_TYPE (basetype
);
12589 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12591 error ("base type %qT fails to be a struct or class type",
12596 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12597 TYPE_FOR_JAVA (ref
) = 1;
12599 base_binfo
= NULL_TREE
;
12600 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12602 base_binfo
= TYPE_BINFO (basetype
);
12603 /* The original basetype could have been a typedef'd type. */
12604 basetype
= BINFO_TYPE (base_binfo
);
12606 /* Inherit flags from the base. */
12607 TYPE_HAS_NEW_OPERATOR (ref
)
12608 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12609 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12610 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12611 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12612 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12613 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12614 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12615 CLASSTYPE_REPEATED_BASE_P (ref
)
12616 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12619 /* We must do this test after we've seen through a typedef
12621 if (TYPE_MARKED_P (basetype
))
12623 if (basetype
== ref
)
12624 error ("recursive type %qT undefined", basetype
);
12626 error ("duplicate base type %qT invalid", basetype
);
12630 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12631 /* Regenerate the pack expansion for the bases. */
12632 basetype
= make_pack_expansion (basetype
);
12634 TYPE_MARKED_P (basetype
) = 1;
12636 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12637 &igo_prev
, via_virtual
);
12638 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12639 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12641 BINFO_BASE_APPEND (binfo
, base_binfo
);
12642 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12645 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12646 /* If we didn't get max_vbases vbases, we must have shared at
12647 least one of them, and are therefore diamond shaped. */
12648 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12650 /* Unmark all the types. */
12651 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12652 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12653 TYPE_MARKED_P (ref
) = 0;
12655 /* Now see if we have a repeated base type. */
12656 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12658 for (base_binfo
= binfo
; base_binfo
;
12659 base_binfo
= TREE_CHAIN (base_binfo
))
12661 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12663 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12666 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12668 for (base_binfo
= binfo
; base_binfo
;
12669 base_binfo
= TREE_CHAIN (base_binfo
))
12670 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12671 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12680 /* Copies the enum-related properties from type SRC to type DST.
12681 Used with the underlying type of an enum and the enum itself. */
12683 copy_type_enum (tree dst
, tree src
)
12686 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12688 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12689 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12690 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12691 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12692 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12693 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12694 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12695 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12696 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12700 /* Begin compiling the definition of an enumeration type.
12703 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12705 UNDERLYING_TYPE is the type that will be used as the storage for
12706 the enumeration type. This should be NULL_TREE if no storage type
12709 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12711 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12713 Returns the type object, as yet incomplete.
12714 Also records info about it so that build_enumerator
12715 may be used to declare the individual values as they are read. */
12718 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12719 bool scoped_enum_p
, bool *is_new
)
12721 tree prevtype
= NULL_TREE
;
12722 gcc_assert (identifier_p (name
));
12726 /* [C++0x dcl.enum]p5:
12728 If not explicitly specified, the underlying type of a scoped
12729 enumeration type is int. */
12730 if (!underlying_type
&& scoped_enum_p
)
12731 underlying_type
= integer_type_node
;
12733 if (underlying_type
)
12734 underlying_type
= cv_unqualified (underlying_type
);
12736 /* If this is the real definition for a previous forward reference,
12737 fill in the contents in the same object that used to be the
12738 forward reference. */
12740 enumtype
= lookup_and_check_tag (enum_type
, name
,
12741 /*tag_scope=*/ts_current
,
12742 /*template_header_p=*/false);
12744 /* In case of a template_decl, the only check that should be deferred
12745 to instantiation time is the comparison of underlying types. */
12746 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12748 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12750 error_at (input_location
, "scoped/unscoped mismatch "
12751 "in enum %q#T", enumtype
);
12752 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12753 "previous definition here");
12754 enumtype
= error_mark_node
;
12756 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12758 error_at (input_location
, "underlying type mismatch "
12759 "in enum %q#T", enumtype
);
12760 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12761 "previous definition here");
12762 enumtype
= error_mark_node
;
12764 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12765 && !dependent_type_p (underlying_type
)
12766 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12767 && !same_type_p (underlying_type
,
12768 ENUM_UNDERLYING_TYPE (enumtype
)))
12770 error_at (input_location
, "different underlying type "
12771 "in enum %q#T", enumtype
);
12772 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12773 "previous definition here");
12774 underlying_type
= NULL_TREE
;
12778 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12779 || processing_template_decl
)
12781 /* In case of error, make a dummy enum to allow parsing to
12783 if (enumtype
== error_mark_node
)
12785 name
= make_anon_name ();
12786 enumtype
= NULL_TREE
;
12789 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12790 of an opaque enum, or an opaque enum of an already defined
12791 enumeration (C++0x only).
12792 In any other case, it'll be NULL_TREE. */
12798 prevtype
= enumtype
;
12800 /* Do not push the decl more than once, unless we need to
12801 compare underlying types at instantiation time */
12803 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12804 || (underlying_type
12805 && dependent_type_p (underlying_type
))
12806 || (ENUM_UNDERLYING_TYPE (enumtype
)
12807 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12809 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12810 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12813 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12816 if (enumtype
== error_mark_node
)
12817 return error_mark_node
;
12819 /* The enum is considered opaque until the opening '{' of the
12820 enumerator list. */
12821 SET_OPAQUE_ENUM_P (enumtype
, true);
12822 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12825 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12827 if (underlying_type
)
12829 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12831 copy_type_enum (enumtype
, underlying_type
);
12832 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12834 else if (dependent_type_p (underlying_type
))
12835 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12837 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12838 underlying_type
, enumtype
);
12841 /* If into a template class, the returned enum is always the first
12842 declaration (opaque or not) seen. This way all the references to
12843 this type will be to the same declaration. The following ones are used
12844 only to check for definition errors. */
12845 if (prevtype
&& processing_template_decl
)
12851 /* After processing and defining all the values of an enumeration type,
12852 install their decls in the enumeration type.
12853 ENUMTYPE is the type object. */
12856 finish_enum_value_list (tree enumtype
)
12859 tree underlying_type
;
12862 tree minnode
, maxnode
;
12865 bool fixed_underlying_type_p
12866 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12868 /* We built up the VALUES in reverse order. */
12869 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12871 /* For an enum defined in a template, just set the type of the values;
12872 all further processing is postponed until the template is
12873 instantiated. We need to set the type so that tsubst of a CONST_DECL
12875 if (processing_template_decl
)
12877 for (values
= TYPE_VALUES (enumtype
);
12879 values
= TREE_CHAIN (values
))
12880 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12884 /* Determine the minimum and maximum values of the enumerators. */
12885 if (TYPE_VALUES (enumtype
))
12887 minnode
= maxnode
= NULL_TREE
;
12889 for (values
= TYPE_VALUES (enumtype
);
12891 values
= TREE_CHAIN (values
))
12893 decl
= TREE_VALUE (values
);
12895 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12896 each enumerator has the type of its enumeration. Prior to the
12897 closing brace, the type of each enumerator is the type of its
12898 initializing value. */
12899 TREE_TYPE (decl
) = enumtype
;
12901 /* Update the minimum and maximum values, if appropriate. */
12902 value
= DECL_INITIAL (decl
);
12903 if (value
== error_mark_node
)
12904 value
= integer_zero_node
;
12905 /* Figure out what the minimum and maximum values of the
12906 enumerators are. */
12908 minnode
= maxnode
= value
;
12909 else if (tree_int_cst_lt (maxnode
, value
))
12911 else if (tree_int_cst_lt (value
, minnode
))
12918 If the enumerator-list is empty, the underlying type is as if
12919 the enumeration had a single enumerator with value 0. */
12920 minnode
= maxnode
= integer_zero_node
;
12922 if (!fixed_underlying_type_p
)
12924 /* Compute the number of bits require to represent all values of the
12925 enumeration. We must do this before the type of MINNODE and
12926 MAXNODE are transformed, since tree_int_cst_min_precision relies
12927 on the TREE_TYPE of the value it is passed. */
12928 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
12929 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
12930 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
12931 int precision
= MAX (lowprec
, highprec
);
12933 bool use_short_enum
;
12935 /* Determine the underlying type of the enumeration.
12939 The underlying type of an enumeration is an integral type that
12940 can represent all the enumerator values defined in the
12941 enumeration. It is implementation-defined which integral type is
12942 used as the underlying type for an enumeration except that the
12943 underlying type shall not be larger than int unless the value of
12944 an enumerator cannot fit in an int or unsigned int.
12946 We use "int" or an "unsigned int" as the underlying type, even if
12947 a smaller integral type would work, unless the user has
12948 explicitly requested that we use the smallest possible type. The
12949 user can request that for all enumerations with a command line
12950 flag, or for just one enumeration with an attribute. */
12952 use_short_enum
= flag_short_enums
12953 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12955 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12959 underlying_type
= integer_types
[itk
];
12960 if (underlying_type
!= NULL_TREE
12961 && TYPE_PRECISION (underlying_type
) >= precision
12962 && TYPE_SIGN (underlying_type
) == sgn
)
12965 if (itk
== itk_none
)
12969 IF no integral type can represent all the enumerator values, the
12970 enumeration is ill-formed. */
12971 error ("no integral type can represent all of the enumerator values "
12972 "for %qT", enumtype
);
12973 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12974 underlying_type
= integer_types
[itk_unsigned_long_long
];
12979 The value of sizeof() applied to an enumeration type, an object
12980 of an enumeration type, or an enumerator, is the value of sizeof()
12981 applied to the underlying type. */
12982 copy_type_enum (enumtype
, underlying_type
);
12984 /* Compute the minimum and maximum values for the type.
12988 For an enumeration where emin is the smallest enumerator and emax
12989 is the largest, the values of the enumeration are the values of the
12990 underlying type in the range bmin to bmax, where bmin and bmax are,
12991 respectively, the smallest and largest values of the smallest bit-
12992 field that can store emin and emax. */
12994 /* The middle-end currently assumes that types with TYPE_PRECISION
12995 narrower than their underlying type are suitably zero or sign
12996 extended to fill their mode. Similarly, it assumes that the front
12997 end assures that a value of a particular type must be within
12998 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
13000 We used to set these fields based on bmin and bmax, but that led
13001 to invalid assumptions like optimizing away bounds checking. So
13002 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
13003 TYPE_MAX_VALUE to the values for the mode above and only restrict
13004 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
13005 ENUM_UNDERLYING_TYPE (enumtype
)
13006 = build_distinct_type_copy (underlying_type
);
13007 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
13008 set_min_and_max_values_for_integral_type
13009 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
13011 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
13012 if (flag_strict_enums
)
13013 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
13016 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
13018 /* Convert each of the enumerators to the type of the underlying
13019 type of the enumeration. */
13020 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13022 location_t saved_location
;
13024 decl
= TREE_VALUE (values
);
13025 saved_location
= input_location
;
13026 input_location
= DECL_SOURCE_LOCATION (decl
);
13027 if (fixed_underlying_type_p
)
13028 /* If the enumeration type has a fixed underlying type, we
13029 already checked all of the enumerator values. */
13030 value
= DECL_INITIAL (decl
);
13032 value
= perform_implicit_conversion (underlying_type
,
13033 DECL_INITIAL (decl
),
13034 tf_warning_or_error
);
13035 input_location
= saved_location
;
13037 /* Do not clobber shared ints. */
13038 value
= copy_node (value
);
13040 TREE_TYPE (value
) = enumtype
;
13041 DECL_INITIAL (decl
) = value
;
13044 /* Fix up all variant types of this enum type. */
13045 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
13046 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
13048 if (at_class_scope_p ()
13049 && COMPLETE_TYPE_P (current_class_type
)
13050 && UNSCOPED_ENUM_P (enumtype
))
13051 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
13052 current_class_type
);
13054 /* Finish debugging output for this type. */
13055 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13058 /* Finishes the enum type. This is called only the first time an
13059 enumeration is seen, be it opaque or odinary.
13060 ENUMTYPE is the type object. */
13063 finish_enum (tree enumtype
)
13065 if (processing_template_decl
)
13067 if (at_function_scope_p ())
13068 add_stmt (build_min (TAG_DEFN
, enumtype
));
13072 /* If this is a forward declaration, there should not be any variants,
13073 though we can get a variant in the middle of an enum-specifier with
13074 wacky code like 'enum E { e = sizeof(const E*) };' */
13075 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
13076 && (TYPE_VALUES (enumtype
)
13077 || !TYPE_NEXT_VARIANT (enumtype
)));
13080 /* Build and install a CONST_DECL for an enumeration constant of the
13081 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13082 Apply ATTRIBUTES if available. LOC is the location of NAME.
13083 Assignment of sequential values by default is handled here. */
13086 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
13093 /* scalar_constant_value will pull out this expression, so make sure
13094 it's folded as appropriate. */
13095 if (processing_template_decl
)
13096 value
= fold_non_dependent_expr (value
);
13098 /* If the VALUE was erroneous, pretend it wasn't there; that will
13099 result in the enum being assigned the next value in sequence. */
13100 if (value
== error_mark_node
)
13103 /* Remove no-op casts from the value. */
13105 STRIP_TYPE_NOPS (value
);
13107 if (! processing_template_decl
)
13109 /* Validate and default VALUE. */
13110 if (value
!= NULL_TREE
)
13112 if (!ENUM_UNDERLYING_TYPE (enumtype
))
13114 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
13119 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
13120 (TREE_TYPE (value
)))
13121 value
= perform_implicit_conversion_flags
13122 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
13123 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
13125 if (value
== error_mark_node
)
13128 if (value
!= NULL_TREE
)
13130 value
= cxx_constant_value (value
);
13132 if (TREE_CODE (value
) != INTEGER_CST
13133 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13135 error ("enumerator value for %qD is not an integer constant",
13142 /* Default based on previous value. */
13143 if (value
== NULL_TREE
)
13145 if (TYPE_VALUES (enumtype
))
13150 /* C++03 7.2/4: If no initializer is specified for the first
13151 enumerator, the type is an unspecified integral
13152 type. Otherwise the type is the same as the type of the
13153 initializing value of the preceding enumerator unless the
13154 incremented value is not representable in that type, in
13155 which case the type is an unspecified integral type
13156 sufficient to contain the incremented value. */
13157 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13158 if (error_operand_p (prev_value
))
13159 value
= error_mark_node
;
13162 tree type
= TREE_TYPE (prev_value
);
13163 signop sgn
= TYPE_SIGN (type
);
13164 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
13168 bool pos
= !wi::neg_p (wi
, sgn
);
13169 if (!wi::fits_to_tree_p (wi
, type
))
13172 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
13174 type
= integer_types
[itk
];
13175 if (type
!= NULL_TREE
13176 && (pos
|| !TYPE_UNSIGNED (type
))
13177 && wi::fits_to_tree_p (wi
, type
))
13180 if (type
&& cxx_dialect
< cxx11
13181 && itk
> itk_unsigned_long
)
13182 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
13183 incremented enumerator value is too large for %<unsigned long%>" : "\
13184 incremented enumerator value is too large for %<long%>");
13186 if (type
== NULL_TREE
)
13189 value
= wide_int_to_tree (type
, wi
);
13194 error ("overflow in enumeration values at %qD", name
);
13195 value
= error_mark_node
;
13200 value
= integer_zero_node
;
13203 /* Remove no-op casts from the value. */
13204 STRIP_TYPE_NOPS (value
);
13206 /* If the underlying type of the enum is fixed, check whether
13207 the enumerator values fits in the underlying type. If it
13208 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13209 if (ENUM_UNDERLYING_TYPE (enumtype
)
13211 && TREE_CODE (value
) == INTEGER_CST
)
13213 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
13214 error ("enumerator value %E is outside the range of underlying "
13215 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
13217 /* Convert the value to the appropriate type. */
13218 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
13222 /* C++ associates enums with global, function, or class declarations. */
13223 context
= current_scope ();
13225 /* Build the actual enumeration constant. Note that the enumeration
13226 constants have the underlying type of the enum (if it is fixed)
13227 or the type of their initializer (if the underlying type of the
13228 enum is not fixed):
13232 If the underlying type is fixed, the type of each enumerator
13233 prior to the closing brace is the underlying type; if the
13234 initializing value of an enumerator cannot be represented by
13235 the underlying type, the program is ill-formed. If the
13236 underlying type is not fixed, the type of each enumerator is
13237 the type of its initializing value.
13239 If the underlying type is not fixed, it will be computed by
13240 finish_enum and we will reset the type of this enumerator. Of
13241 course, if we're processing a template, there may be no value. */
13242 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13244 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
13246 DECL_CONTEXT (decl
) = enumtype
;
13247 TREE_CONSTANT (decl
) = 1;
13248 TREE_READONLY (decl
) = 1;
13249 DECL_INITIAL (decl
) = value
;
13252 cplus_decl_attributes (&decl
, attributes
, 0);
13254 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
13255 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13256 on the TYPE_FIELDS list for `S'. (That's so that you can say
13257 things like `S::i' later.) */
13258 finish_member_declaration (decl
);
13262 /* Add this enumeration constant to the list for this type. */
13263 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13266 /* Look for an enumerator with the given NAME within the enumeration
13267 type ENUMTYPE. This routine is used primarily for qualified name
13268 lookup into an enumerator in C++0x, e.g.,
13270 enum class Color { Red, Green, Blue };
13272 Color color = Color::Red;
13274 Returns the value corresponding to the enumerator, or
13275 NULL_TREE if no such enumerator was found. */
13277 lookup_enumerator (tree enumtype
, tree name
)
13280 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13282 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13283 return e
? TREE_VALUE (e
) : NULL_TREE
;
13287 /* We're defining DECL. Make sure that its type is OK. */
13290 check_function_type (tree decl
, tree current_function_parms
)
13292 tree fntype
= TREE_TYPE (decl
);
13293 tree return_type
= complete_type (TREE_TYPE (fntype
));
13295 /* In a function definition, arg types must be complete. */
13296 require_complete_types_for_parms (current_function_parms
);
13298 if (dependent_type_p (return_type
)
13299 || type_uses_auto (return_type
))
13301 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13302 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13304 tree args
= TYPE_ARG_TYPES (fntype
);
13306 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13307 error ("return type %q#T is incomplete", return_type
);
13309 error ("return type has Java class type %q#T", return_type
);
13311 /* Make it return void instead. */
13312 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13313 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13315 TREE_CHAIN (args
));
13317 fntype
= build_function_type (void_type_node
, args
);
13319 = build_exception_variant (fntype
,
13320 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13321 fntype
= (cp_build_type_attribute_variant
13322 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13323 TREE_TYPE (decl
) = fntype
;
13326 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13329 /* Create the FUNCTION_DECL for a function definition.
13330 DECLSPECS and DECLARATOR are the parts of the declaration;
13331 they describe the function's name and the type it returns,
13332 but twisted together in a fashion that parallels the syntax of C.
13334 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13335 DECLARATOR is really the DECL for the function we are about to
13336 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13337 indicating that the function is an inline defined in-class.
13339 This function creates a binding context for the function body
13340 as well as setting up the FUNCTION_DECL in current_function_decl.
13342 For C++, we must first check whether that datum makes any sense.
13343 For example, "class A local_a(1,2);" means that variable local_a
13344 is an aggregate of type A, which should have a constructor
13345 applied to it with the argument list [1, 2].
13347 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13348 or may be a BLOCK if the function has been defined previously
13349 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13350 error_mark_node if the function has never been defined, or
13351 a BLOCK if the function has been defined somewhere. */
13354 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13356 tree ctype
= NULL_TREE
;
13359 int doing_friend
= 0;
13360 cp_binding_level
*bl
;
13361 tree current_function_parms
;
13362 struct c_fileinfo
*finfo
13363 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13364 bool honor_interface
;
13366 /* Sanity check. */
13367 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13368 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13370 fntype
= TREE_TYPE (decl1
);
13371 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13372 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13374 /* ISO C++ 11.4/5. A friend function defined in a class is in
13375 the (lexical) scope of the class in which it is defined. */
13376 if (!ctype
&& DECL_FRIEND_P (decl1
))
13378 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13380 /* CTYPE could be null here if we're dealing with a template;
13381 for example, `inline friend float foo()' inside a template
13382 will have no CTYPE set. */
13383 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13389 if (DECL_DECLARED_INLINE_P (decl1
)
13390 && lookup_attribute ("noinline", attrs
))
13391 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
13392 "inline function %qD given attribute noinline", decl1
);
13394 /* Handle gnu_inline attribute. */
13395 if (GNU_INLINE_P (decl1
))
13397 DECL_EXTERNAL (decl1
) = 1;
13398 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13399 DECL_INTERFACE_KNOWN (decl1
) = 1;
13400 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13403 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13404 /* This is a constructor, we must ensure that any default args
13405 introduced by this definition are propagated to the clones
13406 now. The clones are used directly in overload resolution. */
13407 adjust_clone_args (decl1
);
13409 /* Sometimes we don't notice that a function is a static member, and
13410 build a METHOD_TYPE for it. Fix that up now. */
13411 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13412 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13414 /* Set up current_class_type, and enter the scope of the class, if
13417 push_nested_class (ctype
);
13418 else if (DECL_STATIC_FUNCTION_P (decl1
))
13419 push_nested_class (DECL_CONTEXT (decl1
));
13421 /* Now that we have entered the scope of the class, we must restore
13422 the bindings for any template parameters surrounding DECL1, if it
13423 is an inline member template. (Order is important; consider the
13424 case where a template parameter has the same name as a field of
13425 the class.) It is not until after this point that
13426 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13427 if (flags
& SF_INCLASS_INLINE
)
13428 maybe_begin_member_template_processing (decl1
);
13430 /* Effective C++ rule 15. */
13432 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13433 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13434 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13436 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13437 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13438 if (!DECL_INITIAL (decl1
))
13439 DECL_INITIAL (decl1
) = error_mark_node
;
13441 /* This function exists in static storage.
13442 (This does not mean `static' in the C sense!) */
13443 TREE_STATIC (decl1
) = 1;
13445 /* We must call push_template_decl after current_class_type is set
13446 up. (If we are processing inline definitions after exiting a
13447 class scope, current_class_type will be NULL_TREE until set above
13448 by push_nested_class.) */
13449 if (processing_template_decl
)
13451 tree newdecl1
= push_template_decl (decl1
);
13452 if (newdecl1
== error_mark_node
)
13454 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13455 pop_nested_class ();
13461 /* We are now in the scope of the function being defined. */
13462 current_function_decl
= decl1
;
13464 /* Save the parm names or decls from this function's declarator
13465 where store_parm_decls will find them. */
13466 current_function_parms
= DECL_ARGUMENTS (decl1
);
13468 /* Make sure the parameter and return types are reasonable. When
13469 you declare a function, these types can be incomplete, but they
13470 must be complete when you define the function. */
13471 check_function_type (decl1
, current_function_parms
);
13473 /* Build the return declaration for the function. */
13474 restype
= TREE_TYPE (fntype
);
13476 if (DECL_RESULT (decl1
) == NULL_TREE
)
13480 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13481 DECL_ARTIFICIAL (resdecl
) = 1;
13482 DECL_IGNORED_P (resdecl
) = 1;
13483 DECL_RESULT (decl1
) = resdecl
;
13485 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13488 /* Let the user know we're compiling this function. */
13489 announce_function (decl1
);
13491 /* Record the decl so that the function name is defined.
13492 If we already have a decl for this name, and it is a FUNCTION_DECL,
13493 use the old decl. */
13494 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13496 /* A specialization is not used to guide overload resolution. */
13497 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13498 && !(DECL_USE_TEMPLATE (decl1
) &&
13499 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13501 tree olddecl
= pushdecl (decl1
);
13503 if (olddecl
== error_mark_node
)
13504 /* If something went wrong when registering the declaration,
13505 use DECL1; we have to have a FUNCTION_DECL to use when
13506 parsing the body of the function. */
13510 /* Otherwise, OLDDECL is either a previous declaration
13511 of the same function or DECL1 itself. */
13513 if (warn_missing_declarations
13514 && olddecl
== decl1
13515 && !DECL_MAIN_P (decl1
)
13516 && TREE_PUBLIC (decl1
)
13517 && !DECL_DECLARED_INLINE_P (decl1
))
13521 /* Check whether DECL1 is in an anonymous
13523 for (context
= DECL_CONTEXT (decl1
);
13525 context
= DECL_CONTEXT (context
))
13527 if (TREE_CODE (context
) == NAMESPACE_DECL
13528 && DECL_NAME (context
) == NULL_TREE
)
13532 if (context
== NULL
)
13533 warning_at (DECL_SOURCE_LOCATION (decl1
),
13534 OPT_Wmissing_declarations
,
13535 "no previous declaration for %qD", decl1
);
13543 /* We need to set the DECL_CONTEXT. */
13544 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13545 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13547 fntype
= TREE_TYPE (decl1
);
13548 restype
= TREE_TYPE (fntype
);
13550 /* If #pragma weak applies, mark the decl appropriately now.
13551 The pragma only applies to global functions. Because
13552 determining whether or not the #pragma applies involves
13553 computing the mangled name for the declaration, we cannot
13554 apply the pragma until after we have merged this declaration
13555 with any previous declarations; if the original declaration
13556 has a linkage specification, that specification applies to
13557 the definition as well, and may affect the mangled name. */
13558 if (DECL_FILE_SCOPE_P (decl1
))
13559 maybe_apply_pragma_weak (decl1
);
13562 /* Reset this in case the call to pushdecl changed it. */
13563 current_function_decl
= decl1
;
13565 gcc_assert (DECL_INITIAL (decl1
));
13567 /* This function may already have been parsed, in which case just
13568 return; our caller will skip over the body without parsing. */
13569 if (DECL_INITIAL (decl1
) != error_mark_node
)
13572 /* Initialize RTL machinery. We cannot do this until
13573 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13574 even when processing a template; this is how we get
13575 CFUN set up, and our per-function variables initialized.
13576 FIXME factor out the non-RTL stuff. */
13577 bl
= current_binding_level
;
13578 allocate_struct_function (decl1
, processing_template_decl
);
13580 /* Initialize the language data structures. Whenever we start
13581 a new function, we destroy temporaries in the usual way. */
13582 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
13583 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13584 current_binding_level
= bl
;
13586 if (!processing_template_decl
&& type_uses_auto (restype
))
13588 FNDECL_USED_AUTO (decl1
) = true;
13589 current_function_auto_return_pattern
= restype
;
13592 /* Start the statement-tree, start the tree now. */
13593 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13595 /* If we are (erroneously) defining a function that we have already
13596 defined before, wipe out what we knew before. */
13597 if (!DECL_PENDING_INLINE_P (decl1
))
13598 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13600 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13602 /* We know that this was set up by `grokclassfn'. We do not
13603 wait until `store_parm_decls', since evil parse errors may
13604 never get us to that point. Here we keep the consistency
13605 between `current_class_type' and `current_class_ptr'. */
13606 tree t
= DECL_ARGUMENTS (decl1
);
13608 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13609 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13611 cp_function_chain
->x_current_class_ref
13612 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13613 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13614 cp_function_chain
->x_current_class_ptr
= t
;
13616 /* Constructors and destructors need to know whether they're "in
13617 charge" of initializing virtual base classes. */
13618 t
= DECL_CHAIN (t
);
13619 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13621 current_in_charge_parm
= t
;
13622 t
= DECL_CHAIN (t
);
13624 if (DECL_HAS_VTT_PARM_P (decl1
))
13626 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13627 current_vtt_parm
= t
;
13631 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13632 /* Implicitly-defined methods (like the
13633 destructor for a class in which no destructor
13634 is explicitly declared) must not be defined
13635 until their definition is needed. So, we
13636 ignore interface specifications for
13637 compiler-generated functions. */
13638 && !DECL_ARTIFICIAL (decl1
));
13640 if (processing_template_decl
)
13641 /* Don't mess with interface flags. */;
13642 else if (DECL_INTERFACE_KNOWN (decl1
))
13644 tree ctx
= decl_function_context (decl1
);
13646 if (DECL_NOT_REALLY_EXTERN (decl1
))
13647 DECL_EXTERNAL (decl1
) = 0;
13649 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13650 /* This is a function in a local class in an extern inline
13651 or template function. */
13652 comdat_linkage (decl1
);
13654 /* If this function belongs to an interface, it is public.
13655 If it belongs to someone else's interface, it is also external.
13656 This only affects inlines and template instantiations. */
13657 else if (!finfo
->interface_unknown
&& honor_interface
)
13659 if (DECL_DECLARED_INLINE_P (decl1
)
13660 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13662 DECL_EXTERNAL (decl1
)
13663 = (finfo
->interface_only
13664 || (DECL_DECLARED_INLINE_P (decl1
)
13665 && ! flag_implement_inlines
13666 && !DECL_VINDEX (decl1
)));
13668 /* For WIN32 we also want to put these in linkonce sections. */
13669 maybe_make_one_only (decl1
);
13672 DECL_EXTERNAL (decl1
) = 0;
13673 DECL_INTERFACE_KNOWN (decl1
) = 1;
13674 /* If this function is in an interface implemented in this file,
13675 make sure that the back end knows to emit this function
13677 if (!DECL_EXTERNAL (decl1
))
13678 mark_needed (decl1
);
13680 else if (finfo
->interface_unknown
&& finfo
->interface_only
13681 && honor_interface
)
13683 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13684 interface, we will have both finfo->interface_unknown and
13685 finfo->interface_only set. In that case, we don't want to
13686 use the normal heuristics because someone will supply a
13687 #pragma implementation elsewhere, and deducing it here would
13688 produce a conflict. */
13689 comdat_linkage (decl1
);
13690 DECL_EXTERNAL (decl1
) = 0;
13691 DECL_INTERFACE_KNOWN (decl1
) = 1;
13692 DECL_DEFER_OUTPUT (decl1
) = 1;
13696 /* This is a definition, not a reference.
13697 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13698 if (!GNU_INLINE_P (decl1
))
13699 DECL_EXTERNAL (decl1
) = 0;
13701 if ((DECL_DECLARED_INLINE_P (decl1
)
13702 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13703 && ! DECL_INTERFACE_KNOWN (decl1
))
13704 DECL_DEFER_OUTPUT (decl1
) = 1;
13706 DECL_INTERFACE_KNOWN (decl1
) = 1;
13709 /* Determine the ELF visibility attribute for the function. We must not
13710 do this before calling "pushdecl", as we must allow "duplicate_decls"
13711 to merge any attributes appropriately. We also need to wait until
13713 if (!DECL_CLONED_FUNCTION_P (decl1
))
13714 determine_visibility (decl1
);
13716 if (!processing_template_decl
)
13717 maybe_instantiate_noexcept (decl1
);
13719 begin_scope (sk_function_parms
, decl1
);
13723 if (DECL_DESTRUCTOR_P (decl1
)
13724 || (DECL_CONSTRUCTOR_P (decl1
)
13725 && targetm
.cxx
.cdtor_returns_this ()))
13727 cdtor_label
= create_artificial_label (input_location
);
13730 start_fname_decls ();
13732 store_parm_decls (current_function_parms
);
13734 if (!processing_template_decl
13735 && flag_lifetime_dse
&& DECL_CONSTRUCTOR_P (decl1
))
13737 /* Insert a clobber to let the back end know that the object storage
13738 is dead when we enter the constructor. */
13739 tree btype
= CLASSTYPE_AS_BASE (current_class_type
);
13740 tree clobber
= build_constructor (btype
, NULL
);
13741 TREE_THIS_VOLATILE (clobber
) = true;
13742 tree bref
= build_nop (build_reference_type (btype
), current_class_ptr
);
13743 bref
= convert_from_reference (bref
);
13744 tree exprstmt
= build2 (MODIFY_EXPR
, btype
, bref
, clobber
);
13745 finish_expr_stmt (exprstmt
);
13752 /* Like start_preparsed_function, except that instead of a
13753 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13755 Returns true on success. If the DECLARATOR is not suitable
13756 for a function, we return false, which tells the parser to
13757 skip the entire function. */
13760 start_function (cp_decl_specifier_seq
*declspecs
,
13761 const cp_declarator
*declarator
,
13766 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13767 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
13768 if (decl1
== error_mark_node
)
13770 /* If the declarator is not suitable for a function definition,
13771 cause a syntax error. */
13772 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13774 error ("invalid function declaration");
13778 if (DECL_MAIN_P (decl1
))
13779 /* main must return int. grokfndecl should have corrected it
13780 (and issued a diagnostic) if the user got it wrong. */
13781 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13782 integer_type_node
));
13784 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13787 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13791 use_eh_spec_block (tree fn
)
13793 return (flag_exceptions
&& flag_enforce_eh_specs
13794 && !processing_template_decl
13795 && !type_throw_all_p (TREE_TYPE (fn
))
13796 /* We insert the EH_SPEC_BLOCK only in the original
13797 function; then, it is copied automatically to the
13799 && !DECL_CLONED_FUNCTION_P (fn
)
13800 /* Implicitly-generated constructors and destructors have
13801 exception specifications. However, those specifications
13802 are the union of the possible exceptions specified by the
13803 constructors/destructors for bases and members, so no
13804 unallowed exception will ever reach this function. By
13805 not creating the EH_SPEC_BLOCK we save a little memory,
13806 and we avoid spurious warnings about unreachable
13808 && !DECL_DEFAULTED_FN (fn
));
13811 /* Store the parameter declarations into the current function declaration.
13812 This is called after parsing the parameter declarations, before
13813 digesting the body of the function.
13815 Also install to binding contour return value identifier, if any. */
13818 store_parm_decls (tree current_function_parms
)
13820 tree fndecl
= current_function_decl
;
13823 /* This is a chain of any other decls that came in among the parm
13824 declarations. If a parm is declared with enum {foo, bar} x;
13825 then CONST_DECLs for foo and bar are put here. */
13826 tree nonparms
= NULL_TREE
;
13828 if (current_function_parms
)
13830 /* This case is when the function was defined with an ANSI prototype.
13831 The parms already have decls, so we need not do anything here
13832 except record them as in effect
13833 and complain if any redundant old-style parm decls were written. */
13835 tree specparms
= current_function_parms
;
13838 /* Must clear this because it might contain TYPE_DECLs declared
13840 current_binding_level
->names
= NULL
;
13842 /* If we're doing semantic analysis, then we'll call pushdecl
13843 for each of these. We must do them in reverse order so that
13844 they end in the correct forward order. */
13845 specparms
= nreverse (specparms
);
13847 for (parm
= specparms
; parm
; parm
= next
)
13849 next
= DECL_CHAIN (parm
);
13850 if (TREE_CODE (parm
) == PARM_DECL
)
13852 if (DECL_NAME (parm
) == NULL_TREE
13853 || !VOID_TYPE_P (parm
))
13856 error ("parameter %qD declared void", parm
);
13860 /* If we find an enum constant or a type tag,
13861 put it aside for the moment. */
13862 TREE_CHAIN (parm
) = NULL_TREE
;
13863 nonparms
= chainon (nonparms
, parm
);
13867 /* Get the decls in their original chain order and record in the
13868 function. This is all and only the PARM_DECLs that were
13869 pushed into scope by the loop above. */
13870 DECL_ARGUMENTS (fndecl
) = getdecls ();
13873 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13875 /* Now store the final chain of decls for the arguments
13876 as the decl-chain of the current lexical scope.
13877 Put the enumerators in as well, at the front so that
13878 DECL_ARGUMENTS is not modified. */
13879 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13881 if (use_eh_spec_block (current_function_decl
))
13882 current_eh_spec_block
= begin_eh_spec_block ();
13886 /* We have finished doing semantic analysis on DECL, but have not yet
13887 generated RTL for its body. Save away our current state, so that
13888 when we want to generate RTL later we know what to do. */
13891 save_function_data (tree decl
)
13893 struct language_function
*f
;
13895 /* Save the language-specific per-function data so that we can
13896 get it back when we really expand this function. */
13897 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13900 f
= ggc_alloc
<language_function
> ();
13901 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13902 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13904 /* Clear out the bits we don't need. */
13905 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13906 f
->bindings
= NULL
;
13907 f
->x_local_names
= NULL
;
13908 f
->base
.local_typedefs
= NULL
;
13912 /* Set the return value of the constructor (if present). */
13915 finish_constructor_body (void)
13920 if (targetm
.cxx
.cdtor_returns_this ()
13921 && (! TYPE_FOR_JAVA (current_class_type
)))
13923 /* Any return from a constructor will end up here. */
13924 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13926 val
= DECL_ARGUMENTS (current_function_decl
);
13927 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13928 DECL_RESULT (current_function_decl
), val
);
13929 /* Return the address of the object. */
13930 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13931 add_stmt (exprstmt
);
13935 /* Do all the processing for the beginning of a destructor; set up the
13936 vtable pointers and cleanups for bases and members. */
13939 begin_destructor_body (void)
13941 tree compound_stmt
;
13943 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13944 issued an error message. We still want to try to process the
13945 body of the function, but initialize_vtbl_ptrs will crash if
13946 TYPE_BINFO is NULL. */
13947 if (COMPLETE_TYPE_P (current_class_type
))
13949 compound_stmt
= begin_compound_stmt (0);
13950 /* Make all virtual function table pointers in non-virtual base
13951 classes point to CURRENT_CLASS_TYPE's virtual function
13953 initialize_vtbl_ptrs (current_class_ptr
);
13954 finish_compound_stmt (compound_stmt
);
13956 if (flag_lifetime_dse
)
13958 /* Insert a cleanup to let the back end know that the object is dead
13959 when we exit the destructor, either normally or via exception. */
13960 tree btype
= CLASSTYPE_AS_BASE (current_class_type
);
13961 tree clobber
= build_constructor (btype
, NULL
);
13962 TREE_THIS_VOLATILE (clobber
) = true;
13963 tree bref
= build_nop (build_reference_type (btype
),
13964 current_class_ptr
);
13965 bref
= convert_from_reference (bref
);
13966 tree exprstmt
= build2 (MODIFY_EXPR
, btype
, bref
, clobber
);
13967 finish_decl_cleanup (NULL_TREE
, exprstmt
);
13970 /* And insert cleanups for our bases and members so that they
13971 will be properly destroyed if we throw. */
13972 push_base_cleanups ();
13976 /* At the end of every destructor we generate code to delete the object if
13977 necessary. Do that now. */
13980 finish_destructor_body (void)
13984 /* Any return from a destructor will end up here; that way all base
13985 and member cleanups will be run when the function returns. */
13986 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13988 /* In a virtual destructor, we must call delete. */
13989 if (DECL_VIRTUAL_P (current_function_decl
))
13992 tree virtual_size
= cxx_sizeof (current_class_type
);
13996 At the point of definition of a virtual destructor (including
13997 an implicit definition), non-placement operator delete shall
13998 be looked up in the scope of the destructor's class and if
13999 found shall be accessible and unambiguous. */
14000 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
14002 /*global_p=*/false,
14003 /*placement=*/NULL_TREE
,
14004 /*alloc_fn=*/NULL_TREE
,
14005 tf_warning_or_error
);
14007 if_stmt
= begin_if_stmt ();
14008 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
14009 current_in_charge_parm
,
14012 finish_expr_stmt (exprstmt
);
14013 finish_then_clause (if_stmt
);
14014 finish_if_stmt (if_stmt
);
14017 if (targetm
.cxx
.cdtor_returns_this ())
14021 val
= DECL_ARGUMENTS (current_function_decl
);
14022 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14023 DECL_RESULT (current_function_decl
), val
);
14024 /* Return the address of the object. */
14025 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14026 add_stmt (exprstmt
);
14030 /* Do the necessary processing for the beginning of a function body, which
14031 in this case includes member-initializers, but not the catch clauses of
14032 a function-try-block. Currently, this means opening a binding level
14033 for the member-initializers (in a ctor), member cleanups (in a dtor),
14034 and capture proxies (in a lambda operator()). */
14037 begin_function_body (void)
14041 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
14044 if (processing_template_decl
)
14045 /* Do nothing now. */;
14047 /* Always keep the BLOCK node associated with the outermost pair of
14048 curly braces of a function. These are needed for correct
14049 operation of dwarfout.c. */
14050 keep_next_level (true);
14052 stmt
= begin_compound_stmt (BCS_FN_BODY
);
14054 if (processing_template_decl
)
14055 /* Do nothing now. */;
14056 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14057 begin_destructor_body ();
14062 /* Do the processing for the end of a function body. Currently, this means
14063 closing out the cleanups for fully-constructed bases and members, and in
14064 the case of the destructor, deleting the object if desired. Again, this
14065 is only meaningful for [cd]tors, since they are the only functions where
14066 there is a significant distinction between the main body and any
14067 function catch clauses. Handling, say, main() return semantics here
14068 would be wrong, as flowing off the end of a function catch clause for
14069 main() would also need to return 0. */
14072 finish_function_body (tree compstmt
)
14074 if (compstmt
== NULL_TREE
)
14077 /* Close the block. */
14078 finish_compound_stmt (compstmt
);
14080 if (processing_template_decl
)
14081 /* Do nothing now. */;
14082 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
14083 finish_constructor_body ();
14084 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14085 finish_destructor_body ();
14088 /* Given a function, returns the BLOCK corresponding to the outermost level
14089 of curly braces, skipping the artificial block created for constructor
14093 outer_curly_brace_block (tree fndecl
)
14095 tree block
= DECL_INITIAL (fndecl
);
14096 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14098 block
= BLOCK_SUBBLOCKS (block
);
14099 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14101 block
= BLOCK_SUBBLOCKS (block
);
14102 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
14106 /* If FNDECL is a class's key method, add the class to the list of
14107 keyed classes that should be emitted. */
14110 record_key_method_defined (tree fndecl
)
14112 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
14113 && DECL_VIRTUAL_P (fndecl
)
14114 && !processing_template_decl
)
14116 tree fnclass
= DECL_CONTEXT (fndecl
);
14117 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
14118 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
14122 /* Subroutine of finish_function.
14123 Save the body of constexpr functions for possible
14124 future compile time evaluation. */
14127 maybe_save_function_definition (tree fun
)
14129 if (!processing_template_decl
14130 && DECL_DECLARED_CONSTEXPR_P (fun
)
14131 && !cp_function_chain
->invalid_constexpr
14132 && !DECL_CLONED_FUNCTION_P (fun
))
14133 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
14136 /* Finish up a function declaration and compile that function
14137 all the way to assembler language output. The free the storage
14138 for the function definition.
14140 FLAGS is a bitwise or of the following values:
14142 We just finished processing the body of an in-class inline
14143 function definition. (This processing will have taken place
14144 after the class definition is complete.) */
14147 finish_function (int flags
)
14149 tree fndecl
= current_function_decl
;
14150 tree fntype
, ctype
= NULL_TREE
;
14151 int inclass_inline
= (flags
& 2) != 0;
14153 /* When we get some parse errors, we can end up without a
14154 current_function_decl, so cope. */
14155 if (fndecl
== NULL_TREE
)
14156 return error_mark_node
;
14158 if (c_dialect_objc ())
14159 objc_finish_function ();
14161 gcc_assert (!defer_mark_used_calls
);
14162 defer_mark_used_calls
= true;
14164 record_key_method_defined (fndecl
);
14166 fntype
= TREE_TYPE (fndecl
);
14168 /* TREE_READONLY (fndecl) = 1;
14169 This caused &foo to be of type ptr-to-const-function
14170 which then got a warning when stored in a ptr-to-function variable. */
14172 gcc_assert (building_stmt_list_p ());
14173 /* The current function is being defined, so its DECL_INITIAL should
14174 be set, and unless there's a multiple definition, it should be
14175 error_mark_node. */
14176 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
14178 /* For a cloned function, we've already got all the code we need;
14179 there's no need to add any extra bits. */
14180 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14182 /* Make it so that `main' always returns 0 by default. */
14183 if (DECL_MAIN_P (current_function_decl
))
14184 finish_return_stmt (integer_zero_node
);
14186 if (use_eh_spec_block (current_function_decl
))
14187 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14188 (TREE_TYPE (current_function_decl
)),
14189 current_eh_spec_block
);
14192 /* If we're saving up tree structure, tie off the function now. */
14193 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
14195 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
14196 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
14198 finish_fname_decls ();
14200 /* If this function can't throw any exceptions, remember that. */
14201 if (!processing_template_decl
14202 && !cp_function_chain
->can_throw
14203 && !flag_non_call_exceptions
14204 && !decl_replaceable_p (fndecl
))
14205 TREE_NOTHROW (fndecl
) = 1;
14207 /* This must come after expand_function_end because cleanups might
14208 have declarations (from inline functions) that need to go into
14209 this function's blocks. */
14211 /* If the current binding level isn't the outermost binding level
14212 for this function, either there is a bug, or we have experienced
14213 syntax errors and the statement tree is malformed. */
14214 if (current_binding_level
->kind
!= sk_function_parms
)
14216 /* Make sure we have already experienced errors. */
14217 gcc_assert (errorcount
);
14219 /* Throw away the broken statement tree and extra binding
14221 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
14223 while (current_binding_level
->kind
!= sk_function_parms
)
14225 if (current_binding_level
->kind
== sk_class
)
14226 pop_nested_class ();
14228 poplevel (0, 0, 0);
14231 poplevel (1, 0, 1);
14233 /* Statements should always be full-expressions at the outermost set
14234 of curly braces for a function. */
14235 gcc_assert (stmts_are_full_exprs_p ());
14237 /* If there are no return statements in a function with auto return type,
14238 the return type is void. But if the declared type is something like
14239 auto*, this is an error. */
14240 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
14241 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
14243 if (!is_auto (current_function_auto_return_pattern
)
14244 && !current_function_returns_value
&& !current_function_returns_null
)
14246 error ("no return statements in function returning %qT",
14247 current_function_auto_return_pattern
);
14248 inform (input_location
, "only plain %<auto%> return type can be "
14249 "deduced to %<void%>");
14251 apply_deduced_return_type (fndecl
, void_type_node
);
14252 fntype
= TREE_TYPE (fndecl
);
14255 /* Save constexpr function body before it gets munged by
14256 the NRV transformation. */
14257 maybe_save_function_definition (fndecl
);
14259 /* Set up the named return value optimization, if we can. Candidate
14260 variables are selected in check_return_expr. */
14261 if (current_function_return_value
)
14263 tree r
= current_function_return_value
;
14266 if (r
!= error_mark_node
14267 /* This is only worth doing for fns that return in memory--and
14268 simpler, since we don't have to worry about promoted modes. */
14269 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
14270 /* Only allow this for variables declared in the outer scope of
14271 the function so we know that their lifetime always ends with a
14272 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14273 we were to do this optimization in tree-ssa. */
14274 && (outer
= outer_curly_brace_block (fndecl
))
14275 && chain_member (r
, BLOCK_VARS (outer
)))
14276 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
14278 current_function_return_value
= NULL_TREE
;
14281 /* Remember that we were in class scope. */
14282 if (current_class_name
)
14283 ctype
= current_class_type
;
14285 /* Must mark the RESULT_DECL as being in this function. */
14286 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14288 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14289 to the FUNCTION_DECL node itself. */
14290 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14292 /* Save away current state, if appropriate. */
14293 if (!processing_template_decl
)
14294 save_function_data (fndecl
);
14296 /* Complain if there's just no return statement. */
14297 if (warn_return_type
14298 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14299 && !dependent_type_p (TREE_TYPE (fntype
))
14300 && !current_function_returns_value
&& !current_function_returns_null
14301 /* Don't complain if we abort or throw. */
14302 && !current_function_returns_abnormally
14303 /* Don't complain if there's an infinite loop. */
14304 && !current_function_infinite_loop
14305 /* Don't complain if we are declared noreturn. */
14306 && !TREE_THIS_VOLATILE (fndecl
)
14307 && !DECL_NAME (DECL_RESULT (fndecl
))
14308 && !TREE_NO_WARNING (fndecl
)
14309 /* Structor return values (if any) are set by the compiler. */
14310 && !DECL_CONSTRUCTOR_P (fndecl
)
14311 && !DECL_DESTRUCTOR_P (fndecl
)
14312 && targetm
.warn_func_return (fndecl
))
14314 warning (OPT_Wreturn_type
,
14315 "no return statement in function returning non-void");
14316 TREE_NO_WARNING (fndecl
) = 1;
14319 /* Store the end of the function, so that we get good line number
14320 info for the epilogue. */
14321 cfun
->function_end_locus
= input_location
;
14323 /* Complain about parameters that are only set, but never otherwise used. */
14324 if (warn_unused_but_set_parameter
14325 && !processing_template_decl
14326 && errorcount
== unused_but_set_errorcount
14327 && !DECL_CLONED_FUNCTION_P (fndecl
))
14331 for (decl
= DECL_ARGUMENTS (fndecl
);
14333 decl
= DECL_CHAIN (decl
))
14334 if (TREE_USED (decl
)
14335 && TREE_CODE (decl
) == PARM_DECL
14336 && !DECL_READ_P (decl
)
14337 && DECL_NAME (decl
)
14338 && !DECL_ARTIFICIAL (decl
)
14339 && !TREE_NO_WARNING (decl
)
14340 && !DECL_IN_SYSTEM_HEADER (decl
)
14341 && TREE_TYPE (decl
) != error_mark_node
14342 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14343 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14344 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14345 warning_at (DECL_SOURCE_LOCATION (decl
),
14346 OPT_Wunused_but_set_parameter
,
14347 "parameter %qD set but not used", decl
);
14348 unused_but_set_errorcount
= errorcount
;
14351 /* Complain about locally defined typedefs that are not used in this
14353 maybe_warn_unused_local_typedefs ();
14355 /* Possibly warn about unused parameters. */
14356 if (warn_unused_parameter
14357 && !processing_template_decl
14358 && !DECL_CLONED_FUNCTION_P (fndecl
))
14359 do_warn_unused_parameter (fndecl
);
14361 /* Genericize before inlining. */
14362 if (!processing_template_decl
)
14364 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14365 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14366 cp_genericize (fndecl
);
14367 /* Clear out the bits we don't need. */
14368 f
->x_current_class_ptr
= NULL
;
14369 f
->x_current_class_ref
= NULL
;
14370 f
->x_eh_spec_block
= NULL
;
14371 f
->x_in_charge_parm
= NULL
;
14372 f
->x_vtt_parm
= NULL
;
14373 f
->x_return_value
= NULL
;
14374 f
->bindings
= NULL
;
14375 f
->extern_decl_map
= NULL
;
14376 f
->infinite_loops
= NULL
;
14378 /* Clear out the bits we don't need. */
14379 local_names
= NULL
;
14381 /* We're leaving the context of this function, so zap cfun. It's still in
14382 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14384 current_function_decl
= NULL
;
14386 /* If this is an in-class inline definition, we may have to pop the
14387 bindings for the template parameters that we added in
14388 maybe_begin_member_template_processing when start_function was
14390 if (inclass_inline
)
14391 maybe_end_member_template_processing ();
14393 /* Leave the scope of the class. */
14395 pop_nested_class ();
14400 current_function_decl
= NULL_TREE
;
14402 defer_mark_used_calls
= false;
14403 if (deferred_mark_used_calls
)
14408 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14410 vec_free (deferred_mark_used_calls
);
14413 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
14417 /* Create the FUNCTION_DECL for a function definition.
14418 DECLSPECS and DECLARATOR are the parts of the declaration;
14419 they describe the return type and the name of the function,
14420 but twisted together in a fashion that parallels the syntax of C.
14422 This function creates a binding context for the function body
14423 as well as setting up the FUNCTION_DECL in current_function_decl.
14425 Returns a FUNCTION_DECL on success.
14427 If the DECLARATOR is not suitable for a function (it defines a datum
14428 instead), we return 0, which tells yyparse to report a parse error.
14430 May return void_type_node indicating that this method is actually
14431 a friend. See grokfield for more details.
14433 Came here with a `.pushlevel' .
14435 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14436 CHANGES TO CODE IN `grokfield'. */
14439 grokmethod (cp_decl_specifier_seq
*declspecs
,
14440 const cp_declarator
*declarator
, tree attrlist
)
14442 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14445 if (fndecl
== error_mark_node
)
14446 return error_mark_node
;
14448 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14450 error ("invalid member function declaration");
14451 return error_mark_node
;
14455 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14457 /* Pass friends other than inline friend functions back. */
14458 if (fndecl
== void_type_node
)
14461 if (DECL_IN_AGGR_P (fndecl
))
14463 if (DECL_CLASS_SCOPE_P (fndecl
))
14464 error ("%qD is already defined in class %qT", fndecl
,
14465 DECL_CONTEXT (fndecl
));
14466 return error_mark_node
;
14469 check_template_shadow (fndecl
);
14471 if (TREE_PUBLIC (fndecl
))
14472 DECL_COMDAT (fndecl
) = 1;
14473 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14474 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14476 /* We process method specializations in finish_struct_1. */
14477 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14479 fndecl
= push_template_decl (fndecl
);
14480 if (fndecl
== error_mark_node
)
14484 if (! DECL_FRIEND_P (fndecl
))
14486 if (DECL_CHAIN (fndecl
))
14488 fndecl
= copy_node (fndecl
);
14489 TREE_CHAIN (fndecl
) = NULL_TREE
;
14493 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14495 DECL_IN_AGGR_P (fndecl
) = 1;
14500 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14501 we can lay it out later, when and if its type becomes complete.
14503 Also handle constexpr variables where the initializer involves
14504 an unlowered PTRMEM_CST because the class isn't complete yet. */
14507 maybe_register_incomplete_var (tree var
)
14509 gcc_assert (VAR_P (var
));
14511 /* Keep track of variables with incomplete types. */
14512 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14513 && DECL_EXTERNAL (var
))
14515 tree inner_type
= TREE_TYPE (var
);
14517 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14518 inner_type
= TREE_TYPE (inner_type
);
14519 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14521 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14522 /* RTTI TD entries are created while defining the type_info. */
14523 || (TYPE_LANG_SPECIFIC (inner_type
)
14524 && TYPE_BEING_DEFINED (inner_type
)))
14526 incomplete_var iv
= {var
, inner_type
};
14527 vec_safe_push (incomplete_vars
, iv
);
14529 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
14530 && decl_constant_var_p (var
)
14531 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
14533 /* When the outermost open class is complete we can resolve any
14534 pointers-to-members. */
14535 tree context
= outermost_open_class ();
14536 incomplete_var iv
= {var
, context
};
14537 vec_safe_push (incomplete_vars
, iv
);
14542 /* Called when a class type (given by TYPE) is defined. If there are
14543 any existing VAR_DECLs whose type has been completed by this
14544 declaration, update them now. */
14547 complete_vars (tree type
)
14550 incomplete_var
*iv
;
14552 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14554 if (same_type_p (type
, iv
->incomplete_type
))
14556 tree var
= iv
->decl
;
14557 tree type
= TREE_TYPE (var
);
14559 if (TYPE_MAIN_VARIANT (strip_array_types (type
))
14560 == iv
->incomplete_type
)
14562 /* Complete the type of the variable. The VAR_DECL itself
14563 will be laid out in expand_expr. */
14564 complete_type (type
);
14565 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14568 if (DECL_INITIAL (var
)
14569 && decl_constant_var_p (var
))
14570 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14572 /* Remove this entry from the list. */
14573 incomplete_vars
->unordered_remove (ix
);
14579 /* Check for pending declarations which may have abstract type. */
14580 complete_type_check_abstract (type
);
14583 /* If DECL is of a type which needs a cleanup, build and return an
14584 expression to perform that cleanup here. Return NULL_TREE if no
14585 cleanup need be done. */
14588 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14594 /* Assume no cleanup is required. */
14595 cleanup
= NULL_TREE
;
14597 if (error_operand_p (decl
))
14600 /* Handle "__attribute__((cleanup))". We run the cleanup function
14601 before the destructor since the destructor is what actually
14602 terminates the lifetime of the object. */
14603 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14610 /* Get the name specified by the user for the cleanup function. */
14611 id
= TREE_VALUE (TREE_VALUE (attr
));
14612 /* Look up the name to find the cleanup function to call. It is
14613 important to use lookup_name here because that is what is
14614 used in c-common.c:handle_cleanup_attribute when performing
14615 initial checks on the attribute. Note that those checks
14616 include ensuring that the function found is not an overloaded
14617 function, or an object with an overloaded call operator,
14618 etc.; we can rely on the fact that the function found is an
14619 ordinary FUNCTION_DECL. */
14620 fn
= lookup_name (id
);
14621 arg
= build_address (decl
);
14622 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
14623 return error_mark_node
;
14624 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14625 if (cleanup
== error_mark_node
)
14626 return error_mark_node
;
14628 /* Handle ordinary C++ destructors. */
14629 type
= TREE_TYPE (decl
);
14630 if (type_build_dtor_call (type
))
14632 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14636 if (TREE_CODE (type
) == ARRAY_TYPE
)
14639 addr
= build_address (decl
);
14641 call
= build_delete (TREE_TYPE (addr
), addr
,
14642 sfk_complete_destructor
, flags
, 0, complain
);
14643 if (call
== error_mark_node
)
14644 cleanup
= error_mark_node
;
14645 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14646 /* Discard the call. */;
14648 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14653 /* build_delete sets the location of the destructor call to the
14654 current location, even though the destructor is going to be
14655 called later, at the end of the current scope. This can lead to
14656 a "jumpy" behaviour for users of debuggers when they step around
14657 the end of the block. So let's unset the location of the
14658 destructor call instead. */
14659 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14660 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14663 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
14664 /* Treat objects with destructors as used; the destructor may do
14665 something substantive. */
14666 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
14667 return error_mark_node
;
14673 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14674 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14675 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14678 static_fn_type (tree memfntype
)
14683 if (TYPE_PTRMEMFUNC_P (memfntype
))
14684 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14685 if (POINTER_TYPE_P (memfntype
)
14686 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14687 memfntype
= TREE_TYPE (memfntype
);
14688 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14690 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14691 args
= TYPE_ARG_TYPES (memfntype
);
14692 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14693 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14694 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14695 fntype
= (cp_build_type_attribute_variant
14696 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14697 fntype
= (build_exception_variant
14698 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14699 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
14700 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
14704 /* DECL was originally constructed as a non-static member function,
14705 but turned out to be static. Update it accordingly. */
14708 revert_static_member_fn (tree decl
)
14710 tree stype
= static_fn_type (decl
);
14711 cp_cv_quals quals
= type_memfn_quals (stype
);
14712 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14714 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14715 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14717 TREE_TYPE (decl
) = stype
;
14719 if (DECL_ARGUMENTS (decl
))
14720 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14721 DECL_STATIC_FUNCTION_P (decl
) = 1;
14724 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14725 one of the language-independent trees. */
14727 enum cp_tree_node_structure_enum
14728 cp_tree_node_structure (union lang_tree_node
* t
)
14730 switch (TREE_CODE (&t
->generic
))
14732 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14733 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14734 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14735 case OVERLOAD
: return TS_CP_OVERLOAD
;
14736 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14737 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14738 case BASELINK
: return TS_CP_BASELINK
;
14739 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
14740 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14741 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14742 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14743 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14744 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14745 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14746 default: return TS_CP_GENERIC
;
14750 /* Build the void_list_node (void_type_node having been created). */
14752 build_void_list_node (void)
14754 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14759 cp_missing_noreturn_ok_p (tree decl
)
14761 /* A missing noreturn is ok for the `main' function. */
14762 return DECL_MAIN_P (decl
);
14765 /* Return the decl used to identify the COMDAT group into which DECL should
14769 cxx_comdat_group (tree decl
)
14771 /* Virtual tables, construction virtual tables, and virtual table
14772 tables all go in a single COMDAT group, named after the primary
14774 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14775 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
14776 /* For all other DECLs, the COMDAT group is the mangled name of the
14777 declaration itself. */
14780 while (DECL_THUNK_P (decl
))
14782 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14783 into the same section as the target function. In that case
14784 we must return target's name. */
14785 tree target
= THUNK_TARGET (decl
);
14786 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14787 && DECL_SECTION_NAME (target
) != NULL
14788 && DECL_ONE_ONLY (target
))
14798 /* Returns the return type for FN as written by the user, which may include
14799 a placeholder for a deduced return type. */
14802 fndecl_declared_return_type (tree fn
)
14804 fn
= STRIP_TEMPLATE (fn
);
14805 if (FNDECL_USED_AUTO (fn
))
14807 struct language_function
*f
= NULL
;
14808 if (DECL_STRUCT_FUNCTION (fn
))
14809 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
14811 f
= DECL_SAVED_FUNCTION_DATA (fn
);
14812 return f
->x_auto_return_pattern
;
14814 return TREE_TYPE (TREE_TYPE (fn
));
14817 /* Returns true iff DECL was declared with an auto return type and it has
14818 not yet been deduced to a real type. */
14821 undeduced_auto_decl (tree decl
)
14823 if (cxx_dialect
< cxx14
)
14825 return type_uses_auto (TREE_TYPE (decl
));
14828 /* Complain if DECL has an undeduced return type. */
14831 require_deduced_type (tree decl
)
14833 if (undeduced_auto_decl (decl
))
14834 error ("use of %qD before deduction of %<auto%>", decl
);
14837 #include "gt-cp-decl.h"