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"
33 #include "c-family/c-target.h"
36 #include "stringpool.h"
38 #include "stor-layout.h"
42 #include "tree-iterator.h"
46 #include "c-family/c-objc.h"
47 #include "c-family/c-pragma.h"
48 #include "c-family/c-ubsan.h"
54 /* Possible cases of bad specifiers type used by bad_specifiers. */
56 BSP_VAR
, /* variable */
57 BSP_PARM
, /* parameter */
62 static const char *redeclaration_error_message (tree
, tree
);
64 static int decl_jump_unsafe (tree
);
65 static void require_complete_types_for_parms (tree
);
66 static int ambi_op_p (enum tree_code
);
67 static int unary_op_p (enum tree_code
);
68 static void push_local_name (tree
);
69 static tree
grok_reference_init (tree
, tree
, tree
, int);
70 static tree
grokvardecl (tree
, tree
, tree
, const cp_decl_specifier_seq
*,
72 static int check_static_variable_definition (tree
, tree
);
73 static void record_unknown_type (tree
, const char *);
74 static tree
builtin_function_1 (tree
, tree
, bool);
75 static int member_function_or_else (tree
, tree
, enum overload_flags
);
76 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
78 static void check_for_uninitialized_const_var (tree
);
79 static tree
local_variable_p_walkfn (tree
*, int *, void *);
80 static tree
record_builtin_java_type (const char *, int);
81 static const char *tag_name (enum tag_types
);
82 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
83 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
84 static void maybe_deduce_size_from_array_init (tree
, tree
);
85 static void layout_var_decl (tree
);
86 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
87 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
88 static void save_function_data (tree
);
89 static void copy_type_enum (tree
, tree
);
90 static void check_function_type (tree
, tree
);
91 static void finish_constructor_body (void);
92 static void begin_destructor_body (void);
93 static void finish_destructor_body (void);
94 static void record_key_method_defined (tree
);
95 static tree
create_array_type_for_decl (tree
, tree
, tree
);
96 static tree
get_atexit_node (void);
97 static tree
get_dso_handle_node (void);
98 static tree
start_cleanup_fn (void);
99 static void end_cleanup_fn (void);
100 static tree
cp_make_fname_decl (location_t
, tree
, int);
101 static void initialize_predefined_identifiers (void);
102 static tree check_special_function_return_type
103 (special_function_kind
, tree
, tree
, int, const location_t
*);
104 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
105 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
106 static void store_parm_decls (tree
);
107 static void initialize_local_var (tree
, tree
);
108 static void expand_static_init (tree
, tree
);
110 /* The following symbols are subsumed in the cp_global_trees array, and
111 listed here individually for documentation purposes.
114 tree wchar_decl_node;
116 tree vtable_entry_type;
117 tree delta_type_node;
118 tree __t_desc_type_node;
120 tree class_type_node;
121 tree unknown_type_node;
123 Array type `vtable_entry_type[]'
126 tree vtbl_ptr_type_node;
133 A FUNCTION_DECL which can call `abort'. Not necessarily the
134 one that the user will declare, but sufficient to be called
135 by routines that want to abort the program.
140 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
141 tree tinfo_var_id; */
143 tree cp_global_trees
[CPTI_MAX
];
145 /* Indicates that there is a type value in some namespace, although
146 that is not necessarily in scope at the moment. */
148 tree global_type_node
;
150 /* The node that holds the "name" of the global scope. */
151 tree global_scope_name
;
153 #define local_names cp_function_chain->x_local_names
155 /* A list of objects which have constructors or destructors
156 which reside in the global scope. The decl is stored in
157 the TREE_VALUE slot and the initializer is stored
158 in the TREE_PURPOSE slot. */
159 tree static_aggregates
;
161 /* Like static_aggregates, but for thread_local variables. */
166 /* A node for the integer constant 2. */
168 tree integer_two_node
;
170 /* Used only for jumps to as-yet undefined labels, since jumps to
171 defined labels can have their validity checked immediately. */
173 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
174 struct named_label_use_entry
*next
;
175 /* The binding level to which this entry is *currently* attached.
176 This is initially the binding level in which the goto appeared,
177 but is modified as scopes are closed. */
178 cp_binding_level
*binding_level
;
179 /* The head of the names list that was current when the goto appeared,
180 or the inner scope popped. These are the decls that will *not* be
181 skipped when jumping to the label. */
183 /* The location of the goto, for error reporting. */
184 location_t o_goto_locus
;
185 /* True if an OpenMP structured block scope has been closed since
186 the goto appeared. This means that the branch from the label will
187 illegally exit an OpenMP scope. */
191 /* A list of all LABEL_DECLs in the function that have names. Here so
192 we can clear out their names' definitions at the end of the
193 function, and so we can check the validity of jumps to these labels. */
195 struct GTY((for_user
)) named_label_entry
{
196 /* The decl itself. */
199 /* The binding level to which the label is *currently* attached.
200 This is initially set to the binding level in which the label
201 is defined, but is modified as scopes are closed. */
202 cp_binding_level
*binding_level
;
203 /* The head of the names list that was current when the label was
204 defined, or the inner scope popped. These are the decls that will
205 be skipped when jumping to the label. */
207 /* A vector of all decls from all binding levels that would be
208 crossed by a backward branch to the label. */
209 vec
<tree
, va_gc
> *bad_decls
;
211 /* A list of uses of the label, before the label is defined. */
212 struct named_label_use_entry
*uses
;
214 /* The following bits are set after the label is defined, and are
215 updated as scopes are popped. They indicate that a backward jump
216 to the label will illegally enter a scope of the given flavor. */
220 bool in_transaction_scope
;
223 #define named_labels cp_function_chain->x_named_labels
225 /* The number of function bodies which we are currently processing.
226 (Zero if we are at namespace scope, one inside the body of a
227 function, two inside the body of a function in a local class, etc.) */
230 /* To avoid unwanted recursion, finish_function defers all mark_used calls
231 encountered during its execution until it finishes. */
232 bool defer_mark_used_calls
;
233 vec
<tree
, va_gc
> *deferred_mark_used_calls
;
235 /* States indicating how grokdeclarator() should handle declspecs marked
236 with __attribute__((deprecated)). An object declared as
237 __attribute__((deprecated)) suppresses warnings of uses of other
239 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
242 /* A list of VAR_DECLs whose type was incomplete at the time the
243 variable was declared. */
245 struct GTY(()) incomplete_var
{
247 tree incomplete_type
;
251 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
253 /* Returns the kind of template specialization we are currently
254 processing, given that it's declaration contained N_CLASS_SCOPES
255 explicit scope qualifications. */
258 current_tmpl_spec_kind (int n_class_scopes
)
260 int n_template_parm_scopes
= 0;
261 int seen_specialization_p
= 0;
262 int innermost_specialization_p
= 0;
265 /* Scan through the template parameter scopes. */
266 for (b
= current_binding_level
;
267 b
->kind
== sk_template_parms
;
270 /* If we see a specialization scope inside a parameter scope,
271 then something is wrong. That corresponds to a declaration
274 template <class T> template <> ...
276 which is always invalid since [temp.expl.spec] forbids the
277 specialization of a class member template if the enclosing
278 class templates are not explicitly specialized as well. */
279 if (b
->explicit_spec_p
)
281 if (n_template_parm_scopes
== 0)
282 innermost_specialization_p
= 1;
284 seen_specialization_p
= 1;
286 else if (seen_specialization_p
== 1)
287 return tsk_invalid_member_spec
;
289 ++n_template_parm_scopes
;
292 /* Handle explicit instantiations. */
293 if (processing_explicit_instantiation
)
295 if (n_template_parm_scopes
!= 0)
296 /* We've seen a template parameter list during an explicit
297 instantiation. For example:
299 template <class T> template void f(int);
301 This is erroneous. */
302 return tsk_invalid_expl_inst
;
304 return tsk_expl_inst
;
307 if (n_template_parm_scopes
< n_class_scopes
)
308 /* We've not seen enough template headers to match all the
309 specialized classes present. For example:
311 template <class T> void R<T>::S<T>::f(int);
313 This is invalid; there needs to be one set of template
314 parameters for each class. */
315 return tsk_insufficient_parms
;
316 else if (n_template_parm_scopes
== n_class_scopes
)
317 /* We're processing a non-template declaration (even though it may
318 be a member of a template class.) For example:
320 template <class T> void S<T>::f(int);
322 The `class T' matches the `S<T>', leaving no template headers
323 corresponding to the `f'. */
325 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
326 /* We've got too many template headers. For example:
328 template <> template <class T> void f (T);
330 There need to be more enclosing classes. */
331 return tsk_excessive_parms
;
333 /* This must be a template. It's of the form:
335 template <class T> template <class U> void S<T>::f(U);
337 This is a specialization if the innermost level was a
338 specialization; otherwise it's just a definition of the
340 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
343 /* Exit the current scope. */
351 /* When a label goes out of scope, check to see if that label was used
352 in a valid manner, and issue any appropriate warnings or errors. */
355 pop_label (tree label
, tree old_value
)
357 if (!processing_template_decl
)
359 if (DECL_INITIAL (label
) == NULL_TREE
)
363 error ("label %q+D used but not defined", label
);
364 location
= input_location
;
365 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
366 /* Avoid crashing later. */
367 define_label (location
, DECL_NAME (label
));
370 warn_for_unused_label (label
);
373 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
376 /* At the end of a function, all labels declared within the function
377 go out of scope. BLOCK is the top-level block for the
381 pop_labels_1 (named_label_entry
**slot
, tree block
)
383 struct named_label_entry
*ent
= *slot
;
385 pop_label (ent
->label_decl
, NULL_TREE
);
387 /* Put the labels into the "variables" of the top-level block,
388 so debugger can see them. */
389 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
390 BLOCK_VARS (block
) = ent
->label_decl
;
392 named_labels
->clear_slot (slot
);
398 pop_labels (tree block
)
402 named_labels
->traverse
<tree
, pop_labels_1
> (block
);
407 /* At the end of a block with local labels, restore the outer definition. */
410 pop_local_label (tree label
, tree old_value
)
412 struct named_label_entry dummy
;
414 pop_label (label
, old_value
);
416 dummy
.label_decl
= label
;
417 named_label_entry
**slot
= named_labels
->find_slot (&dummy
, NO_INSERT
);
418 named_labels
->clear_slot (slot
);
421 /* The following two routines are used to interface to Objective-C++.
422 The binding level is purposely treated as an opaque type. */
425 objc_get_current_scope (void)
427 return current_binding_level
;
430 /* The following routine is used by the NeXT-style SJLJ exceptions;
431 variables get marked 'volatile' so as to not be clobbered by
432 _setjmp()/_longjmp() calls. All variables in the current scope,
433 as well as parent scopes up to (but not including) ENCLOSING_BLK
434 shall be thusly marked. */
437 objc_mark_locals_volatile (void *enclosing_blk
)
439 cp_binding_level
*scope
;
441 for (scope
= current_binding_level
;
442 scope
&& scope
!= enclosing_blk
;
443 scope
= scope
->level_chain
)
447 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
448 objc_volatilize_decl (decl
);
450 /* Do not climb up past the current function. */
451 if (scope
->kind
== sk_function_parms
)
456 /* Update data for defined and undefined labels when leaving a scope. */
459 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
461 named_label_entry
*ent
= *slot
;
462 cp_binding_level
*obl
= bl
->level_chain
;
464 if (ent
->binding_level
== bl
)
468 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
469 TREE_LISTs representing OVERLOADs, so be careful. */
470 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
472 : TREE_CHAIN (decl
)))
473 if (decl_jump_unsafe (decl
))
474 vec_safe_push (ent
->bad_decls
, decl
);
476 ent
->binding_level
= obl
;
477 ent
->names_in_scope
= obl
->names
;
481 ent
->in_try_scope
= true;
484 ent
->in_catch_scope
= true;
487 ent
->in_omp_scope
= true;
490 ent
->in_transaction_scope
= true;
498 struct named_label_use_entry
*use
;
500 for (use
= ent
->uses
; use
; use
= use
->next
)
501 if (use
->binding_level
== bl
)
503 use
->binding_level
= obl
;
504 use
->names_in_scope
= obl
->names
;
505 if (bl
->kind
== sk_omp
)
506 use
->in_omp_scope
= true;
513 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
514 when errors were reported, except for -Werror-unused-but-set-*. */
515 static int unused_but_set_errorcount
;
517 /* Exit a binding level.
518 Pop the level off, and restore the state of the identifier-decl mappings
519 that were in effect when this level was entered.
521 If KEEP == 1, this level had explicit declarations, so
522 and create a "block" (a BLOCK node) for the level
523 to record its declarations and subblocks for symbol table output.
525 If FUNCTIONBODY is nonzero, this level is the body of a function,
526 so create a block as if KEEP were set and also clear out all
529 If REVERSE is nonzero, reverse the order of decls before putting
530 them into the BLOCK. */
533 poplevel (int keep
, int reverse
, int functionbody
)
536 /* The chain of decls was accumulated in reverse order.
537 Put it into forward order, just for cleanliness. */
542 int leaving_for_scope
;
545 cp_label_binding
*label_bind
;
547 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
552 gcc_assert (current_binding_level
->kind
!= sk_class
);
554 if (current_binding_level
->kind
== sk_cleanup
)
556 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
558 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
560 /* We used to use KEEP == 2 to indicate that the new block should go
561 at the beginning of the list of blocks at this binding level,
562 rather than the end. This hack is no longer used. */
563 gcc_assert (keep
== 0 || keep
== 1);
565 if (current_binding_level
->keep
)
568 /* Any uses of undefined labels, and any defined labels, now operate
569 under constraints of next binding contour. */
570 if (cfun
&& !functionbody
&& named_labels
)
571 named_labels
->traverse
<cp_binding_level
*, poplevel_named_label_1
>
572 (current_binding_level
);
574 /* Get the decls in the order they were written.
575 Usually current_binding_level->names is in reverse order.
576 But parameter decls were previously put in forward order. */
579 current_binding_level
->names
580 = decls
= nreverse (current_binding_level
->names
);
582 decls
= current_binding_level
->names
;
584 /* If there were any declarations or structure tags in that level,
585 or if this level is a function body,
586 create a BLOCK to record them for the life of this function. */
588 /* Avoid function body block if possible. */
589 if (functionbody
&& subblocks
&& BLOCK_CHAIN (subblocks
) == NULL_TREE
)
591 else if (keep
== 1 || functionbody
)
592 block
= make_node (BLOCK
);
593 if (block
!= NULL_TREE
)
595 BLOCK_VARS (block
) = decls
;
596 BLOCK_SUBBLOCKS (block
) = subblocks
;
599 /* In each subblock, record that this is its superior. */
601 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
602 BLOCK_SUPERCONTEXT (link
) = block
;
604 /* We still support the old for-scope rules, whereby the variables
605 in a for-init statement were in scope after the for-statement
606 ended. We only use the new rules if flag_new_for_scope is
609 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
611 /* Before we remove the declarations first check for unused variables. */
612 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
613 && current_binding_level
->kind
!= sk_template_parms
614 && !processing_template_decl
)
615 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
617 /* There are cases where D itself is a TREE_LIST. See in
618 push_local_binding where the list of decls returned by
619 getdecls is built. */
620 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
621 tree type
= TREE_TYPE (decl
);
623 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
624 && ! DECL_IN_SYSTEM_HEADER (decl
)
625 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
626 && type
!= error_mark_node
627 && (!CLASS_TYPE_P (type
)
628 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
629 || lookup_attribute ("warn_unused",
630 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
632 if (! TREE_USED (decl
))
633 warning_at (DECL_SOURCE_LOCATION (decl
),
634 OPT_Wunused_variable
, "unused variable %qD", decl
);
635 else if (DECL_CONTEXT (decl
) == current_function_decl
636 // For -Wunused-but-set-variable leave references alone.
637 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
638 && errorcount
== unused_but_set_errorcount
)
640 warning_at (DECL_SOURCE_LOCATION (decl
),
641 OPT_Wunused_but_set_variable
,
642 "variable %qD set but not used", decl
);
643 unused_but_set_errorcount
= errorcount
;
648 /* Remove declarations for all the DECLs in this level. */
649 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
651 if (leaving_for_scope
&& VAR_P (link
)
652 /* It's hard to make this ARM compatibility hack play nicely with
653 lambdas, and it really isn't necessary in C++11 mode. */
654 && cxx_dialect
< cxx11
657 tree name
= DECL_NAME (link
);
661 ob
= outer_binding (name
,
662 IDENTIFIER_BINDING (name
),
665 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
667 ns_binding
= NULL_TREE
;
669 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
670 /* We have something like:
675 and we are leaving the `for' scope. There's no reason to
676 keep the binding of the inner `i' in this case. */
677 pop_binding (name
, link
);
678 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
679 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
680 /* Here, we have something like:
688 We must pop the for-scope binding so we know what's a
689 type and what isn't. */
690 pop_binding (name
, link
);
693 /* Mark this VAR_DECL as dead so that we can tell we left it
694 there only for backward compatibility. */
695 DECL_DEAD_FOR_LOCAL (link
) = 1;
697 /* Keep track of what should have happened when we
698 popped the binding. */
701 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
702 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
705 /* Add it to the list of dead variables in the next
706 outermost binding to that we can remove these when we
707 leave that binding. */
709 current_binding_level
->level_chain
->dead_vars_from_for
,
712 /* Although we don't pop the cxx_binding, we do clear
713 its SCOPE since the scope is going away now. */
714 IDENTIFIER_BINDING (name
)->scope
715 = current_binding_level
->level_chain
;
722 /* Remove the binding. */
725 if (TREE_CODE (decl
) == TREE_LIST
)
726 decl
= TREE_VALUE (decl
);
729 if (TREE_CODE (name
) == OVERLOAD
)
730 name
= OVL_FUNCTION (name
);
732 gcc_assert (DECL_P (name
));
733 pop_binding (DECL_NAME (name
), decl
);
737 /* Remove declarations for any `for' variables from inner scopes
738 that we kept around. */
739 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
741 pop_binding (DECL_NAME (decl
), decl
);
743 /* Restore the IDENTIFIER_TYPE_VALUEs. */
744 for (link
= current_binding_level
->type_shadowed
;
745 link
; link
= TREE_CHAIN (link
))
746 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
748 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
749 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
751 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
753 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
754 list if a `using' declaration put them there. The debugging
755 back ends won't understand OVERLOAD, so we remove them here.
756 Because the BLOCK_VARS are (temporarily) shared with
757 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
758 popped all the bindings. */
763 for (d
= &BLOCK_VARS (block
); *d
; )
765 if (TREE_CODE (*d
) == TREE_LIST
)
766 *d
= TREE_CHAIN (*d
);
768 d
= &DECL_CHAIN (*d
);
772 /* If the level being exited is the top level of a function,
773 check over all the labels. */
778 /* Since this is the top level block of a function, the vars are
779 the function's parameters. Don't leave them in the BLOCK
780 because they are found in the FUNCTION_DECL instead. */
781 BLOCK_VARS (block
) = 0;
785 pop_labels (subblocks
);
788 kind
= current_binding_level
->kind
;
789 if (kind
== sk_cleanup
)
793 /* If this is a temporary binding created for a cleanup, then we'll
794 have pushed a statement list level. Pop that, create a new
795 BIND_EXPR for the block, and insert it into the stream. */
796 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
797 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
804 /* The current function is being defined, so its DECL_INITIAL
805 should be error_mark_node. */
806 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
807 DECL_INITIAL (current_function_decl
) = block
? block
: subblocks
;
810 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
812 if (BLOCK_SUBBLOCKS (subblocks
))
813 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks
)) = 1;
816 BLOCK_OUTER_CURLY_BRACE_P (subblocks
) = 1;
820 current_binding_level
->blocks
821 = block_chainon (current_binding_level
->blocks
, block
);
823 /* If we did not make a block for the level just exited,
824 any blocks made for inner levels
825 (since they cannot be recorded as subblocks in that level)
826 must be carried forward so they will later become subblocks
827 of something else. */
829 current_binding_level
->blocks
830 = block_chainon (current_binding_level
->blocks
, subblocks
);
832 /* Each and every BLOCK node created here in `poplevel' is important
833 (e.g. for proper debugging information) so if we created one
834 earlier, mark it as "used". */
836 TREE_USED (block
) = 1;
838 /* All temporary bindings created for cleanups are popped silently. */
839 if (kind
== sk_cleanup
)
842 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
846 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
847 itself, calling F for each. The DATA is passed to F as well. */
850 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
853 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
855 result
|= (*f
) (name_space
, data
);
857 for (; current
; current
= DECL_CHAIN (current
))
858 result
|= walk_namespaces_r (current
, f
, data
);
863 /* Walk all the namespaces, calling F for each. The DATA is passed to
867 walk_namespaces (walk_namespaces_fn f
, void* data
)
869 return walk_namespaces_r (global_namespace
, f
, data
);
872 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
875 wrapup_globals_for_namespace (tree name_space
, void* data ATTRIBUTE_UNUSED
)
877 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
878 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
879 tree
*vec
= statics
->address ();
880 int len
= statics
->length ();
882 /* Write out any globals that need to be output. */
883 return wrapup_global_declarations (vec
, len
);
886 /* In C++, you don't have to write `struct S' to refer to `S'; you
887 can just use `S'. We accomplish this by creating a TYPE_DECL as
888 if the user had written `typedef struct S S'. Create and return
889 the TYPE_DECL for TYPE. */
892 create_implicit_typedef (tree name
, tree type
)
896 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
897 DECL_ARTIFICIAL (decl
) = 1;
898 /* There are other implicit type declarations, like the one *within*
899 a class that allows you to write `S::S'. We must distinguish
901 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
902 TYPE_NAME (type
) = decl
;
903 TYPE_STUB_DECL (type
) = decl
;
908 /* Remember a local name for name-mangling purposes. */
911 push_local_name (tree decl
)
916 timevar_start (TV_NAME_LOOKUP
);
918 name
= DECL_NAME (decl
);
920 nelts
= vec_safe_length (local_names
);
921 for (i
= 0; i
< nelts
; i
++)
923 t
= (*local_names
)[i
];
924 if (DECL_NAME (t
) == name
)
926 if (!DECL_LANG_SPECIFIC (decl
))
927 retrofit_lang_decl (decl
);
928 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
929 if (DECL_DISCRIMINATOR_SET_P (t
))
930 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
932 DECL_DISCRIMINATOR (decl
) = 1;
934 (*local_names
)[i
] = decl
;
935 timevar_stop (TV_NAME_LOOKUP
);
940 vec_safe_push (local_names
, decl
);
941 timevar_stop (TV_NAME_LOOKUP
);
944 /* Subroutine of duplicate_decls: return truthvalue of whether
945 or not types of these decls match.
947 For C++, we must compare the parameter list so that `int' can match
948 `int&' in a parameter position, but `int&' is not confused with
952 decls_match (tree newdecl
, tree olddecl
)
956 if (newdecl
== olddecl
)
959 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
960 /* If the two DECLs are not even the same kind of thing, we're not
961 interested in their types. */
964 gcc_assert (DECL_P (newdecl
));
966 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
968 tree f1
= TREE_TYPE (newdecl
);
969 tree f2
= TREE_TYPE (olddecl
);
970 tree p1
= TYPE_ARG_TYPES (f1
);
971 tree p2
= TYPE_ARG_TYPES (f2
);
974 /* Specializations of different templates are different functions
975 even if they have the same type. */
976 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
977 ? DECL_TI_TEMPLATE (newdecl
)
979 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
980 ? DECL_TI_TEMPLATE (olddecl
)
985 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
986 && ! (DECL_EXTERN_C_P (newdecl
)
987 && DECL_EXTERN_C_P (olddecl
)))
990 /* A new declaration doesn't match a built-in one unless it
991 is also extern "C". */
992 if (DECL_IS_BUILTIN (olddecl
)
993 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
996 if (TREE_CODE (f1
) != TREE_CODE (f2
))
999 /* A declaration with deduced return type should use its pre-deduction
1000 type for declaration matching. */
1001 r2
= fndecl_declared_return_type (olddecl
);
1003 if (same_type_p (TREE_TYPE (f1
), r2
))
1005 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1006 && (DECL_BUILT_IN (olddecl
)
1007 #ifndef NO_IMPLICIT_EXTERN_C
1008 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1009 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1013 types_match
= self_promoting_args_p (p1
);
1014 if (p1
== void_list_node
)
1015 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1017 #ifndef NO_IMPLICIT_EXTERN_C
1018 else if (!prototype_p (f1
)
1019 && (DECL_EXTERN_C_P (olddecl
)
1020 && DECL_IN_SYSTEM_HEADER (olddecl
)
1021 && !DECL_CLASS_SCOPE_P (olddecl
))
1022 && (DECL_EXTERN_C_P (newdecl
)
1023 && DECL_IN_SYSTEM_HEADER (newdecl
)
1024 && !DECL_CLASS_SCOPE_P (newdecl
)))
1026 types_match
= self_promoting_args_p (p2
);
1027 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1033 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1034 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1035 || comp_type_attributes (TREE_TYPE (newdecl
),
1036 TREE_TYPE (olddecl
)) != 0);
1041 /* The decls dont match if they correspond to two different versions
1042 of the same function. Disallow extern "C" functions to be
1043 versions for now. */
1045 && !DECL_EXTERN_C_P (newdecl
)
1046 && !DECL_EXTERN_C_P (olddecl
)
1047 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1049 /* Mark functions as versions if necessary. Modify the mangled decl
1050 name if necessary. */
1051 if (DECL_FUNCTION_VERSIONED (newdecl
)
1052 && DECL_FUNCTION_VERSIONED (olddecl
))
1054 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1056 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1057 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1058 mangle_decl (newdecl
);
1060 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1062 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1063 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1064 mangle_decl (olddecl
);
1066 cgraph_node::record_function_versions (olddecl
, newdecl
);
1070 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1072 tree oldres
= DECL_TEMPLATE_RESULT (olddecl
);
1073 tree newres
= DECL_TEMPLATE_RESULT (newdecl
);
1075 if (TREE_CODE (newres
) != TREE_CODE (oldres
))
1078 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1079 DECL_TEMPLATE_PARMS (olddecl
)))
1082 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1083 types_match
= (same_type_p (TREE_TYPE (oldres
), TREE_TYPE (newres
))
1084 && equivalently_constrained (olddecl
, newdecl
));
1086 // We don't need to check equivalently_constrained for variable and
1087 // function templates because we check it on the results.
1088 types_match
= decls_match (oldres
, newres
);
1092 /* Need to check scope for variable declaration (VAR_DECL).
1093 For typedef (TYPE_DECL), scope is ignored. */
1095 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1097 Two declarations for an object with C language linkage
1098 with the same name (ignoring the namespace that qualify
1099 it) that appear in different namespace scopes refer to
1101 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1104 if (TREE_TYPE (newdecl
) == error_mark_node
)
1105 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1106 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1107 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1108 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1111 types_match
= comptypes (TREE_TYPE (newdecl
),
1112 TREE_TYPE (olddecl
),
1113 COMPARE_REDECLARATION
);
1116 // Normal functions can be constrained, as can variable partial
1118 if (types_match
&& VAR_OR_FUNCTION_DECL_P (newdecl
))
1119 types_match
= equivalently_constrained (newdecl
, olddecl
);
1124 /* If NEWDECL is `static' and an `extern' was seen previously,
1125 warn about it. OLDDECL is the previous declaration.
1127 Note that this does not apply to the C++ case of declaring
1128 a variable `extern const' and then later `const'.
1130 Don't complain about built-in functions, since they are beyond
1131 the user's control. */
1134 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1136 if (TREE_CODE (newdecl
) == TYPE_DECL
1137 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1138 || TREE_CODE (newdecl
) == CONST_DECL
1139 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1142 /* Don't get confused by static member functions; that's a different
1144 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1145 && DECL_STATIC_FUNCTION_P (newdecl
))
1148 /* If the old declaration was `static', or the new one isn't, then
1149 everything is OK. */
1150 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1153 /* It's OK to declare a builtin function as `static'. */
1154 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1155 && DECL_ARTIFICIAL (olddecl
))
1158 if (permerror (DECL_SOURCE_LOCATION (newdecl
),
1159 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1160 inform (DECL_SOURCE_LOCATION (olddecl
),
1161 "previous declaration of %qD", olddecl
);
1164 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1165 function templates. If their exception specifications do not
1166 match, issue a diagnostic. */
1169 check_redeclaration_exception_specification (tree new_decl
,
1172 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1173 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1175 /* Two default specs are equivalent, don't force evaluation. */
1176 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1177 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1180 maybe_instantiate_noexcept (new_decl
);
1181 maybe_instantiate_noexcept (old_decl
);
1182 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1183 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1187 If any declaration of a function has an exception-specification,
1188 all declarations, including the definition and an explicit
1189 specialization, of that function shall have an
1190 exception-specification with the same set of type-ids. */
1191 if (! DECL_IS_BUILTIN (old_decl
)
1193 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1196 = "declaration of %q+F has a different exception specifier";
1197 bool complained
= true;
1198 if (! DECL_IN_SYSTEM_HEADER (old_decl
))
1199 error (msg
, new_decl
);
1201 complained
= pedwarn (0, OPT_Wsystem_headers
, msg
, new_decl
);
1203 inform (0, "from previous declaration %q+F", old_decl
);
1207 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1208 Otherwise issue diagnostics. */
1211 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1213 old_decl
= STRIP_TEMPLATE (old_decl
);
1214 new_decl
= STRIP_TEMPLATE (new_decl
);
1215 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1216 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1218 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1219 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1221 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1223 if (DECL_BUILT_IN (old_decl
))
1225 /* Hide a built-in declaration. */
1226 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1227 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1230 /* 7.1.5 [dcl.constexpr]
1231 Note: An explicit specialization can differ from the template
1232 declaration with respect to the constexpr specifier. */
1233 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1234 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1237 error ("redeclaration %q+D differs in %<constexpr%>", new_decl
);
1238 error ("from previous declaration %q+D", old_decl
);
1244 // If OLDDECL and NEWDECL are concept declarations with the same type
1245 // (i.e., and template parameters), but different requirements,
1246 // emit diagnostics and return true. Otherwise, return false.
1248 check_concept_refinement (tree olddecl
, tree newdecl
)
1250 if (!DECL_DECLARED_CONCEPT_P (olddecl
) || !DECL_DECLARED_CONCEPT_P (newdecl
))
1253 tree d1
= DECL_TEMPLATE_RESULT (olddecl
);
1254 tree d2
= DECL_TEMPLATE_RESULT (newdecl
);
1255 if (TREE_CODE (d1
) != TREE_CODE (d2
))
1258 tree t1
= TREE_TYPE (d1
);
1259 tree t2
= TREE_TYPE (d2
);
1260 if (TREE_CODE (d1
) == FUNCTION_DECL
)
1262 if (compparms (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
))
1263 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl
),
1264 DECL_TEMPLATE_PARMS (newdecl
))
1265 && !equivalently_constrained (olddecl
, newdecl
))
1267 error ("cannot specialize concept %q#D", olddecl
);
1274 /* DECL is a redeclaration of a function or function template. If
1275 it does have default arguments issue a diagnostic. Note: this
1276 function is used to enforce the requirements in C++11 8.3.6 about
1277 no default arguments in redeclarations. */
1280 check_redeclaration_no_default_args (tree decl
)
1282 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1284 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1285 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1286 if (TREE_PURPOSE (t
))
1288 permerror (DECL_SOURCE_LOCATION (decl
),
1289 "redeclaration of %q#D may not have default "
1295 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1296 && lookup_attribute ("gnu_inline", \
1297 DECL_ATTRIBUTES (fn)))
1299 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1300 If the redeclaration is invalid, a diagnostic is issued, and the
1301 error_mark_node is returned. Otherwise, OLDDECL is returned.
1303 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1306 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1309 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1311 unsigned olddecl_uid
= DECL_UID (olddecl
);
1312 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1313 int new_defines_function
= 0;
1314 tree new_template_info
;
1316 if (newdecl
== olddecl
)
1319 types_match
= decls_match (newdecl
, olddecl
);
1321 /* If either the type of the new decl or the type of the old decl is an
1322 error_mark_node, then that implies that we have already issued an
1323 error (earlier) for some bogus type specification, and in that case,
1324 it is rather pointless to harass the user with yet more error message
1325 about the same declaration, so just pretend the types match here. */
1326 if (TREE_TYPE (newdecl
) == error_mark_node
1327 || TREE_TYPE (olddecl
) == error_mark_node
)
1328 return error_mark_node
;
1330 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1331 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1333 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1334 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1335 && check_raw_literal_operator (olddecl
))
1336 error ("literal operator template %q+D conflicts with"
1337 " raw literal operator %qD", newdecl
, olddecl
);
1338 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1339 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1340 && check_raw_literal_operator (newdecl
))
1341 error ("raw literal operator %q+D conflicts with"
1342 " literal operator template %qD", newdecl
, olddecl
);
1345 if (DECL_P (olddecl
)
1346 && TREE_CODE (newdecl
) == FUNCTION_DECL
1347 && TREE_CODE (olddecl
) == FUNCTION_DECL
1348 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1350 if (DECL_DECLARED_INLINE_P (newdecl
)
1351 && DECL_UNINLINABLE (newdecl
)
1352 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1353 /* Already warned elsewhere. */;
1354 else if (DECL_DECLARED_INLINE_P (olddecl
)
1355 && DECL_UNINLINABLE (olddecl
)
1356 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1357 /* Already warned. */;
1358 else if (DECL_DECLARED_INLINE_P (newdecl
)
1359 && DECL_UNINLINABLE (olddecl
)
1360 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1362 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1363 OPT_Wattributes
, "function %qD redeclared as inline",
1365 inform (DECL_SOURCE_LOCATION (olddecl
),
1366 "previous declaration of %qD with attribute noinline",
1369 else if (DECL_DECLARED_INLINE_P (olddecl
)
1370 && DECL_UNINLINABLE (newdecl
)
1371 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1373 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1374 OPT_Wattributes
, "function %qD redeclared with "
1375 "attribute noinline", newdecl
))
1376 inform (DECL_SOURCE_LOCATION (olddecl
),
1377 "previous declaration of %qD was inline",
1382 /* Check for redeclaration and other discrepancies. */
1383 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1384 && DECL_ARTIFICIAL (olddecl
))
1386 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1387 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1389 /* Avoid warnings redeclaring built-ins which have not been
1390 explicitly declared. */
1391 if (DECL_ANTICIPATED (olddecl
))
1394 /* If you declare a built-in or predefined function name as static,
1395 the old definition is overridden, but optionally warn this was a
1396 bad choice of name. */
1397 if (! TREE_PUBLIC (newdecl
))
1399 warning (OPT_Wshadow
,
1400 DECL_BUILT_IN (olddecl
)
1401 ? G_("shadowing built-in function %q#D")
1402 : G_("shadowing library function %q#D"), olddecl
);
1403 /* Discard the old built-in function. */
1406 /* If the built-in is not ansi, then programs can override
1407 it even globally without an error. */
1408 else if (! DECL_BUILT_IN (olddecl
))
1409 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1410 "library function %q#D redeclared as non-function %q#D",
1413 error ("declaration of %q+#D conflicts with built-in "
1414 "declaration %q#D", newdecl
, olddecl
);
1417 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1419 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1420 error_at (DECL_SOURCE_LOCATION (newdecl
),
1421 "redeclaration of %<pragma omp declare reduction%>");
1422 inform (DECL_SOURCE_LOCATION (olddecl
),
1423 "previous %<pragma omp declare reduction%> declaration");
1424 return error_mark_node
;
1426 else if (!types_match
)
1428 /* Avoid warnings redeclaring built-ins which have not been
1429 explicitly declared. */
1430 if (DECL_ANTICIPATED (olddecl
))
1432 /* Deal with fileptr_type_node. FILE type is not known
1433 at the time we create the builtins. */
1436 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1437 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1439 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1442 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1444 tree t
= TREE_VALUE (t1
);
1447 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1448 == get_identifier ("FILE")
1449 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1451 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1453 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1454 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1455 types_match
= decls_match (newdecl
, olddecl
);
1457 return duplicate_decls (newdecl
, olddecl
,
1459 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1462 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1465 else if ((DECL_EXTERN_C_P (newdecl
)
1466 && DECL_EXTERN_C_P (olddecl
))
1467 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1468 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1470 /* A near match; override the builtin. */
1472 if (TREE_PUBLIC (newdecl
))
1473 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1474 "new declaration %q#D ambiguates built-in "
1475 "declaration %q#D", newdecl
, olddecl
);
1477 warning (OPT_Wshadow
,
1478 DECL_BUILT_IN (olddecl
)
1479 ? G_("shadowing built-in function %q#D")
1480 : G_("shadowing library function %q#D"), olddecl
);
1483 /* Discard the old built-in function. */
1486 /* Replace the old RTL to avoid problems with inlining. */
1487 COPY_DECL_RTL (newdecl
, olddecl
);
1489 /* Even if the types match, prefer the new declarations type for
1490 built-ins which have not been explicitly declared, for
1491 exception lists, etc... */
1492 else if (DECL_IS_BUILTIN (olddecl
))
1494 tree type
= TREE_TYPE (newdecl
);
1495 tree attribs
= (*targetm
.merge_type_attributes
)
1496 (TREE_TYPE (olddecl
), type
);
1498 type
= cp_build_type_attribute_variant (type
, attribs
);
1499 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1502 /* If a function is explicitly declared "throw ()", propagate that to
1503 the corresponding builtin. */
1504 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1505 && DECL_ANTICIPATED (olddecl
)
1506 && TREE_NOTHROW (newdecl
)
1507 && !TREE_NOTHROW (olddecl
))
1509 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1510 tree tmpdecl
= builtin_decl_explicit (fncode
);
1511 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1512 TREE_NOTHROW (tmpdecl
) = 1;
1515 /* Whether or not the builtin can throw exceptions has no
1516 bearing on this declarator. */
1517 TREE_NOTHROW (olddecl
) = 0;
1519 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1521 /* If a builtin function is redeclared as `static', merge
1522 the declarations, but make the original one static. */
1523 DECL_THIS_STATIC (olddecl
) = 1;
1524 TREE_PUBLIC (olddecl
) = 0;
1526 /* Make the old declaration consistent with the new one so
1527 that all remnants of the builtin-ness of this function
1528 will be banished. */
1529 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1530 COPY_DECL_RTL (newdecl
, olddecl
);
1533 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1535 /* C++ Standard, 3.3, clause 4:
1536 "[Note: a namespace name or a class template name must be unique
1537 in its declarative region (7.3.2, clause 14). ]" */
1538 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1539 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1540 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1541 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1542 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1543 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1545 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1546 && TREE_CODE (newdecl
) != TYPE_DECL
)
1547 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1548 && TREE_CODE (olddecl
) != TYPE_DECL
))
1550 /* We do nothing special here, because C++ does such nasty
1551 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1552 get shadowed, and know that if we need to find a TYPE_DECL
1553 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1554 slot of the identifier. */
1558 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1559 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1560 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1561 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1565 error ("%q#D redeclared as different kind of symbol", newdecl
);
1566 if (TREE_CODE (olddecl
) == TREE_LIST
)
1567 olddecl
= TREE_VALUE (olddecl
);
1568 inform (DECL_SOURCE_LOCATION (olddecl
),
1569 "previous declaration %q#D", olddecl
);
1571 return error_mark_node
;
1573 else if (!types_match
)
1575 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1576 /* These are certainly not duplicate declarations; they're
1577 from different scopes. */
1580 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1582 /* The name of a class template may not be declared to refer to
1583 any other template, class, function, object, namespace, value,
1584 or type in the same scope. */
1585 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1586 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1588 error ("conflicting declaration of template %q+#D", newdecl
);
1589 inform (DECL_SOURCE_LOCATION (olddecl
),
1590 "previous declaration %q#D", olddecl
);
1591 return error_mark_node
;
1593 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1594 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1595 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1596 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1597 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1598 DECL_TEMPLATE_PARMS (olddecl
))
1599 /* Template functions can be disambiguated by
1601 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1602 TREE_TYPE (TREE_TYPE (olddecl
)))
1603 // Template functions can also be disambiguated by
1605 && equivalently_constrained (olddecl
, newdecl
))
1607 error ("ambiguating new declaration %q+#D", newdecl
);
1608 inform (DECL_SOURCE_LOCATION (olddecl
),
1609 "old declaration %q#D", olddecl
);
1611 else if (check_concept_refinement (olddecl
, newdecl
))
1612 return error_mark_node
;
1615 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1617 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1619 error ("conflicting declaration of C function %q+#D",
1621 inform (DECL_SOURCE_LOCATION (olddecl
),
1622 "previous declaration %q#D", olddecl
);
1625 /* For function versions, params and types match, but they
1626 are not ambiguous. */
1627 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1628 && !DECL_FUNCTION_VERSIONED (olddecl
))
1629 // The functions have the same parameter types.
1630 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1631 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)))
1632 // And the same constraints.
1633 && equivalently_constrained (newdecl
, olddecl
))
1635 error ("ambiguating new declaration of %q+#D", newdecl
);
1636 inform (DECL_SOURCE_LOCATION (olddecl
),
1637 "old declaration %q#D", olddecl
);
1638 return error_mark_node
;
1645 error ("conflicting declaration %q+#D", newdecl
);
1646 inform (DECL_SOURCE_LOCATION (olddecl
),
1647 "previous declaration as %q#D", olddecl
);
1648 return error_mark_node
;
1651 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1652 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1653 && (!DECL_TEMPLATE_INFO (newdecl
)
1654 || (DECL_TI_TEMPLATE (newdecl
)
1655 != DECL_TI_TEMPLATE (olddecl
))))
1656 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1657 && (!DECL_TEMPLATE_INFO (olddecl
)
1658 || (DECL_TI_TEMPLATE (olddecl
)
1659 != DECL_TI_TEMPLATE (newdecl
))))))
1660 /* It's OK to have a template specialization and a non-template
1661 with the same type, or to have specializations of two
1662 different templates with the same type. Note that if one is a
1663 specialization, and the other is an instantiation of the same
1664 template, that we do not exit at this point. That situation
1665 can occur if we instantiate a template class, and then
1666 specialize one of its methods. This situation is valid, but
1667 the declarations must be merged in the usual way. */
1669 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1670 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1671 && !DECL_USE_TEMPLATE (newdecl
))
1672 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1673 && !DECL_USE_TEMPLATE (olddecl
))))
1674 /* One of the declarations is a template instantiation, and the
1675 other is not a template at all. That's OK. */
1677 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1679 /* In [namespace.alias] we have:
1681 In a declarative region, a namespace-alias-definition can be
1682 used to redefine a namespace-alias declared in that declarative
1683 region to refer only to the namespace to which it already
1686 Therefore, if we encounter a second alias directive for the same
1687 alias, we can just ignore the second directive. */
1688 if (DECL_NAMESPACE_ALIAS (newdecl
)
1689 && (DECL_NAMESPACE_ALIAS (newdecl
)
1690 == DECL_NAMESPACE_ALIAS (olddecl
)))
1692 /* [namespace.alias]
1694 A namespace-name or namespace-alias shall not be declared as
1695 the name of any other entity in the same declarative region.
1696 A namespace-name defined at global scope shall not be
1697 declared as the name of any other entity in any global scope
1699 error ("conflicting declaration of namespace %q+D", newdecl
);
1700 inform (DECL_SOURCE_LOCATION (olddecl
),
1701 "previous declaration of namespace %qD here", olddecl
);
1702 return error_mark_node
;
1706 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1709 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1710 if (DECL_NAME (olddecl
) != NULL_TREE
)
1711 inform (DECL_SOURCE_LOCATION (olddecl
),
1712 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1713 ? G_("%q#D previously defined here")
1714 : G_("%q#D previously declared here"), olddecl
);
1715 return error_mark_node
;
1717 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1718 && DECL_INITIAL (olddecl
) != NULL_TREE
1719 && !prototype_p (TREE_TYPE (olddecl
))
1720 && prototype_p (TREE_TYPE (newdecl
)))
1722 /* Prototype decl follows defn w/o prototype. */
1723 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1724 "prototype specified for %q#D", newdecl
))
1725 inform (DECL_SOURCE_LOCATION (olddecl
),
1726 "previous non-prototype definition here");
1728 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1729 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1732 If two declarations of the same function or object
1733 specify different linkage-specifications ..., the program
1734 is ill-formed.... Except for functions with C++ linkage,
1735 a function declaration without a linkage specification
1736 shall not precede the first linkage specification for
1737 that function. A function can be declared without a
1738 linkage specification after an explicit linkage
1739 specification has been seen; the linkage explicitly
1740 specified in the earlier declaration is not affected by
1741 such a function declaration.
1743 DR 563 raises the question why the restrictions on
1744 functions should not also apply to objects. Older
1745 versions of G++ silently ignore the linkage-specification
1753 which is clearly wrong. Therefore, we now treat objects
1755 if (current_lang_depth () == 0)
1757 /* There is no explicit linkage-specification, so we use
1758 the linkage from the previous declaration. */
1759 if (!DECL_LANG_SPECIFIC (newdecl
))
1760 retrofit_lang_decl (newdecl
);
1761 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1765 error ("conflicting declaration of %q+#D with %qL linkage",
1766 newdecl
, DECL_LANGUAGE (newdecl
));
1767 inform (DECL_SOURCE_LOCATION (olddecl
),
1768 "previous declaration with %qL linkage",
1769 DECL_LANGUAGE (olddecl
));
1773 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1775 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1777 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1778 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1779 && (/* grokfndecl passes member function templates too
1780 as FUNCTION_DECLs. */
1781 DECL_TEMPLATE_INFO (olddecl
)
1783 Default arguments for a member function of a class
1784 template shall be specified on the initial declaration
1785 of the member function within the class template. */
1786 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1787 check_redeclaration_no_default_args (newdecl
);
1790 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1791 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1794 for (; t1
&& t1
!= void_list_node
;
1795 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1796 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1798 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1801 if (permerror (input_location
,
1802 "default argument given for parameter "
1803 "%d of %q#D", i
, newdecl
))
1804 inform (DECL_SOURCE_LOCATION (olddecl
),
1805 "previous specification in %q#D here",
1810 error ("default argument given for parameter %d "
1811 "of %q#D", i
, newdecl
);
1812 inform (DECL_SOURCE_LOCATION (olddecl
),
1813 "previous specification in %q#D here",
1821 /* Do not merge an implicit typedef with an explicit one. In:
1825 typedef class A A __attribute__ ((foo));
1827 the attribute should apply only to the typedef. */
1828 if (TREE_CODE (olddecl
) == TYPE_DECL
1829 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1830 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1833 /* If new decl is `static' and an `extern' was seen previously,
1835 warn_extern_redeclared_static (newdecl
, olddecl
);
1837 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1838 return error_mark_node
;
1840 /* We have committed to returning 1 at this point. */
1841 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1843 /* Now that functions must hold information normally held
1844 by field decls, there is extra work to do so that
1845 declaration information does not get destroyed during
1847 if (DECL_VINDEX (olddecl
))
1848 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1849 if (DECL_CONTEXT (olddecl
))
1850 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1851 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1852 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1853 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1854 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1855 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1856 DECL_FINAL_P (newdecl
) |= DECL_FINAL_P (olddecl
);
1857 DECL_OVERRIDE_P (newdecl
) |= DECL_OVERRIDE_P (olddecl
);
1858 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1859 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1860 SET_OVERLOADED_OPERATOR_CODE
1861 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1862 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1864 /* Optionally warn about more than one declaration for the same
1865 name, but don't warn about a function declaration followed by a
1867 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1868 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1869 /* Don't warn about extern decl followed by definition. */
1870 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1871 /* Don't warn about friends, let add_friend take care of it. */
1872 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1873 /* Don't warn about declaration followed by specialization. */
1874 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1875 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1877 if (warning_at (DECL_SOURCE_LOCATION (newdecl
),
1878 OPT_Wredundant_decls
,
1879 "redundant redeclaration of %qD in same scope",
1881 inform (DECL_SOURCE_LOCATION (olddecl
),
1882 "previous declaration of %qD", olddecl
);
1885 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1886 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1888 if (DECL_DELETED_FN (newdecl
))
1890 error ("deleted definition of %q+D", newdecl
);
1891 inform (DECL_SOURCE_LOCATION (olddecl
),
1892 "previous declaration of %qD", olddecl
);
1894 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1898 /* Deal with C++: must preserve virtual function table size. */
1899 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1901 tree newtype
= TREE_TYPE (newdecl
);
1902 tree oldtype
= TREE_TYPE (olddecl
);
1904 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1905 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1906 CLASSTYPE_FRIEND_CLASSES (newtype
)
1907 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1909 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1912 /* Copy all the DECL_... slots specified in the new decl
1913 except for any that we copy here from the old type. */
1914 DECL_ATTRIBUTES (newdecl
)
1915 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1917 if (DECL_DECLARES_FUNCTION_P (olddecl
) && DECL_DECLARES_FUNCTION_P (newdecl
))
1919 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1920 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1921 && DECL_HIDDEN_FRIEND_P (olddecl
)
1922 && newdecl_is_friend
);
1925 DECL_ANTICIPATED (olddecl
) = 0;
1926 DECL_HIDDEN_FRIEND_P (olddecl
) = 0;
1930 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1934 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1935 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1936 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1937 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1938 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1939 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1941 DECL_ATTRIBUTES (old_result
)
1942 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1944 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1946 /* Per C++11 8.3.6/4, default arguments cannot be added in later
1947 declarations of a function template. */
1948 if (DECL_SOURCE_LOCATION (newdecl
)
1949 != DECL_SOURCE_LOCATION (olddecl
))
1950 check_redeclaration_no_default_args (newdecl
);
1952 check_default_args (newdecl
);
1954 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1955 && DECL_INITIAL (new_result
))
1957 if (DECL_INITIAL (old_result
))
1958 DECL_UNINLINABLE (old_result
) = 1;
1960 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1961 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1962 DECL_NOT_REALLY_EXTERN (old_result
)
1963 = DECL_NOT_REALLY_EXTERN (new_result
);
1964 DECL_INTERFACE_KNOWN (old_result
)
1965 = DECL_INTERFACE_KNOWN (new_result
);
1966 DECL_DECLARED_INLINE_P (old_result
)
1967 = DECL_DECLARED_INLINE_P (new_result
);
1968 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1969 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1974 DECL_DECLARED_INLINE_P (old_result
)
1975 |= DECL_DECLARED_INLINE_P (new_result
);
1976 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1977 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1978 check_redeclaration_exception_specification (newdecl
, olddecl
);
1982 /* If the new declaration is a definition, update the file and
1983 line information on the declaration, and also make
1984 the old declaration the same definition. */
1985 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1987 DECL_SOURCE_LOCATION (olddecl
)
1988 = DECL_SOURCE_LOCATION (old_result
)
1989 = DECL_SOURCE_LOCATION (newdecl
);
1990 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1991 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1994 DECL_ARGUMENTS (old_result
)
1995 = DECL_ARGUMENTS (new_result
);
1996 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1997 parm
= DECL_CHAIN (parm
))
1998 DECL_CONTEXT (parm
) = old_result
;
2007 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2008 check_redeclaration_exception_specification (newdecl
, olddecl
);
2010 /* Automatically handles default parameters. */
2011 tree oldtype
= TREE_TYPE (olddecl
);
2014 /* For typedefs use the old type, as the new type's DECL_NAME points
2015 at newdecl, which will be ggc_freed. */
2016 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2020 /* And remove the new type from the variants list. */
2021 if (TYPE_NAME (TREE_TYPE (newdecl
)) == newdecl
)
2023 tree remove
= TREE_TYPE (newdecl
);
2024 for (tree t
= TYPE_MAIN_VARIANT (remove
); ;
2025 t
= TYPE_NEXT_VARIANT (t
))
2026 if (TYPE_NEXT_VARIANT (t
) == remove
)
2028 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (remove
);
2034 /* Merge the data types specified in the two decls. */
2035 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
2037 if (VAR_P (newdecl
))
2039 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
2040 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
2041 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
2042 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
2043 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
2044 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
2046 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2047 if (DECL_LANG_SPECIFIC (olddecl
)
2048 && CP_DECL_THREADPRIVATE_P (olddecl
))
2050 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2051 if (!DECL_LANG_SPECIFIC (newdecl
))
2052 retrofit_lang_decl (newdecl
);
2054 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
2058 /* An explicit specialization of a function template or of a member
2059 function of a class template can be declared transaction_safe
2060 independently of whether the corresponding template entity is declared
2061 transaction_safe. */
2062 if (flag_tm
&& TREE_CODE (newdecl
) == FUNCTION_DECL
2063 && DECL_TEMPLATE_INSTANTIATION (olddecl
)
2064 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)
2065 && tx_safe_fn_type_p (newtype
)
2066 && !tx_safe_fn_type_p (TREE_TYPE (newdecl
)))
2067 newtype
= tx_unsafe_fn_variant (newtype
);
2069 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
2071 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2072 check_default_args (newdecl
);
2074 /* Lay the type out, unless already done. */
2075 if (! same_type_p (newtype
, oldtype
)
2076 && TREE_TYPE (newdecl
) != error_mark_node
2077 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2078 layout_type (TREE_TYPE (newdecl
));
2080 if ((VAR_P (newdecl
)
2081 || TREE_CODE (newdecl
) == PARM_DECL
2082 || TREE_CODE (newdecl
) == RESULT_DECL
2083 || TREE_CODE (newdecl
) == FIELD_DECL
2084 || TREE_CODE (newdecl
) == TYPE_DECL
)
2085 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2086 layout_decl (newdecl
, 0);
2088 /* Merge the type qualifiers. */
2089 if (TREE_READONLY (newdecl
))
2090 TREE_READONLY (olddecl
) = 1;
2091 if (TREE_THIS_VOLATILE (newdecl
))
2092 TREE_THIS_VOLATILE (olddecl
) = 1;
2093 if (TREE_NOTHROW (newdecl
))
2094 TREE_NOTHROW (olddecl
) = 1;
2096 /* Merge deprecatedness. */
2097 if (TREE_DEPRECATED (newdecl
))
2098 TREE_DEPRECATED (olddecl
) = 1;
2100 /* Preserve function specific target and optimization options */
2101 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2103 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2104 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2105 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2106 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2108 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2109 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2110 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2111 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2114 /* Merge the initialization information. */
2115 if (DECL_INITIAL (newdecl
) == NULL_TREE
2116 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2118 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2119 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2120 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2122 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2123 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2127 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2129 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2130 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2131 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2132 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2133 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2134 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2135 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2136 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2137 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2138 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2139 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2140 /* Keep the old RTL. */
2141 COPY_DECL_RTL (olddecl
, newdecl
);
2143 else if (VAR_P (newdecl
)
2144 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2146 /* Keep the old RTL. We cannot keep the old RTL if the old
2147 declaration was for an incomplete object and the new
2148 declaration is not since many attributes of the RTL will
2150 COPY_DECL_RTL (olddecl
, newdecl
);
2153 /* If cannot merge, then use the new type and qualifiers,
2154 and don't preserve the old rtl. */
2157 /* Clean out any memory we had of the old declaration. */
2158 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2160 TREE_VALUE (oldstatic
) = error_mark_node
;
2162 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2163 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2164 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2165 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2168 /* Merge the storage class information. */
2169 merge_weak (newdecl
, olddecl
);
2171 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2172 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2173 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2174 if (! DECL_EXTERNAL (olddecl
))
2175 DECL_EXTERNAL (newdecl
) = 0;
2176 if (! DECL_COMDAT (olddecl
))
2177 DECL_COMDAT (newdecl
) = 0;
2179 new_template_info
= NULL_TREE
;
2180 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2182 bool new_redefines_gnu_inline
= false;
2184 if (new_defines_function
2185 && ((DECL_INTERFACE_KNOWN (olddecl
)
2186 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2187 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2188 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2189 == FUNCTION_DECL
))))
2193 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2194 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2196 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2199 if (!new_redefines_gnu_inline
)
2201 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2202 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2203 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2205 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2206 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2207 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2209 /* If the OLDDECL is an instantiation and/or specialization,
2210 then the NEWDECL must be too. But, it may not yet be marked
2211 as such if the caller has created NEWDECL, but has not yet
2212 figured out that it is a redeclaration. */
2213 if (!DECL_USE_TEMPLATE (newdecl
))
2214 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2216 /* Don't really know how much of the language-specific
2217 values we should copy from old to new. */
2218 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2219 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2220 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2221 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2223 if (LANG_DECL_HAS_MIN (newdecl
))
2225 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2226 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2227 if (DECL_TEMPLATE_INFO (newdecl
))
2229 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2230 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2231 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2232 /* Remember the presence of explicit specialization args. */
2233 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2234 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2236 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2238 /* Only functions have these fields. */
2239 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2241 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2242 DECL_BEFRIENDING_CLASSES (newdecl
)
2243 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2244 DECL_BEFRIENDING_CLASSES (olddecl
));
2245 /* DECL_THUNKS is only valid for virtual functions,
2246 otherwise it is a DECL_FRIEND_CONTEXT. */
2247 if (DECL_VIRTUAL_P (newdecl
))
2248 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2250 /* Only variables have this field. */
2251 else if (VAR_P (newdecl
)
2252 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2253 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2256 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2260 /* Merge parameter attributes. */
2261 tree oldarg
, newarg
;
2262 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2263 newarg
= DECL_ARGUMENTS(newdecl
);
2265 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2266 DECL_ATTRIBUTES (newarg
)
2267 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2268 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2271 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2272 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2274 /* If newdecl is not a specialization, then it is not a
2275 template-related function at all. And that means that we
2276 should have exited above, returning 0. */
2277 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2279 if (DECL_ODR_USED (olddecl
))
2280 /* From [temp.expl.spec]:
2282 If a template, a member template or the member of a class
2283 template is explicitly specialized then that
2284 specialization shall be declared before the first use of
2285 that specialization that would cause an implicit
2286 instantiation to take place, in every translation unit in
2287 which such a use occurs. */
2288 error ("explicit specialization of %qD after first use",
2291 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2292 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2293 && DECL_DECLARED_INLINE_P (newdecl
));
2295 /* Don't propagate visibility from the template to the
2296 specialization here. We'll do that in determine_visibility if
2298 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2300 /* [temp.expl.spec/14] We don't inline explicit specialization
2301 just because the primary template says so. */
2303 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2304 the always_inline attribute. */
2305 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2306 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2308 if (DECL_DECLARED_INLINE_P (newdecl
))
2309 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2311 DECL_ATTRIBUTES (newdecl
)
2312 = remove_attribute ("always_inline",
2313 DECL_ATTRIBUTES (newdecl
));
2316 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2318 /* Never inline re-defined extern inline functions.
2319 FIXME: this could be better handled by keeping both
2320 function as separate declarations. */
2321 DECL_UNINLINABLE (newdecl
) = 1;
2325 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2326 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2328 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2330 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2331 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2333 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2334 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2335 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2336 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2339 /* Preserve abstractness on cloned [cd]tors. */
2340 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2342 /* Update newdecl's parms to point at olddecl. */
2343 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2344 parm
= DECL_CHAIN (parm
))
2345 DECL_CONTEXT (parm
) = olddecl
;
2349 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2350 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2351 COPY_DECL_RTL (newdecl
, olddecl
);
2353 if (! types_match
|| new_defines_function
)
2355 /* These need to be copied so that the names are available.
2356 Note that if the types do match, we'll preserve inline
2357 info and other bits, but if not, we won't. */
2358 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2359 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2361 /* If redeclaring a builtin function, it stays built in
2362 if newdecl is a gnu_inline definition, or if newdecl is just
2364 if (DECL_BUILT_IN (olddecl
)
2365 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2367 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2368 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2369 /* If we're keeping the built-in definition, keep the rtl,
2370 regardless of declaration matches. */
2371 COPY_DECL_RTL (olddecl
, newdecl
);
2372 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2374 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2377 /* If a compatible prototype of these builtin functions
2378 is seen, assume the runtime implements it with the
2379 expected semantics. */
2380 case BUILT_IN_STPCPY
:
2381 if (builtin_decl_explicit_p (fncode
))
2382 set_builtin_decl_implicit_p (fncode
, true);
2385 if (builtin_decl_explicit_p (fncode
))
2386 set_builtin_decl_declared_p (fncode
, true);
2391 if (new_defines_function
)
2392 /* If defining a function declared with other language
2393 linkage, use the previously declared language linkage. */
2394 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2395 else if (types_match
)
2397 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2398 /* Don't clear out the arguments if we're just redeclaring a
2400 if (DECL_ARGUMENTS (olddecl
))
2401 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2404 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2405 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2407 /* Now preserve various other info from the definition. */
2408 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2409 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2410 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2411 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2413 /* Warn about conflicting visibility specifications. */
2414 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2415 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2416 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2418 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2419 "%qD: visibility attribute ignored because it "
2420 "conflicts with previous declaration", newdecl
))
2421 inform (DECL_SOURCE_LOCATION (olddecl
),
2422 "previous declaration of %qD", olddecl
);
2424 /* Choose the declaration which specified visibility. */
2425 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2427 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2428 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2430 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2431 so keep this behavior. */
2432 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2434 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2435 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2437 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2438 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2440 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2441 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2443 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2444 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2445 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2447 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2448 with that from NEWDECL below. */
2449 if (DECL_LANG_SPECIFIC (olddecl
))
2451 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2452 != DECL_LANG_SPECIFIC (newdecl
));
2453 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2456 /* Merge the USED information. */
2457 if (TREE_USED (olddecl
))
2458 TREE_USED (newdecl
) = 1;
2459 else if (TREE_USED (newdecl
))
2460 TREE_USED (olddecl
) = 1;
2461 if (VAR_P (newdecl
))
2463 if (DECL_READ_P (olddecl
))
2464 DECL_READ_P (newdecl
) = 1;
2465 else if (DECL_READ_P (newdecl
))
2466 DECL_READ_P (olddecl
) = 1;
2468 if (DECL_PRESERVE_P (olddecl
))
2469 DECL_PRESERVE_P (newdecl
) = 1;
2470 else if (DECL_PRESERVE_P (newdecl
))
2471 DECL_PRESERVE_P (olddecl
) = 1;
2473 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2474 to olddecl and deleted. */
2475 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2476 && DECL_FUNCTION_VERSIONED (olddecl
))
2478 /* Set the flag for newdecl so that it gets copied to olddecl. */
2479 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2480 /* newdecl will be purged after copying to olddecl and is no longer
2482 cgraph_node::delete_function_version (newdecl
);
2485 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2488 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2490 function_size
= sizeof (struct tree_decl_common
);
2492 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2493 (char *) newdecl
+ sizeof (struct tree_common
),
2494 function_size
- sizeof (struct tree_common
));
2496 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2497 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2498 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2500 /* Preserve symtab node mapping. */
2501 olddecl
->decl_with_vis
.symtab_node
= snode
;
2503 if (new_template_info
)
2504 /* If newdecl is a template instantiation, it is possible that
2505 the following sequence of events has occurred:
2507 o A friend function was declared in a class template. The
2508 class template was instantiated.
2510 o The instantiation of the friend declaration was
2511 recorded on the instantiation list, and is newdecl.
2513 o Later, however, instantiate_class_template called pushdecl
2514 on the newdecl to perform name injection. But, pushdecl in
2515 turn called duplicate_decls when it discovered that another
2516 declaration of a global function with the same name already
2519 o Here, in duplicate_decls, we decided to clobber newdecl.
2521 If we're going to do that, we'd better make sure that
2522 olddecl, and not newdecl, is on the list of
2523 instantiations so that if we try to do the instantiation
2524 again we won't get the clobbered declaration. */
2525 reregister_specialization (newdecl
,
2531 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2533 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2534 (char *) newdecl
+ sizeof (struct tree_common
),
2535 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2536 switch (TREE_CODE (newdecl
))
2546 struct symtab_node
*snode
= NULL
;
2549 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
)
2550 || DECL_EXTERNAL (olddecl
)))
2551 snode
= symtab_node::get (olddecl
);
2552 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2553 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2554 size
- sizeof (struct tree_decl_common
)
2555 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2556 if (VAR_P (newdecl
))
2557 olddecl
->decl_with_vis
.symtab_node
= snode
;
2561 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2562 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2563 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2564 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2569 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2571 if (DECL_EXTERNAL (olddecl
)
2572 || TREE_PUBLIC (olddecl
)
2573 || TREE_STATIC (olddecl
))
2575 /* Merge the section attribute.
2576 We want to issue an error if the sections conflict but that must be
2577 done later in decl_attributes since we are called before attributes
2579 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2580 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2582 if (DECL_ONE_ONLY (newdecl
))
2584 struct symtab_node
*oldsym
, *newsym
;
2585 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2586 oldsym
= cgraph_node::get_create (olddecl
);
2588 oldsym
= varpool_node::get_create (olddecl
);
2589 newsym
= symtab_node::get (newdecl
);
2590 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2595 && CP_DECL_THREAD_LOCAL_P (newdecl
))
2597 CP_DECL_THREAD_LOCAL_P (olddecl
) = true;
2598 if (!processing_template_decl
)
2599 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2603 DECL_UID (olddecl
) = olddecl_uid
;
2605 DECL_FRIEND_P (olddecl
) = 1;
2608 DECL_ANTICIPATED (olddecl
) = 1;
2609 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2612 /* NEWDECL contains the merged attribute lists.
2613 Update OLDDECL to be the same. */
2614 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2616 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2617 so that encode_section_info has a chance to look at the new decl
2618 flags and attributes. */
2619 if (DECL_RTL_SET_P (olddecl
)
2620 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2622 && TREE_STATIC (olddecl
))))
2623 make_decl_rtl (olddecl
);
2625 /* The NEWDECL will no longer be needed. Because every out-of-class
2626 declaration of a member results in a call to duplicate_decls,
2627 freeing these nodes represents in a significant savings.
2629 Before releasing the node, be sore to remove function from symbol
2630 table that might have been inserted there to record comdat group.
2631 Be sure to however do not free DECL_STRUCT_FUNCTION becuase this
2632 structure is shared in between newdecl and oldecl. */
2633 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2634 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2635 if (VAR_OR_FUNCTION_DECL_P (newdecl
))
2637 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2642 /* Remove the associated constraints for newdecl, if any, before
2643 reclaiming memory. */
2645 remove_constraints (newdecl
);
2652 /* Return zero if the declaration NEWDECL is valid
2653 when the declaration OLDDECL (assumed to be for the same name)
2654 has already been seen.
2655 Otherwise return an error message format string with a %s
2656 where the identifier should go. */
2659 redeclaration_error_message (tree newdecl
, tree olddecl
)
2661 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2663 /* Because C++ can put things into name space for free,
2664 constructs like "typedef struct foo { ... } foo"
2665 would look like an erroneous redeclaration. */
2666 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2669 return G_("redefinition of %q#D");
2671 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2673 /* If this is a pure function, its olddecl will actually be
2674 the original initialization to `0' (which we force to call
2675 abort()). Don't complain about redefinition in this case. */
2676 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2677 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2680 /* If both functions come from different namespaces, this is not
2681 a redeclaration - this is a conflict with a used function. */
2682 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2683 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2684 && ! decls_match (olddecl
, newdecl
))
2685 return G_("%qD conflicts with used function");
2687 /* We'll complain about linkage mismatches in
2688 warn_extern_redeclared_static. */
2690 /* Defining the same name twice is no good. */
2691 if (DECL_INITIAL (olddecl
) != NULL_TREE
2692 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2694 if (DECL_NAME (olddecl
) == NULL_TREE
)
2695 return G_("%q#D not declared in class");
2696 else if (!GNU_INLINE_P (olddecl
)
2697 || GNU_INLINE_P (newdecl
))
2698 return G_("redefinition of %q#D");
2701 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2703 bool olda
= GNU_INLINE_P (olddecl
);
2704 bool newa
= GNU_INLINE_P (newdecl
);
2709 return G_("%q+D redeclared inline with "
2710 "%<gnu_inline%> attribute");
2712 return G_("%q+D redeclared inline without "
2713 "%<gnu_inline%> attribute");
2717 check_abi_tag_redeclaration
2718 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2719 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2723 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2727 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2729 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2730 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2731 return G_("redefinition of %q#D");
2735 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2736 || (DECL_TEMPLATE_RESULT (newdecl
)
2737 == DECL_TEMPLATE_RESULT (olddecl
)))
2740 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2741 if (DECL_TEMPLATE_INFO (nt
))
2742 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2743 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2744 if (DECL_TEMPLATE_INFO (ot
))
2745 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2746 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2747 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2748 return G_("redefinition of %q#D");
2750 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2752 bool olda
= GNU_INLINE_P (ot
);
2753 bool newa
= GNU_INLINE_P (nt
);
2758 return G_("%q+D redeclared inline with "
2759 "%<gnu_inline%> attribute");
2761 return G_("%q+D redeclared inline without "
2762 "%<gnu_inline%> attribute");
2766 /* Core issue #226 (C++0x):
2768 If a friend function template declaration specifies a
2769 default template-argument, that declaration shall be a
2770 definition and shall be the only declaration of the
2771 function template in the translation unit. */
2772 if ((cxx_dialect
!= cxx98
)
2773 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2774 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2775 /*is_primary=*/true,
2776 /*is_partial=*/false,
2777 /*is_friend_decl=*/2))
2778 return G_("redeclaration of friend %q#D "
2779 "may not have default template arguments");
2783 else if (VAR_P (newdecl
)
2784 && CP_DECL_THREAD_LOCAL_P (newdecl
) != CP_DECL_THREAD_LOCAL_P (olddecl
)
2785 && (! DECL_LANG_SPECIFIC (olddecl
)
2786 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2787 || CP_DECL_THREAD_LOCAL_P (newdecl
)))
2789 /* Only variables can be thread-local, and all declarations must
2790 agree on this property. */
2791 if (CP_DECL_THREAD_LOCAL_P (newdecl
))
2792 return G_("thread-local declaration of %q#D follows "
2793 "non-thread-local declaration");
2795 return G_("non-thread-local declaration of %q#D follows "
2796 "thread-local declaration");
2798 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2800 /* The objects have been declared at namespace scope. If either
2801 is a member of an anonymous union, then this is an invalid
2802 redeclaration. For example:
2808 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2809 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2810 return G_("redeclaration of %q#D");
2811 /* If at least one declaration is a reference, there is no
2812 conflict. For example:
2818 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2820 /* Reject two definitions. */
2821 return G_("redefinition of %q#D");
2825 /* Objects declared with block scope: */
2826 /* Reject two definitions, and reject a definition
2827 together with an external reference. */
2828 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2829 return G_("redeclaration of %q#D");
2834 /* Hash and equality functions for the named_label table. */
2837 named_label_hasher::hash (named_label_entry
*ent
)
2839 return DECL_UID (ent
->label_decl
);
2843 named_label_hasher::equal (named_label_entry
*a
, named_label_entry
*b
)
2845 return a
->label_decl
== b
->label_decl
;
2848 /* Create a new label, named ID. */
2851 make_label_decl (tree id
, int local_p
)
2853 struct named_label_entry
*ent
;
2856 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2858 DECL_CONTEXT (decl
) = current_function_decl
;
2859 DECL_MODE (decl
) = VOIDmode
;
2860 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2862 /* Say where one reference is to the label, for the sake of the
2863 error if it is not defined. */
2864 DECL_SOURCE_LOCATION (decl
) = input_location
;
2866 /* Record the fact that this identifier is bound to this label. */
2867 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2869 /* Create the label htab for the function on demand. */
2871 named_labels
= hash_table
<named_label_hasher
>::create_ggc (13);
2873 /* Record this label on the list of labels used in this function.
2874 We do this before calling make_label_decl so that we get the
2875 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2876 ent
= ggc_cleared_alloc
<named_label_entry
> ();
2877 ent
->label_decl
= decl
;
2879 named_label_entry
**slot
= named_labels
->find_slot (ent
, INSERT
);
2880 gcc_assert (*slot
== NULL
);
2886 /* Look for a label named ID in the current function. If one cannot
2887 be found, create one. (We keep track of used, but undefined,
2888 labels, and complain about them at the end of a function.) */
2891 lookup_label_1 (tree id
)
2895 /* You can't use labels at global scope. */
2896 if (current_function_decl
== NULL_TREE
)
2898 error ("label %qE referenced outside of any function", id
);
2902 /* See if we've already got this label. */
2903 decl
= IDENTIFIER_LABEL_VALUE (id
);
2904 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2907 decl
= make_label_decl (id
, /*local_p=*/0);
2911 /* Wrapper for lookup_label_1. */
2914 lookup_label (tree id
)
2917 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2918 ret
= lookup_label_1 (id
);
2919 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2923 /* Declare a local label named ID. */
2926 declare_local_label (tree id
)
2929 cp_label_binding bind
;
2931 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2932 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2933 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2935 decl
= make_label_decl (id
, /*local_p=*/1);
2937 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2942 /* Returns nonzero if it is ill-formed to jump past the declaration of
2943 DECL. Returns 2 if it's also a real problem. */
2946 decl_jump_unsafe (tree decl
)
2948 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2949 with automatic storage duration is not in scope to a point where it is
2950 in scope is ill-formed unless the variable has scalar type, class type
2951 with a trivial default constructor and a trivial destructor, a
2952 cv-qualified version of one of these types, or an array of one of the
2953 preceding types and is declared without an initializer (8.5). */
2954 tree type
= TREE_TYPE (decl
);
2956 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2957 || type
== error_mark_node
)
2960 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
2961 || variably_modified_type_p (type
, NULL_TREE
))
2964 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2970 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
2974 identify_goto (tree decl
, location_t loc
, const location_t
*locus
,
2975 diagnostic_t diag_kind
)
2978 = (decl
? emit_diagnostic (diag_kind
, loc
, 0, "jump to label %qD", decl
)
2979 : emit_diagnostic (diag_kind
, loc
, 0, "jump to case label"));
2980 if (complained
&& locus
)
2981 inform (*locus
, " from here");
2985 /* Check that a single previously seen jump to a newly defined label
2986 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2987 the jump context; NAMES are the names in scope in LEVEL at the jump
2988 context; LOCUS is the source position of the jump or 0. Returns
2989 true if all is well. */
2992 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2993 bool exited_omp
, const location_t
*locus
)
2995 cp_binding_level
*b
;
2996 bool complained
= false;
2998 bool saw_eh
= false, saw_omp
= false, saw_tm
= false;
3002 complained
= identify_goto (decl
, input_location
, locus
, DK_ERROR
);
3004 inform (input_location
, " exits OpenMP structured block");
3009 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3011 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
3013 for (new_decls
= b
->names
; new_decls
!= old_decls
;
3014 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
3015 : TREE_CHAIN (new_decls
)))
3017 int problem
= decl_jump_unsafe (new_decls
);
3023 complained
= identify_goto (decl
, input_location
, locus
,
3030 inform (DECL_SOURCE_LOCATION (new_decls
),
3031 " crosses initialization of %q#D", new_decls
);
3033 inform (DECL_SOURCE_LOCATION (new_decls
),
3034 " enters scope of %q#D which has "
3035 "non-trivial destructor", new_decls
);
3041 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
3045 complained
= identify_goto (decl
, input_location
, locus
,
3051 if (b
->kind
== sk_try
)
3052 inform (input_location
, " enters try block");
3054 inform (input_location
, " enters catch block");
3058 if (b
->kind
== sk_omp
&& !saw_omp
)
3062 complained
= identify_goto (decl
, input_location
, locus
,
3067 inform (input_location
, " enters OpenMP structured block");
3070 if (b
->kind
== sk_transaction
&& !saw_tm
)
3074 complained
= identify_goto (decl
, input_location
, locus
,
3079 inform (input_location
,
3080 " enters synchronized or atomic statement");
3089 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
3091 check_previous_goto_1 (decl
, use
->binding_level
,
3092 use
->names_in_scope
, use
->in_omp_scope
,
3093 &use
->o_goto_locus
);
3097 check_switch_goto (cp_binding_level
* level
)
3099 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
3102 /* Check that a new jump to a label DECL is OK. Called by
3103 finish_goto_stmt. */
3106 check_goto (tree decl
)
3108 struct named_label_entry
*ent
, dummy
;
3109 bool saw_catch
= false, complained
= false;
3114 /* We can't know where a computed goto is jumping.
3115 So we assume that it's OK. */
3116 if (TREE_CODE (decl
) != LABEL_DECL
)
3119 /* We didn't record any information about this label when we created it,
3120 and there's not much point since it's trivial to analyze as a return. */
3121 if (decl
== cdtor_label
)
3124 dummy
.label_decl
= decl
;
3125 ent
= named_labels
->find (&dummy
);
3126 gcc_assert (ent
!= NULL
);
3128 /* If the label hasn't been defined yet, defer checking. */
3129 if (! DECL_INITIAL (decl
))
3131 struct named_label_use_entry
*new_use
;
3133 /* Don't bother creating another use if the last goto had the
3134 same data, and will therefore create the same set of errors. */
3136 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3139 new_use
= ggc_alloc
<named_label_use_entry
> ();
3140 new_use
->binding_level
= current_binding_level
;
3141 new_use
->names_in_scope
= current_binding_level
->names
;
3142 new_use
->o_goto_locus
= input_location
;
3143 new_use
->in_omp_scope
= false;
3145 new_use
->next
= ent
->uses
;
3146 ent
->uses
= new_use
;
3150 if (ent
->in_try_scope
|| ent
->in_catch_scope
|| ent
->in_transaction_scope
3151 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3153 diagnostic_t diag_kind
= DK_PERMERROR
;
3154 if (ent
->in_try_scope
|| ent
->in_catch_scope
3155 || ent
->in_transaction_scope
|| ent
->in_omp_scope
)
3156 diag_kind
= DK_ERROR
;
3157 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3158 &input_location
, diag_kind
);
3159 identified
= 1 + (diag_kind
== DK_ERROR
);
3162 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3164 int u
= decl_jump_unsafe (bad
);
3166 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3168 /* Can't skip init of __exception_info. */
3169 if (identified
== 1)
3171 complained
= identify_goto (decl
, DECL_SOURCE_LOCATION (decl
),
3172 &input_location
, DK_ERROR
);
3176 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3179 else if (complained
)
3182 inform (DECL_SOURCE_LOCATION (bad
),
3183 " skips initialization of %q#D", bad
);
3185 inform (DECL_SOURCE_LOCATION (bad
),
3186 " enters scope of %q#D which has "
3187 "non-trivial destructor", bad
);
3193 if (ent
->in_try_scope
)
3194 inform (input_location
, " enters try block");
3195 else if (ent
->in_catch_scope
&& !saw_catch
)
3196 inform (input_location
, " enters catch block");
3197 else if (ent
->in_transaction_scope
)
3198 inform (input_location
, " enters synchronized or atomic statement");
3201 if (ent
->in_omp_scope
)
3204 inform (input_location
, " enters OpenMP structured block");
3206 else if (flag_openmp
)
3208 cp_binding_level
*b
;
3209 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3211 if (b
== ent
->binding_level
)
3213 if (b
->kind
== sk_omp
)
3217 complained
= identify_goto (decl
,
3218 DECL_SOURCE_LOCATION (decl
),
3219 &input_location
, DK_ERROR
);
3223 inform (input_location
, " exits OpenMP structured block");
3230 /* Check that a return is ok wrt OpenMP structured blocks.
3231 Called by finish_return_stmt. Returns true if all is well. */
3234 check_omp_return (void)
3236 cp_binding_level
*b
;
3237 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3238 if (b
->kind
== sk_omp
)
3240 error ("invalid exit from OpenMP structured block");
3243 else if (b
->kind
== sk_function_parms
)
3248 /* Define a label, specifying the location in the source file.
3249 Return the LABEL_DECL node for the label. */
3252 define_label_1 (location_t location
, tree name
)
3254 struct named_label_entry
*ent
, dummy
;
3255 cp_binding_level
*p
;
3258 decl
= lookup_label (name
);
3260 dummy
.label_decl
= decl
;
3261 ent
= named_labels
->find (&dummy
);
3262 gcc_assert (ent
!= NULL
);
3264 /* After labels, make any new cleanups in the function go into their
3265 own new (temporary) binding contour. */
3266 for (p
= current_binding_level
;
3267 p
->kind
!= sk_function_parms
;
3269 p
->more_cleanups_ok
= 0;
3271 if (name
== get_identifier ("wchar_t"))
3272 permerror (input_location
, "label named wchar_t");
3274 if (DECL_INITIAL (decl
) != NULL_TREE
)
3276 error ("duplicate label %qD", decl
);
3277 return error_mark_node
;
3281 struct named_label_use_entry
*use
;
3283 /* Mark label as having been defined. */
3284 DECL_INITIAL (decl
) = error_mark_node
;
3285 /* Say where in the source. */
3286 DECL_SOURCE_LOCATION (decl
) = location
;
3288 ent
->binding_level
= current_binding_level
;
3289 ent
->names_in_scope
= current_binding_level
->names
;
3291 for (use
= ent
->uses
; use
; use
= use
->next
)
3292 check_previous_goto (decl
, use
);
3299 /* Wrapper for define_label_1. */
3302 define_label (location_t location
, tree name
)
3305 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3306 ret
= define_label_1 (location
, name
);
3307 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3314 cp_binding_level
*level
;
3315 struct cp_switch
*next
;
3316 /* The SWITCH_STMT being built. */
3318 /* A splay-tree mapping the low element of a case range to the high
3319 element, or NULL_TREE if there is no high element. Used to
3320 determine whether or not a new case label duplicates an old case
3321 label. We need a tree, rather than simply a hash table, because
3322 of the GNU case range extension. */
3324 /* Remember whether there was a case value that is outside the
3325 range of the original type of the controlling expression. */
3326 bool outside_range_p
;
3329 /* A stack of the currently active switch statements. The innermost
3330 switch statement is on the top of the stack. There is no need to
3331 mark the stack for garbage collection because it is only active
3332 during the processing of the body of a function, and we never
3333 collect at that point. */
3335 static struct cp_switch
*switch_stack
;
3337 /* Called right after a switch-statement condition is parsed.
3338 SWITCH_STMT is the switch statement being parsed. */
3341 push_switch (tree switch_stmt
)
3343 struct cp_switch
*p
= XNEW (struct cp_switch
);
3344 p
->level
= current_binding_level
;
3345 p
->next
= switch_stack
;
3346 p
->switch_stmt
= switch_stmt
;
3347 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3348 p
->outside_range_p
= false;
3355 struct cp_switch
*cs
= switch_stack
;
3356 location_t switch_location
;
3358 /* Emit warnings as needed. */
3359 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3360 const bool bool_cond_p
3361 = (SWITCH_STMT_TYPE (cs
->switch_stmt
)
3362 && TREE_CODE (SWITCH_STMT_TYPE (cs
->switch_stmt
)) == BOOLEAN_TYPE
);
3363 if (!processing_template_decl
)
3364 c_do_switch_warnings (cs
->cases
, switch_location
,
3365 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3366 SWITCH_STMT_COND (cs
->switch_stmt
),
3367 bool_cond_p
, cs
->outside_range_p
);
3369 splay_tree_delete (cs
->cases
);
3370 switch_stack
= switch_stack
->next
;
3374 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3375 condition. Note that if TYPE and VALUE are already integral we don't
3376 really do the conversion because the language-independent
3377 warning/optimization code will work better that way. */
3380 case_conversion (tree type
, tree value
)
3382 if (value
== NULL_TREE
)
3385 if (cxx_dialect
>= cxx11
3386 && (SCOPED_ENUM_P (type
)
3387 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3389 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3390 type
= type_promotes_to (type
);
3391 value
= (perform_implicit_conversion_flags
3392 (type
, value
, tf_warning_or_error
,
3393 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3395 return cxx_constant_value (value
);
3398 /* Note that we've seen a definition of a case label, and complain if this
3399 is a bad place for one. */
3402 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3405 cp_binding_level
*p
;
3408 if (processing_template_decl
)
3412 /* For templates, just add the case label; we'll do semantic
3413 analysis at instantiation-time. */
3414 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3415 return add_stmt (build_case_label (low_value
, high_value
, label
));
3418 /* Find the condition on which this switch statement depends. */
3419 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3420 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3421 cond
= TREE_VALUE (cond
);
3423 if (!check_switch_goto (switch_stack
->level
))
3424 return error_mark_node
;
3426 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3428 low_value
= case_conversion (type
, low_value
);
3429 high_value
= case_conversion (type
, high_value
);
3431 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3432 low_value
, high_value
,
3433 &switch_stack
->outside_range_p
);
3435 /* After labels, make any new cleanups in the function go into their
3436 own new (temporary) binding contour. */
3437 for (p
= current_binding_level
;
3438 p
->kind
!= sk_function_parms
;
3440 p
->more_cleanups_ok
= 0;
3445 struct typename_info
{
3453 struct typename_hasher
: ggc_ptr_hash
<tree_node
>
3455 typedef typename_info
*compare_type
;
3457 /* Hash a TYPENAME_TYPE. */
3464 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3465 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3470 /* Compare two TYPENAME_TYPEs. */
3473 equal (tree t1
, const typename_info
*t2
)
3475 return (TYPE_IDENTIFIER (t1
) == t2
->name
3476 && TYPE_CONTEXT (t1
) == t2
->scope
3477 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3478 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3479 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3483 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3484 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3486 Returns the new TYPENAME_TYPE. */
3488 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3491 build_typename_type (tree context
, tree name
, tree fullname
,
3492 enum tag_types tag_type
)
3500 if (typename_htab
== NULL
)
3501 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3503 ti
.scope
= FROB_CONTEXT (context
);
3505 ti
.template_id
= fullname
;
3506 ti
.enum_p
= tag_type
== enum_type
;
3507 ti
.class_p
= (tag_type
== class_type
3508 || tag_type
== record_type
3509 || tag_type
== union_type
);
3510 hash
= (htab_hash_pointer (ti
.scope
)
3511 ^ htab_hash_pointer (ti
.name
));
3513 /* See if we already have this type. */
3514 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3519 /* Build the TYPENAME_TYPE. */
3520 t
= cxx_make_type (TYPENAME_TYPE
);
3521 TYPE_CONTEXT (t
) = ti
.scope
;
3522 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3523 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3524 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3526 /* Build the corresponding TYPE_DECL. */
3527 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3528 TYPE_NAME (TREE_TYPE (d
)) = d
;
3529 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3530 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3531 DECL_ARTIFICIAL (d
) = 1;
3533 /* Store it in the hash table. */
3536 /* TYPENAME_TYPEs must always be compared structurally, because
3537 they may or may not resolve down to another type depending on
3538 the currently open classes. */
3539 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3545 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3546 provided to name the type. Returns an appropriate type, unless an
3547 error occurs, in which case error_mark_node is returned. If we
3548 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3549 return that, rather than the _TYPE it corresponds to, in other
3550 cases we look through the type decl. If TF_ERROR is set, complain
3551 about errors, otherwise be quiet. */
3554 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3555 tsubst_flags_t complain
)
3561 if (name
== error_mark_node
3562 || context
== NULL_TREE
3563 || context
== error_mark_node
)
3564 return error_mark_node
;
3568 if (!(TYPE_LANG_SPECIFIC (name
)
3569 && (CLASSTYPE_IS_TEMPLATE (name
)
3570 || CLASSTYPE_USE_TEMPLATE (name
))))
3571 name
= TYPE_IDENTIFIER (name
);
3573 /* Create a TEMPLATE_ID_EXPR for the type. */
3574 name
= build_nt (TEMPLATE_ID_EXPR
,
3575 CLASSTYPE_TI_TEMPLATE (name
),
3576 CLASSTYPE_TI_ARGS (name
));
3578 else if (TREE_CODE (name
) == TYPE_DECL
)
3579 name
= DECL_NAME (name
);
3583 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3585 name
= TREE_OPERAND (name
, 0);
3586 if (DECL_TYPE_TEMPLATE_P (name
))
3587 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3588 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
3590 if (complain
& tf_error
)
3591 error ("%qD is not a type", name
);
3592 return error_mark_node
;
3595 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3597 if (complain
& tf_error
)
3598 error ("%qD used without template parameters", name
);
3599 return error_mark_node
;
3601 gcc_assert (identifier_p (name
));
3602 gcc_assert (TYPE_P (context
));
3604 if (!MAYBE_CLASS_TYPE_P (context
))
3606 if (complain
& tf_error
)
3607 error ("%q#T is not a class", context
);
3608 return error_mark_node
;
3611 /* When the CONTEXT is a dependent type, NAME could refer to a
3612 dependent base class of CONTEXT. But look inside it anyway
3613 if CONTEXT is a currently open scope, in case it refers to a
3614 member of the current instantiation or a non-dependent base;
3615 lookup will stop when we hit a dependent base. */
3616 if (!dependent_scope_p (context
))
3617 /* We should only set WANT_TYPE when we're a nested typename type.
3618 Then we can give better diagnostics if we find a non-type. */
3619 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3623 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3624 return build_typename_type (context
, name
, fullname
, tag_type
);
3626 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3630 if (complain
& tf_error
)
3631 error (want_template
? G_("no class template named %q#T in %q#T")
3632 : G_("no type named %q#T in %q#T"), name
, context
);
3633 return error_mark_node
;
3636 /* Pull out the template from an injected-class-name (or multiple). */
3638 t
= maybe_get_template_decl_from_type_decl (t
);
3640 if (TREE_CODE (t
) == TREE_LIST
)
3642 if (complain
& tf_error
)
3644 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3645 print_candidates (t
);
3647 return error_mark_node
;
3650 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3652 if (complain
& tf_error
)
3653 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3655 return error_mark_node
;
3657 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3659 if (complain
& tf_error
)
3660 error ("%<typename %T::%D%> names %q#T, which is not a type",
3662 return error_mark_node
;
3665 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3666 return error_mark_node
;
3668 /* If we are currently parsing a template and if T is a typedef accessed
3669 through CONTEXT then we need to remember and check access of T at
3670 template instantiation time. */
3671 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3674 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3676 /*entering_scope=*/0,
3677 complain
| tf_user
);
3679 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3682 maybe_record_typedef_use (t
);
3687 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3688 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3689 in which case error_mark_node is returned.
3691 If PARM_LIST is non-NULL, also make sure that the template parameter
3692 list of TEMPLATE_DECL matches.
3694 If COMPLAIN zero, don't complain about any errors that occur. */
3697 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3698 tsubst_flags_t complain
)
3704 name
= TYPE_IDENTIFIER (name
);
3705 else if (DECL_P (name
))
3706 name
= DECL_NAME (name
);
3707 gcc_assert (identifier_p (name
));
3709 if (!dependent_type_p (context
)
3710 || currently_open_class (context
))
3712 tree tmpl
= NULL_TREE
;
3714 if (MAYBE_CLASS_TYPE_P (context
))
3715 tmpl
= lookup_field (context
, name
, 0, false);
3717 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3718 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3720 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3722 if (complain
& tf_error
)
3723 error ("no class template named %q#T in %q#T", name
, context
);
3724 return error_mark_node
;
3728 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3730 if (complain
& tf_error
)
3732 error ("template parameters do not match template %qD", tmpl
);
3733 inform (DECL_SOURCE_LOCATION (tmpl
),
3734 "%qD declared here", tmpl
);
3736 return error_mark_node
;
3739 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3741 return error_mark_node
;
3746 /* Build the UNBOUND_CLASS_TEMPLATE. */
3747 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3748 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3749 TREE_TYPE (t
) = NULL_TREE
;
3750 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3752 /* Build the corresponding TEMPLATE_DECL. */
3753 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3754 TYPE_NAME (TREE_TYPE (d
)) = d
;
3755 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3756 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3757 DECL_ARTIFICIAL (d
) = 1;
3758 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3765 /* Push the declarations of builtin types into the namespace.
3766 RID_INDEX is the index of the builtin type in the array
3767 RID_POINTERS. NAME is the name used when looking up the builtin
3768 type. TYPE is the _TYPE node for the builtin type. */
3771 record_builtin_type (enum rid rid_index
,
3775 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3776 tree tdecl
= NULL_TREE
;
3778 if ((int) rid_index
< (int) RID_MAX
)
3779 rname
= ridpointers
[(int) rid_index
];
3781 tname
= get_identifier (name
);
3783 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3784 eliminated. Built-in types should not be looked up name; their
3785 names are keywords that the parser can recognize. However, there
3786 is code in c-common.c that uses identifier_global_value to look
3787 up built-in types by name. */
3790 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3791 DECL_ARTIFICIAL (tdecl
) = 1;
3792 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3798 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3799 DECL_ARTIFICIAL (tdecl
) = 1;
3801 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3804 if (!TYPE_NAME (type
))
3805 TYPE_NAME (type
) = tdecl
;
3808 debug_hooks
->type_decl (tdecl
, 0);
3811 /* Record one of the standard Java types.
3812 * Declare it as having the given NAME.
3813 * If SIZE > 0, it is the size of one of the integral types;
3814 * otherwise it is the negative of the size of one of the other types. */
3817 record_builtin_java_type (const char* name
, int size
)
3822 type
= build_nonstandard_integer_type (size
, 0);
3823 type
= build_distinct_type_copy (type
);
3825 else if (size
> -32)
3828 /* "__java_char" or ""__java_boolean". */
3829 type
= build_nonstandard_integer_type (-size
, 1);
3830 type
= build_distinct_type_copy (type
);
3831 /* Get the signed type cached and attached to the unsigned type,
3832 so it doesn't get garbage-collected at "random" times,
3833 causing potential codegen differences out of different UIDs
3834 and different alias set numbers. */
3835 stype
= build_nonstandard_integer_type (-size
, 0);
3836 stype
= build_distinct_type_copy (stype
);
3837 TREE_CHAIN (type
) = stype
;
3838 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3841 { /* "__java_float" or ""__java_double". */
3842 type
= make_node (REAL_TYPE
);
3843 TYPE_PRECISION (type
) = - size
;
3846 record_builtin_type (RID_MAX
, name
, type
);
3847 decl
= TYPE_NAME (type
);
3849 /* Suppress generate debug symbol entries for these types,
3850 since for normal C++ they are just clutter.
3851 However, push_lang_context undoes this if extern "Java" is seen. */
3852 DECL_IGNORED_P (decl
) = 1;
3854 TYPE_FOR_JAVA (type
) = 1;
3858 /* Push a type into the namespace so that the back ends ignore it. */
3861 record_unknown_type (tree type
, const char* name
)
3863 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3864 TYPE_DECL
, get_identifier (name
), type
));
3865 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3866 DECL_IGNORED_P (decl
) = 1;
3867 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3868 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3869 TYPE_ALIGN (type
) = 1;
3870 TYPE_USER_ALIGN (type
) = 0;
3871 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3874 /* A string for which we should create an IDENTIFIER_NODE at
3877 struct predefined_identifier
3879 /* The name of the identifier. */
3880 const char *const name
;
3881 /* The place where the IDENTIFIER_NODE should be stored. */
3883 /* Nonzero if this is the name of a constructor or destructor. */
3884 const int ctor_or_dtor_p
;
3887 /* Create all the predefined identifiers. */
3890 initialize_predefined_identifiers (void)
3892 const predefined_identifier
*pid
;
3894 /* A table of identifiers to create at startup. */
3895 static const predefined_identifier predefined_identifiers
[] = {
3896 { "C++", &lang_name_cplusplus
, 0 },
3897 { "C", &lang_name_c
, 0 },
3898 { "Java", &lang_name_java
, 0 },
3899 /* Some of these names have a trailing space so that it is
3900 impossible for them to conflict with names written by users. */
3901 { "__ct ", &ctor_identifier
, 1 },
3902 { "__base_ctor ", &base_ctor_identifier
, 1 },
3903 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3904 { "__dt ", &dtor_identifier
, 1 },
3905 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3906 { "__base_dtor ", &base_dtor_identifier
, 1 },
3907 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3908 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3909 { "nelts", &nelts_identifier
, 0 },
3910 { THIS_NAME
, &this_identifier
, 0 },
3911 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3912 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3913 { "_vptr", &vptr_identifier
, 0 },
3914 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3915 { "::", &global_scope_name
, 0 },
3916 { "std", &std_identifier
, 0 },
3920 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3922 *pid
->node
= get_identifier (pid
->name
);
3923 if (pid
->ctor_or_dtor_p
)
3924 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3928 /* Create the predefined scalar types of C,
3929 and some nodes representing standard constants (0, 1, (void *)0).
3930 Initialize the global binding level.
3931 Make definitions for built-in primitive functions. */
3934 cxx_init_decl_processing (void)
3937 tree void_ftype_ptr
;
3939 /* Create all the identifiers we need. */
3940 initialize_predefined_identifiers ();
3942 /* Create the global variables. */
3943 push_to_top_level ();
3945 current_function_decl
= NULL_TREE
;
3946 current_binding_level
= NULL
;
3947 /* Enter the global namespace. */
3948 gcc_assert (global_namespace
== NULL_TREE
);
3949 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3951 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3952 debug_hooks
->register_main_translation_unit
3953 (DECL_CONTEXT (global_namespace
));
3954 TREE_PUBLIC (global_namespace
) = 1;
3955 begin_scope (sk_namespace
, global_namespace
);
3957 if (flag_visibility_ms_compat
)
3958 default_visibility
= VISIBILITY_HIDDEN
;
3961 current_lang_name
= lang_name_c
;
3963 /* Create the `std' namespace. */
3964 push_namespace (std_identifier
);
3965 std_node
= current_namespace
;
3968 c_common_nodes_and_builtins ();
3970 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3971 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3972 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3973 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3974 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3975 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3976 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3977 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3979 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3981 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3982 truthvalue_type_node
= boolean_type_node
;
3983 truthvalue_false_node
= boolean_false_node
;
3984 truthvalue_true_node
= boolean_true_node
;
3986 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3987 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3988 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3991 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3994 delta_type_node
= ptrdiff_type_node
;
3995 vtable_index_type
= ptrdiff_type_node
;
3997 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3998 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3999 void_ftype_ptr
= build_function_type_list (void_type_node
,
4000 ptr_type_node
, NULL_TREE
);
4002 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
4004 /* C++ extensions */
4006 unknown_type_node
= make_node (LANG_TYPE
);
4007 record_unknown_type (unknown_type_node
, "unknown type");
4009 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4010 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
4012 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4014 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
4015 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
4017 init_list_type_node
= make_node (LANG_TYPE
);
4018 record_unknown_type (init_list_type_node
, "init list");
4021 /* Make sure we get a unique function type, so we can give
4022 its pointer type a name. (This wins for gdb.) */
4023 tree vfunc_type
= make_node (FUNCTION_TYPE
);
4024 TREE_TYPE (vfunc_type
) = integer_type_node
;
4025 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
4026 layout_type (vfunc_type
);
4028 vtable_entry_type
= build_pointer_type (vfunc_type
);
4030 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
4033 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
4034 layout_type (vtbl_type_node
);
4035 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
4036 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
4037 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
4038 layout_type (vtbl_ptr_type_node
);
4039 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
4041 push_namespace (get_identifier ("__cxxabiv1"));
4042 abi_node
= current_namespace
;
4045 global_type_node
= make_node (LANG_TYPE
);
4046 record_unknown_type (global_type_node
, "global type");
4049 current_lang_name
= lang_name_cplusplus
;
4052 tree newattrs
, extvisattr
;
4053 tree newtype
, deltype
;
4054 tree ptr_ftype_sizetype
;
4058 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
4059 if (cxx_dialect
== cxx98
)
4062 tree bad_alloc_type_node
;
4063 tree bad_alloc_decl
;
4065 push_namespace (std_identifier
);
4066 bad_alloc_id
= get_identifier ("bad_alloc");
4067 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
4068 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
4070 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
4071 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
4075 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
4078 new_eh_spec
= noexcept_false_spec
;
4080 /* Ensure attribs.c is initialized. */
4083 /* Ensure constraint.cc is initialized. */
4084 init_constraint_processing ();
4086 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
4088 newattrs
= tree_cons (get_identifier ("alloc_size"),
4089 build_tree_list (NULL_TREE
, integer_one_node
),
4091 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
4092 newtype
= build_exception_variant (newtype
, new_eh_spec
);
4093 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
4094 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4095 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
4096 DECL_IS_MALLOC (opnew
) = 1;
4097 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4098 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
4099 DECL_IS_MALLOC (opnew
) = 1;
4100 DECL_IS_OPERATOR_NEW (opnew
) = 1;
4101 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4102 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4103 if (flag_sized_deallocation
)
4105 /* Also push the sized deallocation variants:
4106 void operator delete(void*, std::size_t) throw();
4107 void operator delete[](void*, std::size_t) throw(); */
4108 tree void_ftype_ptr_size
4109 = build_function_type_list (void_type_node
, ptr_type_node
,
4110 size_type_node
, NULL_TREE
);
4111 deltype
= cp_build_type_attribute_variant (void_ftype_ptr_size
,
4113 deltype
= build_exception_variant (deltype
, empty_except_spec
);
4114 push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4115 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
4118 nullptr_type_node
= make_node (NULLPTR_TYPE
);
4119 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
4120 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
4121 TYPE_UNSIGNED (nullptr_type_node
) = 1;
4122 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
4123 if (abi_version_at_least (9))
4124 TYPE_ALIGN (nullptr_type_node
) = GET_MODE_ALIGNMENT (ptr_mode
);
4125 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
4126 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
4127 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
4131 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
4132 ECF_NORETURN
| ECF_NOTHROW
);
4134 /* Perform other language dependent initializations. */
4135 init_class_processing ();
4136 init_rtti_processing ();
4137 init_template_processing ();
4139 if (flag_exceptions
)
4140 init_exception_processing ();
4142 if (! supports_one_only ())
4145 make_fname_decl
= cp_make_fname_decl
;
4146 start_fname_decls ();
4148 /* Show we use EH for cleanups. */
4149 if (flag_exceptions
)
4150 using_eh_for_cleanups ();
4153 /* Generate an initializer for a function naming variable from
4154 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4155 filled in with the type of the init. */
4158 cp_fname_init (const char* name
, tree
*type_p
)
4160 tree domain
= NULL_TREE
;
4162 tree init
= NULL_TREE
;
4167 length
= strlen (name
);
4168 domain
= build_index_type (size_int (length
));
4169 init
= build_string (length
+ 1, name
);
4172 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4173 type
= build_cplus_array_type (type
, domain
);
4178 TREE_TYPE (init
) = type
;
4180 init
= error_mark_node
;
4185 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4186 the decl, LOC is the location to give the decl, NAME is the
4187 initialization string and TYPE_DEP indicates whether NAME depended
4188 on the type of the function. We make use of that to detect
4189 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4190 at the point of first use, so we mustn't push the decl now. */
4193 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4195 const char *const name
= (type_dep
&& processing_template_decl
4196 ? NULL
: fname_as_string (type_dep
));
4198 tree init
= cp_fname_init (name
, &type
);
4199 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4202 free (CONST_CAST (char *, name
));
4204 /* As we're using pushdecl_with_scope, we must set the context. */
4205 DECL_CONTEXT (decl
) = current_function_decl
;
4207 TREE_STATIC (decl
) = 1;
4208 TREE_READONLY (decl
) = 1;
4209 DECL_ARTIFICIAL (decl
) = 1;
4211 TREE_USED (decl
) = 1;
4213 if (current_function_decl
)
4215 cp_binding_level
*b
= current_binding_level
;
4216 if (b
->kind
== sk_function_parms
)
4217 return error_mark_node
;
4218 while (b
->level_chain
->kind
!= sk_function_parms
)
4220 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
4221 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
4222 LOOKUP_ONLYCONVERTING
);
4226 DECL_THIS_STATIC (decl
) = true;
4227 pushdecl_top_level_and_finish (decl
, init
);
4234 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4236 tree id
= DECL_NAME (decl
);
4237 const char *name
= IDENTIFIER_POINTER (id
);
4239 retrofit_lang_decl (decl
);
4241 DECL_ARTIFICIAL (decl
) = 1;
4242 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
4243 SET_DECL_LANGUAGE (decl
, lang_c
);
4244 /* Runtime library routines are, by definition, available in an
4245 external shared object. */
4246 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4247 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4249 DECL_CONTEXT (decl
) = context
;
4252 pushdecl_top_level (decl
);
4256 /* A function in the user's namespace should have an explicit
4257 declaration before it is used. Mark the built-in function as
4258 anticipated but not actually declared. */
4259 if (name
[0] != '_' || name
[1] != '_')
4260 DECL_ANTICIPATED (decl
) = 1;
4261 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4263 size_t len
= strlen (name
);
4265 /* Treat __*_chk fortification functions as anticipated as well,
4266 unless they are __builtin_*. */
4267 if (len
> strlen ("___chk")
4268 && memcmp (name
+ len
- strlen ("_chk"),
4269 "_chk", strlen ("_chk") + 1) == 0)
4270 DECL_ANTICIPATED (decl
) = 1;
4277 cxx_builtin_function (tree decl
)
4279 tree id
= DECL_NAME (decl
);
4280 const char *name
= IDENTIFIER_POINTER (id
);
4281 /* All builtins that don't begin with an '_' should additionally
4282 go in the 'std' namespace. */
4285 tree decl2
= copy_node(decl
);
4286 push_namespace (std_identifier
);
4287 builtin_function_1 (decl2
, std_node
, false);
4291 return builtin_function_1 (decl
, NULL_TREE
, false);
4294 /* Like cxx_builtin_function, but guarantee the function is added to the global
4295 scope. This is to allow function specific options to add new machine
4296 dependent builtins when the target ISA changes via attribute((target(...)))
4297 which saves space on program startup if the program does not use non-generic
4301 cxx_builtin_function_ext_scope (tree decl
)
4304 tree id
= DECL_NAME (decl
);
4305 const char *name
= IDENTIFIER_POINTER (id
);
4306 /* All builtins that don't begin with an '_' should additionally
4307 go in the 'std' namespace. */
4310 tree decl2
= copy_node(decl
);
4311 push_namespace (std_identifier
);
4312 builtin_function_1 (decl2
, std_node
, true);
4316 return builtin_function_1 (decl
, NULL_TREE
, true);
4319 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4320 function. Not called directly. */
4323 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4326 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4327 DECL_EXTERNAL (fn
) = 1;
4328 TREE_PUBLIC (fn
) = 1;
4329 DECL_ARTIFICIAL (fn
) = 1;
4330 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4331 SET_DECL_LANGUAGE (fn
, lang_c
);
4332 /* Runtime library routines are, by definition, available in an
4333 external shared object. */
4334 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4335 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4336 set_call_expr_flags (fn
, ecf_flags
);
4340 /* Returns the _DECL for a library function with C++ linkage. */
4343 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4346 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4347 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4348 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4352 /* Like build_library_fn, but takes a C string instead of an
4356 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4358 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4361 /* Like build_cp_library_fn, but takes a C string instead of an
4365 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4367 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4371 /* Like build_library_fn, but also pushes the function so that we will
4372 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4373 may throw exceptions listed in RAISES. */
4376 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4381 type
= build_exception_variant (type
, raises
);
4383 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4384 pushdecl_top_level (fn
);
4388 /* Like build_cp_library_fn, but also pushes the function so that it
4389 will be found by normal lookup. */
4392 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4395 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4400 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4404 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4408 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4410 tree type
= build_function_type (void_type_node
, parmtypes
);
4411 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4414 /* Like push_library_fn, but also note that this function throws
4415 and does not return. Used for __throw_foo and the like. */
4418 push_throw_library_fn (tree name
, tree type
)
4420 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4424 /* When we call finish_struct for an anonymous union, we create
4425 default copy constructors and such. But, an anonymous union
4426 shouldn't have such things; this function undoes the damage to the
4427 anonymous union type T.
4429 (The reason that we create the synthesized methods is that we don't
4430 distinguish `union { int i; }' from `typedef union { int i; } U'.
4431 The first is an anonymous union; the second is just an ordinary
4435 fixup_anonymous_aggr (tree t
)
4439 /* Wipe out memory of synthesized methods. */
4440 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4441 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4442 TYPE_HAS_COPY_CTOR (t
) = 0;
4443 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4444 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4445 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4447 /* Splice the implicitly generated functions out of the TYPE_METHODS
4449 q
= &TYPE_METHODS (t
);
4452 if (DECL_ARTIFICIAL (*q
))
4453 *q
= TREE_CHAIN (*q
);
4455 q
= &DECL_CHAIN (*q
);
4458 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4459 if (TYPE_METHODS (t
))
4461 tree decl
= TYPE_MAIN_DECL (t
);
4463 if (TREE_CODE (t
) != UNION_TYPE
)
4464 error_at (DECL_SOURCE_LOCATION (decl
),
4465 "an anonymous struct cannot have function members");
4467 error_at (DECL_SOURCE_LOCATION (decl
),
4468 "an anonymous union cannot have function members");
4471 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4472 assignment operators (because they cannot have these methods themselves).
4473 For anonymous unions this is already checked because they are not allowed
4474 in any union, otherwise we have to check it. */
4475 if (TREE_CODE (t
) != UNION_TYPE
)
4479 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4480 if (TREE_CODE (field
) == FIELD_DECL
)
4482 type
= TREE_TYPE (field
);
4483 if (CLASS_TYPE_P (type
))
4485 if (TYPE_NEEDS_CONSTRUCTING (type
))
4486 error ("member %q+#D with constructor not allowed "
4487 "in anonymous aggregate", field
);
4488 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4489 error ("member %q+#D with destructor not allowed "
4490 "in anonymous aggregate", field
);
4491 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4492 error ("member %q+#D with copy assignment operator "
4493 "not allowed in anonymous aggregate", field
);
4499 /* Warn for an attribute located at LOCATION that appertains to the
4500 class type CLASS_TYPE that has not been properly placed after its
4501 class-key, in it class-specifier. */
4504 warn_misplaced_attr_for_class_type (source_location location
,
4507 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4509 if (warning_at (location
, OPT_Wattributes
,
4510 "attribute ignored in declaration "
4511 "of %q#T", class_type
))
4513 "attribute for %q#T must follow the %qs keyword",
4514 class_type
, class_key_or_enum_as_string (class_type
));
4517 /* Make sure that a declaration with no declarator is well-formed, i.e.
4518 just declares a tagged type or anonymous union.
4520 Returns the type declared; or NULL_TREE if none. */
4523 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4524 bool explicit_type_instantiation_p
)
4526 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4527 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4528 /* If a class, struct, or enum type is declared by the DECLSPECS
4529 (i.e, if a class-specifier, enum-specifier, or non-typename
4530 elaborated-type-specifier appears in the DECLSPECS),
4531 DECLARED_TYPE is set to the corresponding type. */
4532 tree declared_type
= NULL_TREE
;
4533 bool error_p
= false;
4535 if (declspecs
->multiple_types_p
)
4536 error ("multiple types in one declaration");
4537 else if (declspecs
->redefined_builtin_type
)
4539 if (!in_system_header_at (input_location
))
4540 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4541 "redeclaration of C++ built-in type %qT",
4542 declspecs
->redefined_builtin_type
);
4547 && TYPE_P (declspecs
->type
)
4548 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4549 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4550 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4551 declared_type
= declspecs
->type
;
4552 else if (declspecs
->type
== error_mark_node
)
4554 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4555 permerror (input_location
, "declaration does not declare anything");
4556 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4558 error_at (declspecs
->locations
[ds_type_spec
],
4559 "%<auto%> can only be specified for variables "
4560 "or function declarations");
4561 return error_mark_node
;
4563 /* Check for an anonymous union. */
4564 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4565 && TYPE_ANONYMOUS_P (declared_type
))
4567 /* 7/3 In a simple-declaration, the optional init-declarator-list
4568 can be omitted only when declaring a class (clause 9) or
4569 enumeration (7.2), that is, when the decl-specifier-seq contains
4570 either a class-specifier, an elaborated-type-specifier with
4571 a class-key (9.1), or an enum-specifier. In these cases and
4572 whenever a class-specifier or enum-specifier is present in the
4573 decl-specifier-seq, the identifiers in these specifiers are among
4574 the names being declared by the declaration (as class-name,
4575 enum-names, or enumerators, depending on the syntax). In such
4576 cases, and except for the declaration of an unnamed bit-field (9.6),
4577 the decl-specifier-seq shall introduce one or more names into the
4578 program, or shall redeclare a name introduced by a previous
4579 declaration. [Example:
4580 enum { }; // ill-formed
4581 typedef class { }; // ill-formed
4585 error ("missing type-name in typedef-declaration");
4588 /* Anonymous unions are objects, so they can have specifiers. */;
4589 SET_ANON_AGGR_TYPE_P (declared_type
);
4591 if (TREE_CODE (declared_type
) != UNION_TYPE
4592 && !in_system_header_at (input_location
))
4593 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4598 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
4599 error_at (declspecs
->locations
[ds_inline
],
4600 "%<inline%> can only be specified for functions");
4601 else if (decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4602 error_at (declspecs
->locations
[ds_virtual
],
4603 "%<virtual%> can only be specified for functions");
4605 && (!current_class_type
4606 || current_scope () != current_class_type
))
4607 error_at (declspecs
->locations
[ds_friend
],
4608 "%<friend%> can only be specified inside a class");
4609 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4610 error_at (declspecs
->locations
[ds_explicit
],
4611 "%<explicit%> can only be specified for constructors");
4612 else if (declspecs
->storage_class
)
4613 error_at (declspecs
->locations
[ds_storage_class
],
4614 "a storage class can only be specified for objects "
4616 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
4617 error_at (declspecs
->locations
[ds_const
],
4618 "%<const%> can only be specified for objects and "
4620 else if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
4621 error_at (declspecs
->locations
[ds_volatile
],
4622 "%<volatile%> can only be specified for objects and "
4624 else if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
4625 error_at (declspecs
->locations
[ds_restrict
],
4626 "%<__restrict%> can only be specified for objects and "
4628 else if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4629 error_at (declspecs
->locations
[ds_thread
],
4630 "%<__thread%> can only be specified for objects "
4632 else if (saw_typedef
)
4633 warning_at (declspecs
->locations
[ds_typedef
], 0,
4634 "%<typedef%> was ignored in this declaration");
4635 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4636 error_at (declspecs
->locations
[ds_constexpr
],
4637 "%<constexpr%> cannot be used for type declarations");
4640 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4643 if (!CLASS_TYPE_P (declared_type
)
4644 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4645 /* For a non-template class, use the name location. */
4646 loc
= location_of (declared_type
);
4648 /* For a template class (an explicit instantiation), use the
4649 current location. */
4650 loc
= input_location
;
4652 if (explicit_type_instantiation_p
)
4653 /* [dcl.attr.grammar]/4:
4655 No attribute-specifier-seq shall appertain to an explicit
4658 if (warning_at (loc
, OPT_Wattributes
,
4659 "attribute ignored in explicit instantiation %q#T",
4662 "no attribute can be applied to "
4663 "an explicit instantiation");
4666 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4669 return declared_type
;
4672 /* Called when a declaration is seen that contains no names to declare.
4673 If its type is a reference to a structure, union or enum inherited
4674 from a containing scope, shadow that tag name for the current scope
4675 with a forward reference.
4676 If its type defines a new named structure or union
4677 or defines an enum, it is valid but we need not do anything here.
4678 Otherwise, it is an error.
4680 C++: may have to grok the declspecs to learn about static,
4681 complain for anonymous unions.
4683 Returns the TYPE declared -- or NULL_TREE if none. */
4686 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4688 tree t
= check_tag_decl (declspecs
,
4689 /*explicit_type_instantiation_p=*/false);
4694 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4697 /* This is where the variables in an anonymous union are
4698 declared. An anonymous union declaration looks like:
4700 because there is no declarator after the union, the parser
4701 sends that declaration here. */
4702 if (ANON_AGGR_TYPE_P (t
))
4704 fixup_anonymous_aggr (t
);
4706 if (TYPE_FIELDS (t
))
4708 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4709 declspecs
, NORMAL
, 0, NULL
);
4710 finish_anon_union (decl
);
4717 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4720 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4721 const cp_declarator
*declarator
,
4722 bool is_template_arg
)
4726 enum decl_context context
4727 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4728 attrs
= type_specifiers
->attributes
;
4729 type_specifiers
->attributes
= NULL_TREE
;
4730 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4731 if (attrs
&& type
!= error_mark_node
)
4733 if (CLASS_TYPE_P (type
))
4734 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4735 "outside of definition", type
);
4736 else if (MAYBE_CLASS_TYPE_P (type
))
4737 /* A template type parameter or other dependent type. */
4738 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4739 "type %qT without an associated declaration", type
);
4741 cplus_decl_attributes (&type
, attrs
, 0);
4746 /* Process a DECLARATOR for a function-scope variable declaration,
4747 namespace-scope variable declaration, or function declaration.
4748 (Function definitions go through start_function; class member
4749 declarations appearing in the body of the class go through
4750 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4751 If an error occurs, the error_mark_node is returned instead.
4753 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4754 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4755 for an explicitly defaulted function, or SD_DELETED for an explicitly
4756 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4757 implicitly initialized via a default constructor. ATTRIBUTES and
4758 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4760 The scope represented by the context of the returned DECL is pushed
4761 (if it is not the global namespace) and is assigned to
4762 *PUSHED_SCOPE_P. The caller is then responsible for calling
4763 pop_scope on *PUSHED_SCOPE_P if it is set. */
4766 start_decl (const cp_declarator
*declarator
,
4767 cp_decl_specifier_seq
*declspecs
,
4770 tree prefix_attributes
,
4771 tree
*pushed_scope_p
)
4779 *pushed_scope_p
= NULL_TREE
;
4781 /* An object declared as __attribute__((deprecated)) suppresses
4782 warnings of uses of other deprecated items. */
4783 if (lookup_attribute ("deprecated", attributes
))
4784 deprecated_state
= DEPRECATED_SUPPRESS
;
4786 attributes
= chainon (attributes
, prefix_attributes
);
4788 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4791 deprecated_state
= DEPRECATED_NORMAL
;
4793 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4794 || decl
== error_mark_node
)
4795 return error_mark_node
;
4797 context
= CP_DECL_CONTEXT (decl
);
4798 if (context
!= global_namespace
)
4799 *pushed_scope_p
= push_scope (context
);
4801 /* Is it valid for this decl to have an initializer at all?
4802 If not, set INITIALIZED to zero, which will indirectly
4803 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4805 && TREE_CODE (decl
) == TYPE_DECL
)
4807 error ("typedef %qD is initialized (use decltype instead)", decl
);
4808 return error_mark_node
;
4813 if (! toplevel_bindings_p ()
4814 && DECL_EXTERNAL (decl
))
4815 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4817 DECL_EXTERNAL (decl
) = 0;
4818 if (toplevel_bindings_p ())
4819 TREE_STATIC (decl
) = 1;
4821 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4823 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4824 record_key_method_defined (decl
);
4826 /* If this is a typedef that names the class for linkage purposes
4827 (7.1.3p8), apply any attributes directly to the type. */
4828 if (TREE_CODE (decl
) == TYPE_DECL
4829 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4830 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4831 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4835 /* Set attributes here so if duplicate decl, will have proper attributes. */
4836 cplus_decl_attributes (&decl
, attributes
, flags
);
4838 /* Dllimported symbols cannot be defined. Static data members (which
4839 can be initialized in-class and dllimported) go through grokfield,
4840 not here, so we don't need to exclude those decls when checking for
4842 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4844 error ("definition of %q#D is marked %<dllimport%>", decl
);
4845 DECL_DLLIMPORT_P (decl
) = 0;
4848 /* If #pragma weak was used, mark the decl weak now. */
4849 if (!processing_template_decl
)
4850 maybe_apply_pragma_weak (decl
);
4852 if (TREE_CODE (decl
) == FUNCTION_DECL
4853 && DECL_DECLARED_INLINE_P (decl
)
4854 && DECL_UNINLINABLE (decl
)
4855 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4856 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4857 "inline function %qD given attribute noinline", decl
);
4859 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4861 bool this_tmpl
= (processing_template_decl
4862 > template_class_depth (context
));
4865 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4866 if (field
== NULL_TREE
4867 || !(VAR_P (field
) || variable_template_p (field
)))
4868 error ("%q+#D is not a static data member of %q#T", decl
, context
);
4869 else if (variable_template_p (field
) && !this_tmpl
)
4871 if (DECL_LANG_SPECIFIC (decl
)
4872 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4873 /* OK, specialization was already checked. */;
4876 error_at (DECL_SOURCE_LOCATION (decl
),
4877 "non-member-template declaration of %qD", decl
);
4878 inform (DECL_SOURCE_LOCATION (field
), "does not match "
4879 "member template declaration here");
4880 return error_mark_node
;
4885 if (variable_template_p (field
))
4886 field
= DECL_TEMPLATE_RESULT (field
);
4888 if (DECL_CONTEXT (field
) != context
)
4890 if (!same_type_p (DECL_CONTEXT (field
), context
))
4891 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4892 "to be defined as %<%T::%D%>",
4893 DECL_CONTEXT (field
), DECL_NAME (decl
),
4894 context
, DECL_NAME (decl
));
4895 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4897 /* Static data member are tricky; an in-class initialization
4898 still doesn't provide a definition, so the in-class
4899 declaration will have DECL_EXTERNAL set, but will have an
4900 initialization. Thus, duplicate_decls won't warn
4901 about this situation, and so we check here. */
4902 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4903 error ("duplicate initialization of %qD", decl
);
4904 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4906 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4907 && !DECL_DECLARED_CONSTEXPR_P (field
))
4908 error ("%qD declared %<constexpr%> outside its class", field
);
4913 tree field
= check_classfn (context
, decl
,
4915 ? current_template_parms
4917 if (field
&& field
!= error_mark_node
4918 && duplicate_decls (decl
, field
,
4919 /*newdecl_is_friend=*/false))
4923 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4924 DECL_IN_AGGR_P (decl
) = 0;
4925 /* Do not mark DECL as an explicit specialization if it was not
4926 already marked as an instantiation; a declaration should
4927 never be marked as a specialization unless we know what
4928 template is being specialized. */
4929 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4931 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4932 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4933 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
4934 && DECL_DECLARED_INLINE_P (decl
));
4936 DECL_COMDAT (decl
) = false;
4938 /* [temp.expl.spec] An explicit specialization of a static data
4939 member of a template is a definition if the declaration
4940 includes an initializer; otherwise, it is a declaration.
4942 We check for processing_specialization so this only applies
4943 to the new specialization syntax. */
4944 if (!initialized
&& processing_specialization
)
4945 DECL_EXTERNAL (decl
) = 1;
4948 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4949 /* Aliases are definitions. */
4951 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4955 was_public
= TREE_PUBLIC (decl
);
4957 /* Enter this declaration into the symbol table. Don't push the plain
4958 VAR_DECL for a variable template. */
4959 if (!template_parm_scope_p ()
4961 decl
= maybe_push_decl (decl
);
4963 if (processing_template_decl
)
4964 decl
= push_template_decl (decl
);
4965 if (decl
== error_mark_node
)
4966 return error_mark_node
;
4969 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4970 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4972 /* This is a const variable with implicit 'static'. Set
4973 DECL_THIS_STATIC so we can tell it from variables that are
4974 !TREE_PUBLIC because of the anonymous namespace. */
4975 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4976 DECL_THIS_STATIC (decl
) = 1;
4979 if (current_function_decl
&& VAR_P (decl
)
4980 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
4983 if (CP_DECL_THREAD_LOCAL_P (decl
))
4984 error ("%qD declared %<thread_local%> in %<constexpr%> function",
4986 else if (TREE_STATIC (decl
))
4987 error ("%qD declared %<static%> in %<constexpr%> function", decl
);
4991 cp_function_chain
->invalid_constexpr
= true;
4994 if (!processing_template_decl
&& VAR_P (decl
))
4995 start_decl_1 (decl
, initialized
);
5000 /* Process the declaration of a variable DECL. INITIALIZED is true
5001 iff DECL is explicitly initialized. (INITIALIZED is false if the
5002 variable is initialized via an implicitly-called constructor.)
5003 This function must be called for ordinary variables (including, for
5004 example, implicit instantiations of templates), but must not be
5005 called for template declarations. */
5008 start_decl_1 (tree decl
, bool initialized
)
5012 bool aggregate_definition_p
;
5014 gcc_assert (!processing_template_decl
);
5016 if (error_operand_p (decl
))
5019 gcc_assert (VAR_P (decl
));
5021 type
= TREE_TYPE (decl
);
5022 complete_p
= COMPLETE_TYPE_P (type
);
5023 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
5025 /* If an explicit initializer is present, or if this is a definition
5026 of an aggregate, then we need a complete type at this point.
5027 (Scalars are always complete types, so there is nothing to
5028 check.) This code just sets COMPLETE_P; errors (if necessary)
5029 are issued below. */
5030 if ((initialized
|| aggregate_definition_p
)
5032 && COMPLETE_TYPE_P (complete_type (type
)))
5035 /* We will not yet have set TREE_READONLY on DECL if the type
5036 was "const", but incomplete, before this point. But, now, we
5037 have a complete type, so we can try again. */
5038 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
5042 /* Is it valid for this decl to have an initializer at all? */
5044 /* Don't allow initializations for incomplete types except for
5045 arrays which might be completed by the initialization. */
5047 ; /* A complete type is ok. */
5048 else if (type_uses_auto (type
))
5049 ; /* An auto type is ok. */
5050 else if (TREE_CODE (type
) != ARRAY_TYPE
)
5052 error ("variable %q#D has initializer but incomplete type", decl
);
5053 type
= TREE_TYPE (decl
) = error_mark_node
;
5055 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
5057 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
5058 error ("elements of array %q#D have incomplete type", decl
);
5059 /* else we already gave an error in start_decl. */
5062 else if (aggregate_definition_p
&& !complete_p
)
5064 if (type_uses_auto (type
))
5065 error ("declaration of %q#D has no initializer", decl
);
5067 error ("aggregate %q#D has incomplete type and cannot be defined",
5069 /* Change the type so that assemble_variable will give
5070 DECL an rtl we can live with: (mem (const_int 0)). */
5071 type
= TREE_TYPE (decl
) = error_mark_node
;
5074 /* Create a new scope to hold this declaration if necessary.
5075 Whether or not a new scope is necessary cannot be determined
5076 until after the type has been completed; if the type is a
5077 specialization of a class template it is not until after
5078 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5079 will be set correctly. */
5080 maybe_push_cleanup_level (type
);
5083 /* Handle initialization of references. DECL, TYPE, and INIT have the
5084 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5085 but will be set to a new CLEANUP_STMT if a temporary is created
5086 that must be destroyed subsequently.
5088 Returns an initializer expression to use to initialize DECL, or
5089 NULL if the initialization can be performed statically.
5091 Quotes on semantics can be found in ARM 8.4.3. */
5094 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
5096 if (init
== NULL_TREE
)
5098 if ((DECL_LANG_SPECIFIC (decl
) == 0
5099 || DECL_IN_AGGR_P (decl
) == 0)
5100 && ! DECL_THIS_EXTERN (decl
))
5101 error ("%qD declared as reference but not initialized", decl
);
5105 if (TREE_CODE (init
) == TREE_LIST
)
5106 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5107 tf_warning_or_error
);
5109 tree ttype
= TREE_TYPE (type
);
5110 if (TREE_CODE (ttype
) != ARRAY_TYPE
5111 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
5112 /* Note: default conversion is only called in very special cases. */
5113 init
= decay_conversion (init
, tf_warning_or_error
);
5115 /* check_initializer handles this for non-reference variables, but for
5116 references we need to do it here or the initializer will get the
5117 incomplete array type and confuse later calls to
5118 cp_complete_array_type. */
5119 if (TREE_CODE (ttype
) == ARRAY_TYPE
5120 && TYPE_DOMAIN (ttype
) == NULL_TREE
5121 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
5122 || TREE_CODE (init
) == STRING_CST
))
5124 cp_complete_array_type (&ttype
, init
, false);
5125 if (ttype
!= TREE_TYPE (type
))
5126 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
5129 /* Convert INIT to the reference type TYPE. This may involve the
5130 creation of a temporary, whose lifetime must be the same as that
5131 of the reference. If so, a DECL_EXPR for the temporary will be
5132 added just after the DECL_EXPR for DECL. That's why we don't set
5133 DECL_INITIAL for local references (instead assigning to them
5134 explicitly); we need to allow the temporary to be initialized
5136 return initialize_reference (type
, init
, flags
,
5137 tf_warning_or_error
);
5140 /* Designated initializers in arrays are not supported in GNU C++.
5141 The parser cannot detect this error since it does not know whether
5142 a given brace-enclosed initializer is for a class type or for an
5143 array. This function checks that CE does not use a designated
5144 initializer. If it does, an error is issued. Returns true if CE
5145 is valid, i.e., does not have a designated initializer. */
5148 check_array_designated_initializer (constructor_elt
*ce
,
5149 unsigned HOST_WIDE_INT index
)
5151 /* Designated initializers for array elements are not supported. */
5154 /* The parser only allows identifiers as designated
5156 if (ce
->index
== error_mark_node
)
5158 error ("name used in a GNU-style designated "
5159 "initializer for an array");
5162 else if (identifier_p (ce
->index
))
5164 error ("name %qD used in a GNU-style designated "
5165 "initializer for an array", ce
->index
);
5169 tree ce_index
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
5172 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index
))
5173 && (TREE_CODE (ce_index
= maybe_constant_value (ce_index
))
5176 /* A C99 designator is OK if it matches the current index. */
5177 if (wi::eq_p (ce_index
, index
))
5180 sorry ("non-trivial designated initializers not supported");
5183 error ("C99 designator %qE is not an integral constant-expression",
5192 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5193 array until we finish parsing the initializer. If that's the
5194 situation we're in, update DECL accordingly. */
5197 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5199 tree type
= TREE_TYPE (decl
);
5201 if (TREE_CODE (type
) == ARRAY_TYPE
5202 && TYPE_DOMAIN (type
) == NULL_TREE
5203 && TREE_CODE (decl
) != TYPE_DECL
)
5205 /* do_default is really a C-ism to deal with tentative definitions.
5206 But let's leave it here to ease the eventual merge. */
5207 int do_default
= !DECL_EXTERNAL (decl
);
5208 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5211 /* Check that there are no designated initializers in INIT, as
5212 those are not supported in GNU C++, and as the middle-end
5213 will crash if presented with a non-numeric designated
5215 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5217 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5218 constructor_elt
*ce
;
5220 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5221 if (!check_array_designated_initializer (ce
, i
))
5227 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5231 error ("initializer fails to determine size of %qD", decl
);
5233 else if (failure
== 2)
5237 error ("array size missing in %qD", decl
);
5239 /* If a `static' var's size isn't known, make it extern as
5240 well as static, so it does not get allocated. If it's not
5241 `static', then don't mark it extern; finish_incomplete_decl
5242 will give it a default size and it will get allocated. */
5243 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5244 DECL_EXTERNAL (decl
) = 1;
5246 else if (failure
== 3)
5248 error ("zero-size array %qD", decl
);
5252 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5254 relayout_decl (decl
);
5258 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5259 any appropriate error messages regarding the layout. */
5262 layout_var_decl (tree decl
)
5266 type
= TREE_TYPE (decl
);
5267 if (type
== error_mark_node
)
5270 /* If we haven't already laid out this declaration, do so now.
5271 Note that we must not call complete type for an external object
5272 because it's type might involve templates that we are not
5273 supposed to instantiate yet. (And it's perfectly valid to say
5274 `extern X x' for some incomplete type `X'.) */
5275 if (!DECL_EXTERNAL (decl
))
5276 complete_type (type
);
5277 if (!DECL_SIZE (decl
)
5278 && TREE_TYPE (decl
) != error_mark_node
5279 && (COMPLETE_TYPE_P (type
)
5280 || (TREE_CODE (type
) == ARRAY_TYPE
5281 && !TYPE_DOMAIN (type
)
5282 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
5283 layout_decl (decl
, 0);
5285 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5287 /* An automatic variable with an incomplete type: that is an error.
5288 Don't talk about array types here, since we took care of that
5289 message in grokdeclarator. */
5290 error ("storage size of %qD isn%'t known", decl
);
5291 TREE_TYPE (decl
) = error_mark_node
;
5294 /* Keep this code around in case we later want to control debug info
5295 based on whether a type is "used". (jason 1999-11-11) */
5297 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5298 /* Let debugger know it should output info for this type. */
5299 note_debug_info_needed (ttype
);
5301 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5302 note_debug_info_needed (DECL_CONTEXT (decl
));
5305 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5306 && DECL_SIZE (decl
) != NULL_TREE
5307 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5309 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5310 constant_expression_warning (DECL_SIZE (decl
));
5313 error ("storage size of %qD isn%'t constant", decl
);
5314 TREE_TYPE (decl
) = error_mark_node
;
5319 /* If a local static variable is declared in an inline function, or if
5320 we have a weak definition, we must endeavor to create only one
5321 instance of the variable at link-time. */
5324 maybe_commonize_var (tree decl
)
5326 /* Static data in a function with comdat linkage also has comdat
5328 if (TREE_STATIC (decl
)
5329 /* Don't mess with __FUNCTION__. */
5330 && ! DECL_ARTIFICIAL (decl
)
5331 && DECL_FUNCTION_SCOPE_P (decl
)
5332 && vague_linkage_p (DECL_CONTEXT (decl
)))
5336 /* With weak symbols, we simply make the variable COMDAT;
5337 that will cause copies in multiple translations units to
5339 comdat_linkage (decl
);
5343 if (DECL_INITIAL (decl
) == NULL_TREE
5344 || DECL_INITIAL (decl
) == error_mark_node
)
5346 /* Without weak symbols, we can use COMMON to merge
5347 uninitialized variables. */
5348 TREE_PUBLIC (decl
) = 1;
5349 DECL_COMMON (decl
) = 1;
5353 /* While for initialized variables, we must use internal
5354 linkage -- which means that multiple copies will not
5356 TREE_PUBLIC (decl
) = 0;
5357 DECL_COMMON (decl
) = 0;
5358 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5359 "sorry: semantics of inline function static "
5360 "data %q#D are wrong (you%'ll wind up "
5361 "with multiple copies)", decl
))
5362 inform (DECL_SOURCE_LOCATION (decl
),
5363 "you can work around this by removing the initializer");
5369 /* Issue an error message if DECL is an uninitialized const variable. */
5372 check_for_uninitialized_const_var (tree decl
)
5374 tree type
= strip_array_types (TREE_TYPE (decl
));
5376 /* ``Unless explicitly declared extern, a const object does not have
5377 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5380 && TREE_CODE (type
) != REFERENCE_TYPE
5381 && (CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5382 && !DECL_INITIAL (decl
))
5384 tree field
= default_init_uninitialized_part (type
);
5388 if (CP_TYPE_CONST_P (type
))
5389 permerror (DECL_SOURCE_LOCATION (decl
),
5390 "uninitialized const %qD", decl
);
5393 error_at (DECL_SOURCE_LOCATION (decl
),
5394 "uninitialized variable %qD in %<constexpr%> function",
5396 cp_function_chain
->invalid_constexpr
= true;
5399 if (CLASS_TYPE_P (type
))
5401 tree defaulted_ctor
;
5403 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5404 "%q#T has no user-provided default constructor", type
);
5405 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5407 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5408 "constructor is not user-provided because it is "
5409 "explicitly defaulted in the class body");
5410 inform (DECL_SOURCE_LOCATION (field
),
5411 "and the implicitly-defined constructor does not "
5412 "initialize %q#D", field
);
5417 /* Structure holding the current initializer being processed by reshape_init.
5418 CUR is a pointer to the current element being processed, END is a pointer
5419 after the last element present in the initializer. */
5422 constructor_elt
*cur
;
5423 constructor_elt
*end
;
5426 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5428 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5429 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5430 initialized. If there are no more such fields, the return value
5434 next_initializable_field (tree field
)
5437 && (TREE_CODE (field
) != FIELD_DECL
5438 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5439 || DECL_ARTIFICIAL (field
)))
5440 field
= DECL_CHAIN (field
);
5445 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5446 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5447 INTEGER_CST representing the size of the array minus one (the maximum index),
5448 or NULL_TREE if the array was declared without specifying the size. D is
5449 the iterator within the constructor. */
5452 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5453 tsubst_flags_t complain
)
5456 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5457 unsigned HOST_WIDE_INT max_index_cst
= 0;
5458 unsigned HOST_WIDE_INT index
;
5460 /* The initializer for an array is always a CONSTRUCTOR. */
5461 new_init
= build_constructor (init_list_type_node
, NULL
);
5465 /* Minus 1 is used for zero sized arrays. */
5466 if (integer_all_onesp (max_index
))
5469 if (tree_fits_uhwi_p (max_index
))
5470 max_index_cst
= tree_to_uhwi (max_index
);
5471 /* sizetype is sign extended, not zero extended. */
5473 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5476 /* Loop until there are no more initializers. */
5478 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5482 constructor_elt
*old_cur
= d
->cur
;
5484 check_array_designated_initializer (d
->cur
, index
);
5485 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5487 if (elt_init
== error_mark_node
)
5488 return error_mark_node
;
5489 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5490 size_int (index
), elt_init
);
5491 if (!TREE_CONSTANT (elt_init
))
5492 TREE_CONSTANT (new_init
) = false;
5494 /* This can happen with an invalid initializer (c++/54501). */
5495 if (d
->cur
== old_cur
&& !sized_array_p
)
5502 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5503 Parameters are the same of reshape_init_r. */
5506 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5508 tree max_index
= NULL_TREE
;
5510 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5512 if (TYPE_DOMAIN (type
))
5513 max_index
= array_type_nelts (type
);
5515 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5518 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5519 Parameters are the same of reshape_init_r. */
5522 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5524 tree max_index
= NULL_TREE
;
5526 gcc_assert (VECTOR_TYPE_P (type
));
5528 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5530 tree value
= d
->cur
->value
;
5531 if (!same_type_p (TREE_TYPE (value
), type
))
5533 if (complain
& tf_error
)
5534 error ("invalid type %qT as initializer for a vector of type %qT",
5535 TREE_TYPE (d
->cur
->value
), type
);
5536 value
= error_mark_node
;
5542 /* For a vector, we initialize it as an array of the appropriate size. */
5543 if (VECTOR_TYPE_P (type
))
5544 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5546 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5549 /* Subroutine of reshape_init_r, processes the initializers for classes
5550 or union. Parameters are the same of reshape_init_r. */
5553 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5554 tsubst_flags_t complain
)
5559 gcc_assert (CLASS_TYPE_P (type
));
5561 /* The initializer for a class is always a CONSTRUCTOR. */
5562 new_init
= build_constructor (init_list_type_node
, NULL
);
5563 field
= next_initializable_field (TYPE_FIELDS (type
));
5569 An initializer for an aggregate member that is an
5570 empty class shall have the form of an empty
5571 initializer-list {}. */
5572 if (!first_initializer_p
)
5574 if (complain
& tf_error
)
5575 error ("initializer for %qT must be brace-enclosed", type
);
5576 return error_mark_node
;
5581 /* Loop through the initializable fields, gathering initializers. */
5582 while (d
->cur
!= d
->end
)
5585 constructor_elt
*old_cur
= d
->cur
;
5587 /* Handle designated initializers, as an extension. */
5590 if (d
->cur
->index
== error_mark_node
)
5591 return error_mark_node
;
5593 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5594 /* We already reshaped this. */
5595 gcc_assert (d
->cur
->index
== field
);
5596 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5597 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5600 if (complain
& tf_error
)
5601 error ("%<[%E] =%> used in a GNU-style designated initializer"
5602 " for class %qT", d
->cur
->index
, type
);
5603 return error_mark_node
;
5606 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5608 if (complain
& tf_error
)
5609 error ("%qT has no non-static data member named %qD", type
,
5611 return error_mark_node
;
5615 /* If we processed all the member of the class, we are done. */
5619 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5620 /*first_initializer_p=*/false, complain
);
5621 if (field_init
== error_mark_node
)
5622 return error_mark_node
;
5624 if (d
->cur
== old_cur
&& d
->cur
->index
)
5626 /* This can happen with an invalid initializer for a flexible
5627 array member (c++/54441). */
5628 if (complain
& tf_error
)
5629 error ("invalid initializer for %q#D", field
);
5630 return error_mark_node
;
5633 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5637 When a union is initialized with a brace-enclosed
5638 initializer, the braces shall only contain an
5639 initializer for the first member of the union. */
5640 if (TREE_CODE (type
) == UNION_TYPE
)
5643 field
= next_initializable_field (DECL_CHAIN (field
));
5649 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5650 designators are not valid; either complain or return true to indicate
5651 that reshape_init_r should return error_mark_node. */
5654 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5658 if (complain
& tf_error
)
5659 error ("C99 designator %qE outside aggregate initializer",
5667 /* Subroutine of reshape_init, which processes a single initializer (part of
5668 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5669 iterator within the CONSTRUCTOR which points to the initializer to process.
5670 FIRST_INITIALIZER_P is true if this is the first initializer of the
5671 outermost CONSTRUCTOR node. */
5674 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5675 tsubst_flags_t complain
)
5677 tree init
= d
->cur
->value
;
5679 if (error_operand_p (init
))
5680 return error_mark_node
;
5682 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5683 && has_designator_problem (d
, complain
))
5684 return error_mark_node
;
5686 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5688 /* A complex type can be initialized from one or two initializers,
5689 but braces are not elided. */
5691 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5693 if (CONSTRUCTOR_NELTS (init
) > 2)
5695 if (complain
& tf_error
)
5696 error ("too many initializers for %qT", type
);
5698 return error_mark_node
;
5701 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5703 vec
<constructor_elt
, va_gc
> *v
= 0;
5704 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5705 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5706 if (has_designator_problem (d
, complain
))
5707 return error_mark_node
;
5709 init
= build_constructor (init_list_type_node
, v
);
5714 /* A non-aggregate type is always initialized with a single
5716 if (!CP_AGGREGATE_TYPE_P (type
))
5718 /* It is invalid to initialize a non-aggregate type with a
5719 brace-enclosed initializer before C++0x.
5720 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5721 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5722 a CONSTRUCTOR (with a record type). */
5723 if (TREE_CODE (init
) == CONSTRUCTOR
5724 /* Don't complain about a capture-init. */
5725 && !CONSTRUCTOR_IS_DIRECT_INIT (init
)
5726 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5728 if (SCALAR_TYPE_P (type
))
5730 if (cxx_dialect
< cxx11
5731 /* Isn't value-initialization. */
5732 || CONSTRUCTOR_NELTS (init
) > 0)
5734 if (complain
& tf_error
)
5735 error ("braces around scalar initializer for type %qT",
5737 init
= error_mark_node
;
5741 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5748 /* "If T is a class type and the initializer list has a single element of
5749 type cv U, where U is T or a class derived from T, the object is
5750 initialized from that element." Even if T is an aggregate. */
5751 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5752 && first_initializer_p
5753 && d
->end
- d
->cur
== 1
5754 && reference_related_p (type
, TREE_TYPE (init
)))
5762 All implicit type conversions (clause _conv_) are considered when
5763 initializing the aggregate member with an initializer from an
5764 initializer-list. If the initializer can initialize a member,
5765 the member is initialized. Otherwise, if the member is itself a
5766 non-empty subaggregate, brace elision is assumed and the
5767 initializer is considered for the initialization of the first
5768 member of the subaggregate. */
5769 if (TREE_CODE (init
) != CONSTRUCTOR
5770 /* But don't try this for the first initializer, since that would be
5771 looking through the outermost braces; A a2 = { a1 }; is not a
5772 valid aggregate initialization. */
5773 && !first_initializer_p
5774 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5775 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5782 /* [dcl.init.string]
5784 A char array (whether plain char, signed char, or unsigned char)
5785 can be initialized by a string-literal (optionally enclosed in
5786 braces); a wchar_t array can be initialized by a wide
5787 string-literal (optionally enclosed in braces). */
5788 if (TREE_CODE (type
) == ARRAY_TYPE
5789 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5791 tree str_init
= init
;
5793 /* Strip one level of braces if and only if they enclose a single
5794 element (as allowed by [dcl.init.string]). */
5795 if (!first_initializer_p
5796 && TREE_CODE (str_init
) == CONSTRUCTOR
5797 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5799 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5802 /* If it's a string literal, then it's the initializer for the array
5803 as a whole. Otherwise, continue with normal initialization for
5804 array types (one value per array element). */
5805 if (TREE_CODE (str_init
) == STRING_CST
)
5807 if (has_designator_problem (d
, complain
))
5808 return error_mark_node
;
5814 /* The following cases are about aggregates. If we are not within a full
5815 initializer already, and there is not a CONSTRUCTOR, it means that there
5816 is a missing set of braces (that is, we are processing the case for
5817 which reshape_init exists). */
5818 if (!first_initializer_p
)
5820 if (TREE_CODE (init
) == CONSTRUCTOR
)
5822 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5823 /* There is no need to reshape pointer-to-member function
5824 initializers, as they are always constructed correctly
5825 by the front end. */
5827 else if (COMPOUND_LITERAL_P (init
))
5828 /* For a nested compound literal, there is no need to reshape since
5829 brace elision is not allowed. Even if we decided to allow it,
5830 we should add a call to reshape_init in finish_compound_literal,
5831 before calling digest_init, so changing this code would still
5832 not be necessary. */
5833 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5837 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5838 return reshape_init (type
, init
, complain
);
5842 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5846 /* Dispatch to specialized routines. */
5847 if (CLASS_TYPE_P (type
))
5848 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5849 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5850 return reshape_init_array (type
, d
, complain
);
5851 else if (VECTOR_TYPE_P (type
))
5852 return reshape_init_vector (type
, d
, complain
);
5857 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5858 brace-enclosed aggregate initializer.
5860 INIT is the CONSTRUCTOR containing the list of initializers describing
5861 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5862 It may not presently match the shape of the TYPE; for example:
5864 struct S { int a; int b; };
5865 struct S a[] = { 1, 2, 3, 4 };
5867 Here INIT will hold a vector of four elements, rather than a
5868 vector of two elements, each itself a vector of two elements. This
5869 routine transforms INIT from the former form into the latter. The
5870 revised CONSTRUCTOR node is returned. */
5873 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5875 vec
<constructor_elt
, va_gc
> *v
;
5879 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5881 v
= CONSTRUCTOR_ELTS (init
);
5883 /* An empty constructor does not need reshaping, and it is always a valid
5885 if (vec_safe_is_empty (v
))
5888 /* Recurse on this CONSTRUCTOR. */
5890 d
.end
= d
.cur
+ v
->length ();
5892 new_init
= reshape_init_r (type
, &d
, true, complain
);
5893 if (new_init
== error_mark_node
)
5894 return error_mark_node
;
5896 /* Make sure all the element of the constructor were used. Otherwise,
5897 issue an error about exceeding initializers. */
5900 if (complain
& tf_error
)
5901 error ("too many initializers for %qT", type
);
5903 return error_mark_node
;
5909 /* Verify array initializer. Returns true if errors have been reported. */
5912 check_array_initializer (tree decl
, tree type
, tree init
)
5914 tree element_type
= TREE_TYPE (type
);
5916 /* The array type itself need not be complete, because the
5917 initializer may tell us how many elements are in the array.
5918 But, the elements of the array must be complete. */
5919 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5922 error ("elements of array %q#D have incomplete type", decl
);
5924 error ("elements of array %q#T have incomplete type", type
);
5927 /* A compound literal can't have variable size. */
5929 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5930 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5932 error ("variable-sized compound literal");
5938 /* Subroutine of check_initializer; args are passed down from that function.
5939 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5942 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5945 gcc_assert (stmts_are_full_exprs_p ());
5946 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5949 /* Verify INIT (the initializer for DECL), and record the
5950 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5951 grok_reference_init.
5953 If the return value is non-NULL, it is an expression that must be
5954 evaluated dynamically to initialize DECL. */
5957 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5959 tree type
= TREE_TYPE (decl
);
5960 tree init_code
= NULL
;
5963 /* Things that are going to be initialized need to have complete
5965 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5967 if (DECL_HAS_VALUE_EXPR_P (decl
))
5969 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5970 it doesn't have storage to be initialized. */
5971 gcc_assert (init
== NULL_TREE
);
5975 if (type
== error_mark_node
)
5976 /* We will have already complained. */
5979 if (TREE_CODE (type
) == ARRAY_TYPE
)
5981 if (check_array_initializer (decl
, type
, init
))
5984 else if (!COMPLETE_TYPE_P (type
))
5986 error ("%q#D has incomplete type", decl
);
5987 TREE_TYPE (decl
) = error_mark_node
;
5991 /* There is no way to make a variable-sized class type in GNU C++. */
5992 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5994 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5996 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5997 if (SCALAR_TYPE_P (type
))
6001 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
6002 init
= build_zero_init (type
, NULL_TREE
, false);
6004 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
6006 error ("scalar object %qD requires one element in initializer",
6008 TREE_TYPE (decl
) = error_mark_node
;
6014 if (TREE_CODE (decl
) == CONST_DECL
)
6016 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
6018 DECL_INITIAL (decl
) = init
;
6020 gcc_assert (init
!= NULL_TREE
);
6023 else if (!init
&& DECL_REALLY_EXTERN (decl
))
6025 else if (init
|| type_build_ctor_call (type
)
6026 || TREE_CODE (type
) == REFERENCE_TYPE
)
6028 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6030 init
= grok_reference_init (decl
, type
, init
, flags
);
6031 flags
|= LOOKUP_ALREADY_DIGESTED
;
6034 check_for_uninitialized_const_var (decl
);
6035 /* Do not reshape constructors of vectors (they don't need to be
6037 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
6039 if (is_std_init_list (type
))
6041 init
= perform_implicit_conversion (type
, init
,
6042 tf_warning_or_error
);
6043 flags
|= LOOKUP_ALREADY_DIGESTED
;
6045 else if (TYPE_NON_AGGREGATE_CLASS (type
))
6047 /* Don't reshape if the class has constructors. */
6048 if (cxx_dialect
== cxx98
)
6049 error ("in C++98 %qD must be initialized by constructor, "
6053 else if (VECTOR_TYPE_P (type
) && TYPE_VECTOR_OPAQUE (type
))
6055 error ("opaque vector types cannot be initialized");
6056 init
= error_mark_node
;
6060 init
= reshape_init (type
, init
, tf_warning_or_error
);
6061 flags
|= LOOKUP_NO_NARROWING
;
6064 else if (TREE_CODE (init
) == TREE_LIST
6065 && TREE_TYPE (init
) != unknown_type_node
6066 && !MAYBE_CLASS_TYPE_P (type
))
6068 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6070 /* We get here with code like `int a (2);' */
6071 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6072 tf_warning_or_error
);
6075 /* If DECL has an array type without a specific bound, deduce the
6076 array size from the initializer. */
6077 maybe_deduce_size_from_array_init (decl
, init
);
6078 type
= TREE_TYPE (decl
);
6079 if (type
== error_mark_node
)
6082 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
6083 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
6084 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
6085 && CP_AGGREGATE_TYPE_P (type
)
6086 && (CLASS_TYPE_P (type
)
6087 || !TYPE_NEEDS_CONSTRUCTING (type
)
6088 || type_has_extended_temps (type
))))
6090 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
6092 /* A constructor call is a non-trivial initializer even if
6093 it isn't explicitly written. */
6094 if (TREE_SIDE_EFFECTS (init_code
))
6095 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
6097 /* If this is a constexpr initializer, expand_default_init will
6098 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6099 case, pull the initializer back out and pass it down into
6100 store_init_value. */
6101 while (TREE_CODE (init_code
) == EXPR_STMT
6102 || TREE_CODE (init_code
) == CONVERT_EXPR
)
6103 init_code
= TREE_OPERAND (init_code
, 0);
6104 if (TREE_CODE (init_code
) == INIT_EXPR
)
6106 init
= TREE_OPERAND (init_code
, 1);
6107 init_code
= NULL_TREE
;
6108 /* Don't call digest_init; it's unnecessary and will complain
6109 about aggregate initialization of non-aggregate classes. */
6110 flags
|= LOOKUP_ALREADY_DIGESTED
;
6112 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
6114 /* Declared constexpr, but no suitable initializer; massage
6115 init appropriately so we can pass it into store_init_value
6117 if (CLASS_TYPE_P (type
)
6118 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
6120 init
= build_functional_cast (type
, init
, tf_none
);
6121 if (TREE_CODE (init
) == TARGET_EXPR
)
6122 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
6124 init_code
= NULL_TREE
;
6130 if (init
&& TREE_CODE (init
) != TREE_VEC
)
6132 /* In aggregate initialization of a variable, each element
6133 initialization is a full-expression because there is no
6134 enclosing expression. */
6135 gcc_assert (stmts_are_full_exprs_p ());
6137 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
6139 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
6140 && DECL_INITIAL (decl
)
6141 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
6142 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
6143 warning (0, "array %qD initialized by parenthesized string literal %qE",
6144 decl
, DECL_INITIAL (decl
));
6150 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
6151 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
6152 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
6153 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
6156 check_for_uninitialized_const_var (decl
);
6159 if (init
&& init
!= error_mark_node
)
6160 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
6164 /* We might have set these in cp_finish_decl. */
6165 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
6166 TREE_CONSTANT (decl
) = false;
6169 if (init_code
&& DECL_IN_AGGR_P (decl
))
6171 static int explained
= 0;
6173 if (cxx_dialect
< cxx11
)
6174 error ("initializer invalid for static member with constructor");
6176 error ("non-constant in-class initialization invalid for static "
6177 "member %qD", decl
);
6180 inform (input_location
,
6181 "(an out of class initialization is required)");
6190 /* If DECL is not a local variable, give it RTL. */
6193 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6195 int toplev
= toplevel_bindings_p ();
6198 /* Set the DECL_ASSEMBLER_NAME for the object. */
6201 /* The `register' keyword, when used together with an
6202 asm-specification, indicates that the variable should be
6203 placed in a particular register. */
6204 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6206 set_user_assembler_name (decl
, asmspec
);
6207 DECL_HARD_REGISTER (decl
) = 1;
6211 if (TREE_CODE (decl
) == FUNCTION_DECL
6212 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6213 set_builtin_user_assembler_name (decl
, asmspec
);
6214 set_user_assembler_name (decl
, asmspec
);
6218 /* Handle non-variables up front. */
6221 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6225 /* If we see a class member here, it should be a static data
6227 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6229 gcc_assert (TREE_STATIC (decl
));
6230 /* An in-class declaration of a static data member should be
6231 external; it is only a declaration, and not a definition. */
6232 if (init
== NULL_TREE
)
6233 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
6236 /* We don't create any RTL for local variables. */
6237 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6240 /* We defer emission of local statics until the corresponding
6241 DECL_EXPR is expanded. */
6242 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
6244 /* Defer template instantiations. */
6245 if (DECL_LANG_SPECIFIC (decl
)
6246 && DECL_IMPLICIT_INSTANTIATION (decl
))
6249 /* If we're not deferring, go ahead and assemble the variable. */
6251 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6254 /* walk_tree helper for wrap_temporary_cleanups, below. */
6257 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6259 /* Stop at types or full-expression boundaries. */
6260 if (TYPE_P (*stmt_p
)
6261 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6267 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6269 tree guard
= (tree
)data
;
6270 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6272 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6273 /* Tell honor_protect_cleanup_actions to handle this as a separate
6275 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6277 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6283 /* We're initializing a local variable which has a cleanup GUARD. If there
6284 are any temporaries used in the initializer INIT of this variable, we
6285 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6286 variable will be cleaned up properly if one of them throws.
6288 Unfortunately, there's no way to express this properly in terms of
6289 nesting, as the regions for the temporaries overlap the region for the
6290 variable itself; if there are two temporaries, the variable needs to be
6291 the first thing destroyed if either of them throws. However, we only
6292 want to run the variable's cleanup if it actually got constructed. So
6293 we need to guard the temporary cleanups with the variable's cleanup if
6294 they are run on the normal path, but not if they are run on the
6295 exceptional path. We implement this by telling
6296 honor_protect_cleanup_actions to strip the variable cleanup from the
6297 exceptional path. */
6300 wrap_temporary_cleanups (tree init
, tree guard
)
6302 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6305 /* Generate code to initialize DECL (a local variable). */
6308 initialize_local_var (tree decl
, tree init
)
6310 tree type
= TREE_TYPE (decl
);
6314 gcc_assert (VAR_P (decl
)
6315 || TREE_CODE (decl
) == RESULT_DECL
);
6316 gcc_assert (!TREE_STATIC (decl
));
6318 if (DECL_SIZE (decl
) == NULL_TREE
)
6320 /* If we used it already as memory, it must stay in memory. */
6321 DECL_INITIAL (decl
) = NULL_TREE
;
6322 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6326 if (type
== error_mark_node
)
6329 /* Compute and store the initial value. */
6330 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6331 if (TREE_USED (type
))
6332 DECL_READ_P (decl
) = 1;
6334 /* Generate a cleanup, if necessary. */
6335 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6337 /* Perform the initialization. */
6340 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6341 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6342 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6344 /* Stick simple initializers in DECL_INITIAL so that
6345 -Wno-init-self works (c++/34772). */
6346 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6347 DECL_INITIAL (decl
) = rinit
;
6349 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6353 warning_at (DECL_SOURCE_LOCATION (decl
),
6355 "reference %qD is initialized with itself", decl
);
6360 int saved_stmts_are_full_exprs_p
;
6362 /* If we're only initializing a single object, guard the
6363 destructors of any temporaries used in its initializer with
6364 its destructor. This isn't right for arrays because each
6365 element initialization is a full-expression. */
6366 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6367 wrap_temporary_cleanups (init
, cleanup
);
6369 gcc_assert (building_stmt_list_p ());
6370 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6371 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6372 finish_expr_stmt (init
);
6373 current_stmt_tree ()->stmts_are_full_exprs_p
=
6374 saved_stmts_are_full_exprs_p
;
6378 /* Set this to 0 so we can tell whether an aggregate which was
6379 initialized was ever used. Don't do this if it has a
6380 destructor, so we don't complain about the 'resource
6381 allocation is initialization' idiom. Now set
6382 attribute((unused)) on types so decls of that type will be
6383 marked used. (see TREE_USED, above.) */
6384 if (TYPE_NEEDS_CONSTRUCTING (type
)
6386 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6387 && DECL_NAME (decl
))
6388 TREE_USED (decl
) = 0;
6389 else if (already_used
)
6390 TREE_USED (decl
) = 1;
6393 finish_decl_cleanup (decl
, cleanup
);
6396 /* DECL is a VAR_DECL for a compiler-generated variable with static
6397 storage duration (like a virtual table) whose initializer is a
6398 compile-time constant. Initialize the variable and provide it to the
6402 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6405 gcc_assert (DECL_ARTIFICIAL (decl
));
6406 init
= build_constructor (TREE_TYPE (decl
), v
);
6407 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6408 DECL_INITIAL (decl
) = init
;
6409 DECL_INITIALIZED_P (decl
) = 1;
6410 determine_visibility (decl
);
6411 layout_var_decl (decl
);
6412 maybe_commonize_var (decl
);
6413 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6416 /* INIT is the initializer for a variable, as represented by the
6417 parser. Returns true iff INIT is type-dependent. */
6420 type_dependent_init_p (tree init
)
6422 if (TREE_CODE (init
) == TREE_LIST
)
6423 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6424 return any_type_dependent_elements_p (init
);
6425 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6426 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6428 vec
<constructor_elt
, va_gc
> *elts
;
6432 elts
= CONSTRUCTOR_ELTS (init
);
6433 nelts
= vec_safe_length (elts
);
6434 for (i
= 0; i
< nelts
; ++i
)
6435 if (type_dependent_init_p ((*elts
)[i
].value
))
6439 /* It must be a simple expression, e.g., int i = 3; */
6440 return type_dependent_expression_p (init
);
6445 /* INIT is the initializer for a variable, as represented by the
6446 parser. Returns true iff INIT is value-dependent. */
6449 value_dependent_init_p (tree init
)
6451 if (TREE_CODE (init
) == TREE_LIST
)
6452 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6453 return any_value_dependent_elements_p (init
);
6454 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6455 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6457 vec
<constructor_elt
, va_gc
> *elts
;
6461 elts
= CONSTRUCTOR_ELTS (init
);
6462 nelts
= vec_safe_length (elts
);
6463 for (i
= 0; i
< nelts
; ++i
)
6464 if (value_dependent_init_p ((*elts
)[i
].value
))
6468 /* It must be a simple expression, e.g., int i = 3; */
6469 return value_dependent_expression_p (init
);
6474 // Returns true if a DECL is VAR_DECL with the concept specifier.
6476 is_concept_var (tree decl
)
6478 return (VAR_P (decl
)
6479 // Not all variables have DECL_LANG_SPECIFIC.
6480 && DECL_LANG_SPECIFIC (decl
)
6481 && DECL_DECLARED_CONCEPT_P (decl
));
6484 /* Finish processing of a declaration;
6485 install its line number and initial value.
6486 If the length of an array type is not known before,
6487 it must be determined now, from the initial value, or it is an error.
6489 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6490 true, then INIT is an integral constant expression.
6492 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6493 if the (init) syntax was used. */
6496 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6497 tree asmspec_tree
, int flags
)
6500 vec
<tree
, va_gc
> *cleanups
= NULL
;
6501 const char *asmspec
= NULL
;
6502 int was_readonly
= 0;
6503 bool var_definition_p
= false;
6506 if (decl
== error_mark_node
)
6511 error ("assignment (not initialization) in declaration");
6515 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6516 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6517 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6519 type
= TREE_TYPE (decl
);
6520 if (type
== error_mark_node
)
6523 /* If a name was specified, get the string. */
6524 if (at_namespace_scope_p ())
6525 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6526 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6527 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6529 if (current_class_type
6530 && CP_DECL_CONTEXT (decl
) == current_class_type
6531 && TYPE_BEING_DEFINED (current_class_type
)
6532 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6533 && (DECL_INITIAL (decl
) || init
))
6534 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6536 if (TREE_CODE (decl
) != FUNCTION_DECL
6537 && (auto_node
= type_uses_auto (type
)))
6540 if (init
== NULL_TREE
)
6542 if (DECL_LANG_SPECIFIC (decl
)
6543 && DECL_TEMPLATE_INSTANTIATION (decl
)
6544 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6546 /* init is null because we're deferring instantiating the
6547 initializer until we need it. Well, we need it now. */
6548 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6552 error ("declaration of %q#D has no initializer", decl
);
6553 TREE_TYPE (decl
) = error_mark_node
;
6557 if (TREE_CODE (d_init
) == TREE_LIST
)
6558 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6559 tf_warning_or_error
);
6560 d_init
= resolve_nondeduced_context (d_init
);
6561 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6563 tf_warning_or_error
,
6565 if (type
== error_mark_node
)
6567 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6570 if (!ensure_literal_type_for_constexpr_object (decl
))
6571 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6574 && DECL_CLASS_SCOPE_P (decl
)
6575 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6576 check_static_variable_definition (decl
, type
);
6578 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6581 if (init
== ridpointers
[(int)RID_DELETE
])
6583 /* FIXME check this is 1st decl. */
6584 DECL_DELETED_FN (decl
) = 1;
6585 DECL_DECLARED_INLINE_P (decl
) = 1;
6586 DECL_INITIAL (decl
) = error_mark_node
;
6587 FOR_EACH_CLONE (clone
, decl
)
6589 DECL_DELETED_FN (clone
) = 1;
6590 DECL_DECLARED_INLINE_P (clone
) = 1;
6591 DECL_INITIAL (clone
) = error_mark_node
;
6595 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6597 if (defaultable_fn_check (decl
))
6598 DECL_DEFAULTED_FN (decl
) = 1;
6600 DECL_INITIAL (decl
) = NULL_TREE
;
6604 if (init
&& VAR_P (decl
))
6606 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6607 /* If DECL is a reference, then we want to know whether init is a
6608 reference constant; init_const_expr_p as passed tells us whether
6609 it's an rvalue constant. */
6610 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6611 init_const_expr_p
= potential_constant_expression (init
);
6612 if (init_const_expr_p
)
6614 /* Set these flags now for templates. We'll update the flags in
6615 store_init_value for instantiations. */
6616 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6617 if (decl_maybe_constant_var_p (decl
))
6618 TREE_CONSTANT (decl
) = 1;
6622 if (processing_template_decl
)
6624 bool type_dependent_p
;
6626 /* Add this declaration to the statement-tree. */
6627 if (at_function_scope_p ())
6628 add_decl_expr (decl
);
6630 type_dependent_p
= dependent_type_p (type
);
6632 if (check_for_bare_parameter_packs (init
))
6635 DECL_INITIAL (decl
) = NULL_TREE
;
6638 /* Generally, initializers in templates are expanded when the
6639 template is instantiated. But, if DECL is a variable constant
6640 then it can be used in future constant expressions, so its value
6641 must be available. */
6643 if (!VAR_P (decl
) || type_dependent_p
)
6644 /* We can't do anything if the decl has dependent type. */;
6646 && init_const_expr_p
6647 && TREE_CODE (type
) != REFERENCE_TYPE
6648 && decl_maybe_constant_var_p (decl
)
6649 && !type_dependent_init_p (init
)
6650 && !value_dependent_init_p (init
))
6652 /* This variable seems to be a non-dependent constant, so process
6653 its initializer. If check_initializer returns non-null the
6654 initialization wasn't constant after all. */
6656 cleanups
= make_tree_vector ();
6657 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6658 if (init_code
== NULL_TREE
)
6660 release_tree_vector (cleanups
);
6662 else if (!init
&& is_concept_var (decl
))
6663 error ("variable concept has no initializer");
6664 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6666 /* Deduce array size even if the initializer is dependent. */
6667 maybe_deduce_size_from_array_init (decl
, init
);
6668 /* And complain about multiple initializers. */
6669 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6670 && !MAYBE_CLASS_TYPE_P (type
))
6671 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6672 tf_warning_or_error
);
6676 DECL_INITIAL (decl
) = init
;
6680 /* Just store non-static data member initializers for later. */
6681 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6682 DECL_INITIAL (decl
) = init
;
6684 /* Take care of TYPE_DECLs up front. */
6685 if (TREE_CODE (decl
) == TYPE_DECL
)
6687 if (type
!= error_mark_node
6688 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6690 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6691 warning (0, "shadowing previous type declaration of %q#D", decl
);
6692 set_identifier_type_value (DECL_NAME (decl
), decl
);
6695 /* If we have installed this as the canonical typedef for this
6696 type, and that type has not been defined yet, delay emitting
6697 the debug information for it, as we will emit it later. */
6698 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6699 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6700 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6702 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6707 /* A reference will be modified here, as it is initialized. */
6708 if (! DECL_EXTERNAL (decl
)
6709 && TREE_READONLY (decl
)
6710 && TREE_CODE (type
) == REFERENCE_TYPE
)
6713 TREE_READONLY (decl
) = 0;
6718 /* If this is a local variable that will need a mangled name,
6719 register it now. We must do this before processing the
6720 initializer for the variable, since the initialization might
6721 require a guard variable, and since the mangled name of the
6722 guard variable will depend on the mangled name of this
6724 if (DECL_FUNCTION_SCOPE_P (decl
)
6725 && TREE_STATIC (decl
)
6726 && !DECL_ARTIFICIAL (decl
))
6728 push_local_name (decl
);
6729 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6730 || DECL_DESTRUCTOR_P (current_function_decl
))
6731 /* Normally local_decls is populated during GIMPLE lowering,
6732 but [cd]tors are never actually compiled directly. We need
6733 to put statics on the list so we can deal with the label
6734 address extension. FIXME. */
6735 add_local_decl (cfun
, decl
);
6736 /* And make sure it's in the symbol table for
6737 c_parse_final_cleanups to find. */
6738 varpool_node::get_create (decl
);
6741 /* Convert the initializer to the type of DECL, if we have not
6742 already initialized DECL. */
6743 if (!DECL_INITIALIZED_P (decl
)
6744 /* If !DECL_EXTERNAL then DECL is being defined. In the
6745 case of a static data member initialized inside the
6746 class-specifier, there can be an initializer even if DECL
6747 is *not* defined. */
6748 && (!DECL_EXTERNAL (decl
) || init
))
6750 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6753 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6754 /* Allow libjava/prims.cc define primitive classes. */
6755 if (init
!= NULL_TREE
6756 || jclass
== NULL_TREE
6757 || TREE_CODE (jclass
) != TYPE_DECL
6758 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6759 || !same_type_ignoring_top_level_qualifiers_p
6760 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6761 error ("Java object %qD not allocated with %<new%>", decl
);
6764 cleanups
= make_tree_vector ();
6765 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6771 The memory occupied by any object of static storage
6772 duration is zero-initialized at program startup before
6773 any other initialization takes place.
6775 We cannot create an appropriate initializer until after
6776 the type of DECL is finalized. If DECL_INITIAL is set,
6777 then the DECL is statically initialized, and any
6778 necessary zero-initialization has already been performed. */
6779 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6780 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6781 /*nelts=*/NULL_TREE
,
6782 /*static_storage_p=*/true);
6783 /* Remember that the initialization for this variable has
6785 DECL_INITIALIZED_P (decl
) = 1;
6786 /* This declaration is the definition of this variable,
6787 unless we are initializing a static data member within
6788 the class specifier. */
6789 if (!DECL_EXTERNAL (decl
))
6790 var_definition_p
= true;
6792 /* If the variable has an array type, lay out the type, even if
6793 there is no initializer. It is valid to index through the
6794 array, and we must get TYPE_ALIGN set correctly on the array
6796 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6799 if (TREE_STATIC (decl
)
6800 && !at_function_scope_p ()
6801 && current_function_decl
== NULL
)
6802 /* So decl is a global variable or a static member of a
6803 non local class. Record the types it uses
6804 so that we can decide later to emit debug info for them. */
6805 record_types_used_by_current_var_decl (decl
);
6807 else if (TREE_CODE (decl
) == FIELD_DECL
6808 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6809 error ("non-static data member %qD has Java class type", decl
);
6811 /* Add this declaration to the statement-tree. This needs to happen
6812 after the call to check_initializer so that the DECL_EXPR for a
6813 reference temp is added before the DECL_EXPR for the reference itself. */
6814 if (DECL_FUNCTION_SCOPE_P (decl
))
6816 /* If we're building a variable sized type, and we might be
6817 reachable other than via the top of the current binding
6818 level, then create a new BIND_EXPR so that we deallocate
6819 the object at the right time. */
6822 && !TREE_CONSTANT (DECL_SIZE (decl
))
6823 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
6826 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6827 TREE_SIDE_EFFECTS (bind
) = 1;
6829 BIND_EXPR_BODY (bind
) = push_stmt_list ();
6831 add_decl_expr (decl
);
6834 /* Let the middle end know about variables and functions -- but not
6835 static data members in uninstantiated class templates. */
6836 if (VAR_OR_FUNCTION_DECL_P (decl
))
6840 layout_var_decl (decl
);
6841 maybe_commonize_var (decl
);
6844 /* This needs to happen after the linkage is set. */
6845 determine_visibility (decl
);
6847 if (var_definition_p
&& TREE_STATIC (decl
))
6849 /* If a TREE_READONLY variable needs initialization
6850 at runtime, it is no longer readonly and we need to
6851 avoid MEM_READONLY_P being set on RTL created for it. */
6854 if (TREE_READONLY (decl
))
6855 TREE_READONLY (decl
) = 0;
6858 else if (was_readonly
)
6859 TREE_READONLY (decl
) = 1;
6861 /* Likewise if it needs destruction. */
6862 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6863 TREE_READONLY (decl
) = 0;
6866 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6868 /* Check for abstractness of the type. Notice that there is no
6869 need to strip array types here since the check for those types
6870 is already done within create_array_type_for_decl. */
6871 abstract_virtuals_error (decl
, type
);
6873 if (TREE_TYPE (decl
) == error_mark_node
)
6874 /* No initialization required. */
6876 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6880 if (init
== ridpointers
[(int)RID_DEFAULT
])
6882 /* An out-of-class default definition is defined at
6883 the point where it is explicitly defaulted. */
6884 if (DECL_DELETED_FN (decl
))
6885 maybe_explain_implicit_delete (decl
);
6886 else if (DECL_INITIAL (decl
) == error_mark_node
)
6887 synthesize_method (decl
);
6890 error ("function %q#D is initialized like a variable", decl
);
6892 /* else no initialization required. */
6894 else if (DECL_EXTERNAL (decl
)
6895 && ! (DECL_LANG_SPECIFIC (decl
)
6896 && DECL_NOT_REALLY_EXTERN (decl
)))
6899 DECL_INITIAL (decl
) = init
;
6901 /* A variable definition. */
6902 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6903 /* Initialize the local variable. */
6904 initialize_local_var (decl
, init
);
6906 /* If a variable is defined, and then a subsequent
6907 definition with external linkage is encountered, we will
6908 get here twice for the same variable. We want to avoid
6909 calling expand_static_init more than once. For variables
6910 that are not static data members, we can call
6911 expand_static_init only when we actually process the
6912 initializer. It is not legal to redeclare a static data
6913 member, so this issue does not arise in that case. */
6914 else if (var_definition_p
&& TREE_STATIC (decl
))
6915 expand_static_init (decl
, init
);
6918 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6919 reference, insert it in the statement-tree now. */
6923 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6924 push_cleanup (decl
, t
, false);
6925 release_tree_vector (cleanups
);
6929 TREE_READONLY (decl
) = 1;
6931 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6934 /* Returns a declaration for a VAR_DECL as if:
6936 extern "C" TYPE NAME;
6938 had been seen. Used to create compiler-generated global
6942 declare_global_var (tree name
, tree type
)
6946 push_to_top_level ();
6947 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6948 TREE_PUBLIC (decl
) = 1;
6949 DECL_EXTERNAL (decl
) = 1;
6950 DECL_ARTIFICIAL (decl
) = 1;
6951 /* If the user has explicitly declared this variable (perhaps
6952 because the code we are compiling is part of a low-level runtime
6953 library), then it is possible that our declaration will be merged
6954 with theirs by pushdecl. */
6955 decl
= pushdecl (decl
);
6956 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6957 pop_from_top_level ();
6962 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6963 if "__cxa_atexit" is not being used) corresponding to the function
6964 to be called when the program exits. */
6967 get_atexit_fn_ptr_type (void)
6971 if (!atexit_fn_ptr_type_node
)
6974 if (flag_use_cxa_atexit
6975 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6976 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6977 arg_type
= ptr_type_node
;
6979 /* The parameter to "atexit" is "void (*)(void)". */
6980 arg_type
= NULL_TREE
;
6982 fn_type
= build_function_type_list (void_type_node
,
6983 arg_type
, NULL_TREE
);
6984 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6987 return atexit_fn_ptr_type_node
;
6990 /* Returns a pointer to the `atexit' function. Note that if
6991 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6992 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6995 get_atexit_node (void)
7001 bool use_aeabi_atexit
;
7006 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
7008 /* The declaration for `__cxa_atexit' is:
7010 int __cxa_atexit (void (*)(void *), void *, void *)
7012 We build up the argument types and then the function type
7014 tree argtype0
, argtype1
, argtype2
;
7016 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
7017 /* First, build the pointer-to-function type for the first
7019 fn_ptr_type
= get_atexit_fn_ptr_type ();
7020 /* Then, build the rest of the argument types. */
7021 argtype2
= ptr_type_node
;
7022 if (use_aeabi_atexit
)
7024 argtype1
= fn_ptr_type
;
7025 argtype0
= ptr_type_node
;
7029 argtype1
= ptr_type_node
;
7030 argtype0
= fn_ptr_type
;
7032 /* And the final __cxa_atexit type. */
7033 fn_type
= build_function_type_list (integer_type_node
,
7034 argtype0
, argtype1
, argtype2
,
7036 if (use_aeabi_atexit
)
7037 name
= "__aeabi_atexit";
7039 name
= "__cxa_atexit";
7043 /* The declaration for `atexit' is:
7045 int atexit (void (*)());
7047 We build up the argument types and then the function type
7049 fn_ptr_type
= get_atexit_fn_ptr_type ();
7050 /* Build the final atexit type. */
7051 fn_type
= build_function_type_list (integer_type_node
,
7052 fn_ptr_type
, NULL_TREE
);
7056 /* Now, build the function declaration. */
7057 push_lang_context (lang_name_c
);
7058 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
7059 mark_used (atexit_fndecl
);
7060 pop_lang_context ();
7061 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7066 /* Like get_atexit_node, but for thread-local cleanups. */
7069 get_thread_atexit_node (void)
7071 /* The declaration for `__cxa_thread_atexit' is:
7073 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
7074 tree fn_type
= build_function_type_list (integer_type_node
,
7075 get_atexit_fn_ptr_type (),
7076 ptr_type_node
, ptr_type_node
,
7079 /* Now, build the function declaration. */
7080 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
7081 ECF_LEAF
| ECF_NOTHROW
);
7082 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
7085 /* Returns the __dso_handle VAR_DECL. */
7088 get_dso_handle_node (void)
7090 if (dso_handle_node
)
7091 return dso_handle_node
;
7093 /* Declare the variable. */
7094 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
7097 #ifdef HAVE_GAS_HIDDEN
7098 if (dso_handle_node
!= error_mark_node
)
7100 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
7101 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
7105 return dso_handle_node
;
7108 /* Begin a new function with internal linkage whose job will be simply
7109 to destroy some particular variable. */
7111 static GTY(()) int start_cleanup_cnt
;
7114 start_cleanup_fn (void)
7119 bool use_cxa_atexit
= flag_use_cxa_atexit
7120 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
7122 push_to_top_level ();
7124 /* No need to mangle this. */
7125 push_lang_context (lang_name_c
);
7127 /* Build the name of the function. */
7128 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
7129 /* Build the function declaration. */
7130 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
7131 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
7132 /* It's a function with internal linkage, generated by the
7134 TREE_PUBLIC (fndecl
) = 0;
7135 DECL_ARTIFICIAL (fndecl
) = 1;
7136 /* Make the function `inline' so that it is only emitted if it is
7137 actually needed. It is unlikely that it will be inlined, since
7138 it is only called via a function pointer, but we avoid unnecessary
7139 emissions this way. */
7140 DECL_DECLARED_INLINE_P (fndecl
) = 1;
7141 DECL_INTERFACE_KNOWN (fndecl
) = 1;
7142 /* Build the parameter. */
7147 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
7148 DECL_CONTEXT (parmdecl
) = fndecl
;
7149 TREE_USED (parmdecl
) = 1;
7150 DECL_READ_P (parmdecl
) = 1;
7151 DECL_ARGUMENTS (fndecl
) = parmdecl
;
7155 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
7157 pop_lang_context ();
7159 return current_function_decl
;
7162 /* Finish the cleanup function begun by start_cleanup_fn. */
7165 end_cleanup_fn (void)
7167 expand_or_defer_fn (finish_function (0));
7169 pop_from_top_level ();
7172 /* Generate code to handle the destruction of DECL, an object with
7173 static storage duration. */
7176 register_dtor_fn (tree decl
)
7183 bool ob_parm
, dso_parm
, use_dtor
;
7184 tree arg0
, arg1
, arg2
;
7187 type
= TREE_TYPE (decl
);
7188 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7191 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7192 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7193 destructor to "__cxa_atexit"; we don't have to build a temporary
7194 function to do the cleanup. */
7195 dso_parm
= (flag_use_cxa_atexit
7196 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7197 ob_parm
= (CP_DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7198 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7203 /* Find the destructor. */
7204 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
7205 gcc_assert (idx
>= 0);
7206 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
7207 /* Make sure it is accessible. */
7208 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7209 tf_warning_or_error
);
7213 /* Call build_cleanup before we enter the anonymous function so
7214 that any access checks will be done relative to the current
7215 scope, rather than the scope of the anonymous function. */
7216 build_cleanup (decl
);
7218 /* Now start the function. */
7219 cleanup
= start_cleanup_fn ();
7221 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7222 to the original function, rather than the anonymous one. That
7223 will make the back end think that nested functions are in use,
7224 which causes confusion. */
7225 push_deferring_access_checks (dk_no_check
);
7226 fcall
= build_cleanup (decl
);
7227 pop_deferring_access_checks ();
7229 /* Create the body of the anonymous function. */
7230 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7231 finish_expr_stmt (fcall
);
7232 finish_compound_stmt (compound_stmt
);
7236 /* Call atexit with the cleanup function. */
7237 mark_used (cleanup
);
7238 cleanup
= build_address (cleanup
);
7240 if (CP_DECL_THREAD_LOCAL_P (decl
))
7241 atex_node
= get_thread_atexit_node ();
7243 atex_node
= get_atexit_node ();
7247 /* We must convert CLEANUP to the type that "__cxa_atexit"
7249 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7250 /* "__cxa_atexit" will pass the address of DECL to the
7251 cleanup function. */
7253 addr
= build_address (decl
);
7254 /* The declared type of the parameter to "__cxa_atexit" is
7255 "void *". For plain "T*", we could just let the
7256 machinery in cp_build_function_call convert it -- but if the
7257 type is "cv-qualified T *", then we need to convert it
7258 before passing it in, to avoid spurious errors. */
7259 addr
= build_nop (ptr_type_node
, addr
);
7262 /* Since the cleanup functions we build ignore the address
7263 they're given, there's no reason to pass the actual address
7264 in, and, in general, it's cheaper to pass NULL than any
7266 addr
= null_pointer_node
;
7269 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7270 tf_warning_or_error
);
7272 /* Just pass NULL to the dso handle parm if we don't actually
7273 have a DSO handle on this target. */
7274 arg2
= null_pointer_node
;
7280 if (!CP_DECL_THREAD_LOCAL_P (decl
)
7281 && targetm
.cxx
.use_aeabi_atexit ())
7297 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7298 arg0
, arg1
, arg2
, NULL_TREE
);
7301 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7302 is its initializer. Generate code to handle the construction
7303 and destruction of DECL. */
7306 expand_static_init (tree decl
, tree init
)
7308 gcc_assert (VAR_P (decl
));
7309 gcc_assert (TREE_STATIC (decl
));
7311 /* Some variables require no dynamic initialization. */
7312 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7314 /* Make sure the destructor is callable. */
7315 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7320 if (CP_DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7321 && !DECL_FUNCTION_SCOPE_P (decl
))
7324 error ("non-local variable %qD declared %<__thread%> "
7325 "needs dynamic initialization", decl
);
7327 error ("non-local variable %qD declared %<__thread%> "
7328 "has a non-trivial destructor", decl
);
7329 static bool informed
;
7332 inform (DECL_SOURCE_LOCATION (decl
),
7333 "C++11 %<thread_local%> allows dynamic initialization "
7340 if (DECL_FUNCTION_SCOPE_P (decl
))
7342 /* Emit code to perform this initialization but once. */
7343 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7344 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7345 tree guard
, guard_addr
;
7347 /* We don't need thread-safety code for thread-local vars. */
7348 bool thread_guard
= (flag_threadsafe_statics
7349 && !CP_DECL_THREAD_LOCAL_P (decl
));
7351 /* Emit code to perform this initialization but once. This code
7354 static <type> guard;
7355 if (!__atomic_load (guard.first_byte)) {
7356 if (__cxa_guard_acquire (&guard)) {
7359 // Do initialization.
7360 flag = true; __cxa_guard_release (&guard);
7361 // Register variable for destruction at end of program.
7363 if (!flag) __cxa_guard_abort (&guard);
7367 Note that the `flag' variable is only set to 1 *after* the
7368 initialization is complete. This ensures that an exception,
7369 thrown during the construction, will cause the variable to
7370 reinitialized when we pass through this code again, as per:
7374 If the initialization exits by throwing an exception, the
7375 initialization is not complete, so it will be tried again
7376 the next time control enters the declaration.
7378 This process should be thread-safe, too; multiple threads
7379 should not be able to initialize the variable more than
7382 /* Create the guard variable. */
7383 guard
= get_guard (decl
);
7385 /* Begin the conditional initialization. */
7386 if_stmt
= begin_if_stmt ();
7388 finish_if_stmt_cond (get_guard_cond (guard
, thread_guard
), if_stmt
);
7389 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7393 tree vfntype
= NULL_TREE
;
7394 tree acquire_name
, release_name
, abort_name
;
7395 tree acquire_fn
, release_fn
, abort_fn
;
7396 guard_addr
= build_address (guard
);
7398 acquire_name
= get_identifier ("__cxa_guard_acquire");
7399 release_name
= get_identifier ("__cxa_guard_release");
7400 abort_name
= get_identifier ("__cxa_guard_abort");
7401 acquire_fn
= identifier_global_value (acquire_name
);
7402 release_fn
= identifier_global_value (release_name
);
7403 abort_fn
= identifier_global_value (abort_name
);
7405 acquire_fn
= push_library_fn
7406 (acquire_name
, build_function_type_list (integer_type_node
,
7407 TREE_TYPE (guard_addr
),
7409 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7410 if (!release_fn
|| !abort_fn
)
7411 vfntype
= build_function_type_list (void_type_node
,
7412 TREE_TYPE (guard_addr
),
7415 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7416 ECF_NOTHROW
| ECF_LEAF
);
7418 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7419 ECF_NOTHROW
| ECF_LEAF
);
7421 inner_if_stmt
= begin_if_stmt ();
7422 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7425 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7426 begin
= get_target_expr (boolean_false_node
);
7427 flag
= TARGET_EXPR_SLOT (begin
);
7429 TARGET_EXPR_CLEANUP (begin
)
7430 = build3 (COND_EXPR
, void_type_node
, flag
,
7432 build_call_n (abort_fn
, 1, guard_addr
));
7433 CLEANUP_EH_ONLY (begin
) = 1;
7435 /* Do the initialization itself. */
7436 init
= add_stmt_to_compound (begin
, init
);
7437 init
= add_stmt_to_compound
7438 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7439 init
= add_stmt_to_compound
7440 (init
, build_call_n (release_fn
, 1, guard_addr
));
7443 init
= add_stmt_to_compound (init
, set_guard (guard
));
7445 /* Use atexit to register a function for destroying this static
7447 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7449 finish_expr_stmt (init
);
7453 finish_compound_stmt (inner_then_clause
);
7454 finish_then_clause (inner_if_stmt
);
7455 finish_if_stmt (inner_if_stmt
);
7458 finish_compound_stmt (then_clause
);
7459 finish_then_clause (if_stmt
);
7460 finish_if_stmt (if_stmt
);
7462 else if (CP_DECL_THREAD_LOCAL_P (decl
))
7463 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7465 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7469 /* Make TYPE a complete type based on INITIAL_VALUE.
7470 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7471 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7472 3 if the initializer list is empty (in pedantic mode). */
7475 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7478 tree type
, elt_type
;
7480 /* Don't get confused by a CONSTRUCTOR for some other type. */
7481 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
7482 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
))
7487 unsigned HOST_WIDE_INT i
;
7490 /* An array of character type can be initialized from a
7491 brace-enclosed string constant.
7493 FIXME: this code is duplicated from reshape_init. Probably
7494 we should just call reshape_init here? */
7495 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7496 && TREE_CODE (initial_value
) == CONSTRUCTOR
7497 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7499 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7500 tree value
= (*v
)[0].value
;
7502 if (TREE_CODE (value
) == STRING_CST
7503 && v
->length () == 1)
7504 initial_value
= value
;
7507 /* If any of the elements are parameter packs, we can't actually
7508 complete this type now because the array size is dependent. */
7509 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7511 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7514 if (PACK_EXPANSION_P (value
))
7520 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7522 /* We can create the array before the element type is complete, which
7523 means that we didn't have these two bits set in the original type
7524 either. In completing the type, we are expected to propagate these
7525 bits. See also complete_type which does the same thing for arrays
7528 if (TYPE_DOMAIN (type
))
7530 elt_type
= TREE_TYPE (type
);
7531 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7532 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7533 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7539 /* As above, but either give an error or reject zero-size arrays, depending
7543 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7544 bool do_default
, tsubst_flags_t complain
)
7547 bool sfinae
= !(complain
& tf_error
);
7548 /* In SFINAE context we can't be lenient about zero-size arrays. */
7551 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7557 /* Not an error. */;
7558 else if (failure
== 1)
7559 error ("initializer fails to determine size of %qT", *ptype
);
7560 else if (failure
== 2)
7563 error ("array size missing in %qT", *ptype
);
7565 else if (failure
== 3)
7566 error ("zero-size array %qT", *ptype
);
7567 *ptype
= error_mark_node
;
7572 /* Return zero if something is declared to be a member of type
7573 CTYPE when in the context of CUR_TYPE. STRING is the error
7574 message to print in that case. Otherwise, quietly return 1. */
7577 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7579 if (ctype
&& ctype
!= cur_type
)
7581 if (flags
== DTOR_FLAG
)
7582 error ("destructor for alien class %qT cannot be a member", ctype
);
7584 error ("constructor for alien class %qT cannot be a member", ctype
);
7590 /* Subroutine of `grokdeclarator'. */
7592 /* Generate errors possibly applicable for a given set of specifiers.
7593 This is for ARM $7.1.2. */
7596 bad_specifiers (tree object
,
7597 enum bad_spec_place type
,
7608 error ("%qD declared as a %<virtual%> variable", object
);
7610 error ("%qD declared as an %<inline%> variable", object
);
7612 error ("%<const%> and %<volatile%> function specifiers on "
7613 "%qD invalid in variable declaration", object
);
7617 error ("%qD declared as a %<virtual%> parameter", object
);
7619 error ("%qD declared as an %<inline%> parameter", object
);
7621 error ("%<const%> and %<volatile%> function specifiers on "
7622 "%qD invalid in parameter declaration", object
);
7626 error ("%qD declared as a %<virtual%> type", object
);
7628 error ("%qD declared as an %<inline%> type", object
);
7630 error ("%<const%> and %<volatile%> function specifiers on "
7631 "%qD invalid in type declaration", object
);
7635 error ("%qD declared as a %<virtual%> field", object
);
7637 error ("%qD declared as an %<inline%> field", object
);
7639 error ("%<const%> and %<volatile%> function specifiers on "
7640 "%qD invalid in field declaration", object
);
7646 error ("%q+D declared as a friend", object
);
7648 && (TREE_CODE (object
) == TYPE_DECL
7649 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7650 && !TYPE_REFFN_P (TREE_TYPE (object
))
7651 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7652 error ("%q+D declared with an exception specification", object
);
7655 /* DECL is a member function or static data member and is presently
7656 being defined. Check that the definition is taking place in a
7660 check_class_member_definition_namespace (tree decl
)
7662 /* These checks only apply to member functions and static data
7664 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7665 /* We check for problems with specializations in pt.c in
7666 check_specialization_namespace, where we can issue better
7668 if (processing_specialization
)
7670 /* There are no restrictions on the placement of
7671 explicit instantiations. */
7672 if (processing_explicit_instantiation
)
7676 A member function definition that appears outside of the
7677 class definition shall appear in a namespace scope enclosing
7678 the class definition.
7682 The definition for a static data member shall appear in a
7683 namespace scope enclosing the member's class definition. */
7684 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7685 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7686 decl
, DECL_CONTEXT (decl
));
7689 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7690 METHOD_TYPE for a non-static member function; QUALS are the
7691 cv-qualifiers that apply to the function. */
7694 build_this_parm (tree type
, cp_cv_quals quals
)
7699 cp_cv_quals this_quals
;
7701 if (CLASS_TYPE_P (type
))
7704 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7705 this_type
= build_pointer_type (this_type
);
7708 this_type
= type_of_this_parm (type
);
7709 /* The `this' parameter is implicitly `const'; it cannot be
7711 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7712 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7713 parm
= build_artificial_parm (this_identifier
, qual_type
);
7714 cp_apply_type_quals_to_decl (this_quals
, parm
);
7718 /* DECL is a static member function. Complain if it was declared
7719 with function-cv-quals. */
7722 check_static_quals (tree decl
, cp_cv_quals quals
)
7724 if (quals
!= TYPE_UNQUALIFIED
)
7725 error ("static member function %q#D declared with type qualifiers",
7729 // Check that FN takes no arguments and returns bool.
7731 check_concept_fn (tree fn
)
7733 // A constraint is nullary.
7734 if (DECL_ARGUMENTS (fn
))
7735 error ("concept %q#D declared with function parameters", fn
);
7737 // The declared return type of the concept shall be bool, and
7738 // it shall not be deduced from it definition.
7739 tree type
= TREE_TYPE (TREE_TYPE (fn
));
7741 error ("concept %q#D declared with a deduced return type", fn
);
7742 else if (type
!= boolean_type_node
)
7743 error ("concept %q#D with non-%<bool%> return type %qT", fn
, type
);
7746 /* Helper function. Replace the temporary this parameter injected
7747 during cp_finish_omp_declare_simd with the real this parameter. */
7750 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7752 tree this_parm
= (tree
) data
;
7753 if (TREE_CODE (*tp
) == PARM_DECL
7754 && DECL_NAME (*tp
) == this_identifier
7755 && *tp
!= this_parm
)
7757 else if (TYPE_P (*tp
))
7762 /* CTYPE is class type, or null if non-class.
7763 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7765 DECLARATOR is the function's name.
7766 PARMS is a chain of PARM_DECLs for the function.
7767 VIRTUALP is truthvalue of whether the function is virtual or not.
7768 FLAGS are to be passed through to `grokclassfn'.
7769 QUALS are qualifiers indicating whether the function is `const'
7771 RAISES is a list of exceptions that this function can raise.
7772 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7773 not look, and -1 if we should not call `grokclassfn' at all.
7775 SFK is the kind of special function (if any) for the new function.
7777 Returns `NULL_TREE' if something goes wrong, after issuing
7778 applicable error messages. */
7781 grokfndecl (tree ctype
,
7785 tree orig_declarator
,
7788 enum overload_flags flags
,
7790 cp_ref_qualifier rqual
,
7797 special_function_kind sfk
,
7802 location_t location
)
7805 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7808 // Was the concept specifier present?
7809 bool concept_p
= inlinep
& 4;
7811 // Concept declarations must have a corresponding definition.
7812 if (concept_p
&& !funcdef_flag
)
7814 error ("concept %qD has no definition", declarator
);
7819 type
= build_ref_qualified_type (type
, rqual
);
7821 type
= build_exception_variant (type
, raises
);
7823 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7825 /* Set the constraints on the declaration. */
7828 tree tmpl_reqs
= NULL_TREE
;
7829 if (processing_template_decl
> template_class_depth (ctype
))
7830 tmpl_reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
7832 /* Adjust the required expression into a constraint. */
7834 decl_reqs
= make_predicate_constraint (decl_reqs
);
7836 tree ci
= build_constraints (tmpl_reqs
, decl_reqs
);
7837 set_constraints (decl
, ci
);
7840 /* If we have an explicit location, use it, otherwise use whatever
7841 build_lang_decl used (probably input_location). */
7842 if (location
!= UNKNOWN_LOCATION
)
7843 DECL_SOURCE_LOCATION (decl
) = location
;
7845 if (TREE_CODE (type
) == METHOD_TYPE
)
7848 parm
= build_this_parm (type
, quals
);
7849 DECL_CHAIN (parm
) = parms
;
7852 /* Allocate space to hold the vptr bit if needed. */
7853 DECL_ALIGN (decl
) = MINIMUM_METHOD_BOUNDARY
;
7855 DECL_ARGUMENTS (decl
) = parms
;
7856 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7857 DECL_CONTEXT (t
) = decl
;
7858 /* Propagate volatile out from type to decl. */
7859 if (TYPE_VOLATILE (type
))
7860 TREE_THIS_VOLATILE (decl
) = 1;
7862 /* Setup decl according to sfk. */
7865 case sfk_constructor
:
7866 case sfk_copy_constructor
:
7867 case sfk_move_constructor
:
7868 DECL_CONSTRUCTOR_P (decl
) = 1;
7870 case sfk_destructor
:
7871 DECL_DESTRUCTOR_P (decl
) = 1;
7878 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7882 ("defining explicit specialization %qD in friend declaration",
7886 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7887 tree args
= TREE_OPERAND (orig_declarator
, 1);
7889 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7891 /* Something like `template <class T> friend void f<T>()'. */
7892 error ("invalid use of template-id %qD in declaration "
7893 "of primary template",
7899 /* A friend declaration of the form friend void f<>(). Record
7900 the information in the TEMPLATE_ID_EXPR. */
7901 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7903 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7904 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7906 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7907 if (TREE_PURPOSE (t
)
7908 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7910 error ("default arguments are not allowed in declaration "
7911 "of friend template specialization %qD",
7918 error ("%<inline%> is not allowed in declaration of friend "
7919 "template specialization %qD",
7926 /* If this decl has namespace scope, set that up. */
7928 set_decl_namespace (decl
, in_namespace
, friendp
);
7930 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7932 /* `main' and builtins have implicit 'C' linkage. */
7933 if ((MAIN_NAME_P (declarator
)
7934 || (IDENTIFIER_LENGTH (declarator
) > 10
7935 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7936 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7937 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
7938 || (targetcm
.cxx_implicit_extern_c
7939 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
7940 && current_lang_name
== lang_name_cplusplus
7941 && ctype
== NULL_TREE
7942 && DECL_FILE_SCOPE_P (decl
))
7943 SET_DECL_LANGUAGE (decl
, lang_c
);
7945 /* Should probably propagate const out from type to decl I bet (mrs). */
7948 DECL_STATIC_FUNCTION_P (decl
) = 1;
7949 DECL_CONTEXT (decl
) = ctype
;
7953 DECL_DELETED_FN (decl
) = 1;
7957 DECL_CONTEXT (decl
) = ctype
;
7959 check_class_member_definition_namespace (decl
);
7962 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7964 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7965 error ("cannot declare %<::main%> to be a template");
7967 error ("cannot declare %<::main%> to be inline");
7969 error ("cannot declare %<::main%> to be constexpr");
7971 error ("cannot declare %<::main%> to be static");
7976 /* Members of anonymous types and local classes have no linkage; make
7977 them internal. If a typedef is made later, this will be changed. */
7978 if (ctype
&& (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype
))
7979 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7982 if (publicp
&& cxx_dialect
== cxx98
)
7984 /* [basic.link]: A name with no linkage (notably, the name of a class
7985 or enumeration declared in a local scope) shall not be used to
7986 declare an entity with linkage.
7988 DR 757 relaxes this restriction for C++0x. */
7989 no_linkage_error (decl
);
7992 TREE_PUBLIC (decl
) = publicp
;
7995 DECL_INTERFACE_KNOWN (decl
) = 1;
7996 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7999 /* If the declaration was declared inline, mark it as such. */
8002 DECL_DECLARED_INLINE_P (decl
) = 1;
8004 DECL_COMDAT (decl
) = 1;
8007 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
8009 // If the concept declaration specifier was found, check
8010 // that the declaration satisfies the necessary requirements.
8013 DECL_DECLARED_CONCEPT_P (decl
) = true;
8014 check_concept_fn (decl
);
8017 DECL_EXTERNAL (decl
) = 1;
8018 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8021 TREE_TYPE (decl
) = apply_memfn_quals (TREE_TYPE (decl
),
8028 ? G_("static member function %qD cannot have cv-qualifier")
8029 : G_("non-member function %qD cannot have cv-qualifier"),
8031 quals
= TYPE_UNQUALIFIED
;
8037 ? G_("static member function %qD cannot have ref-qualifier")
8038 : G_("non-member function %qD cannot have ref-qualifier"),
8040 rqual
= REF_QUAL_NONE
;
8044 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
8045 && !grok_op_properties (decl
, /*complain=*/true))
8047 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
8049 bool long_long_unsigned_p
;
8051 const char *suffix
= NULL
;
8052 /* [over.literal]/6: Literal operators shall not have C linkage. */
8053 if (DECL_LANGUAGE (decl
) == lang_c
)
8055 error ("literal operator with C linkage");
8059 if (DECL_NAMESPACE_SCOPE_P (decl
))
8061 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
8064 error ("%qD has invalid argument list", decl
);
8068 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
8069 if (long_long_unsigned_p
)
8071 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
8072 warning (0, "integer suffix %<%s%>"
8073 " shadowed by implementation", suffix
);
8075 else if (long_double_p
)
8077 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
8078 warning (0, "floating point suffix %<%s%>"
8079 " shadowed by implementation", suffix
);
8084 error ("%qD must be a non-member function", decl
);
8090 /* Make the init_value nonzero so pushdecl knows this is not
8091 tentative. error_mark_node is replaced later with the BLOCK. */
8092 DECL_INITIAL (decl
) = error_mark_node
;
8094 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
8095 TREE_NOTHROW (decl
) = 1;
8097 if (flag_openmp
|| flag_openmp_simd
|| flag_cilkplus
)
8099 /* Adjust "omp declare simd" attributes. */
8100 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
8104 for (attr
= ods
; attr
;
8105 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
8107 if (TREE_CODE (type
) == METHOD_TYPE
)
8108 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
8109 DECL_ARGUMENTS (decl
), NULL
);
8110 if (TREE_VALUE (attr
) != NULL_TREE
)
8112 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
8113 cl
= c_omp_declare_simd_clauses_to_numbers
8114 (DECL_ARGUMENTS (decl
), cl
);
8116 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
8118 TREE_VALUE (attr
) = NULL_TREE
;
8124 /* Caller will do the rest of this. */
8128 if (ctype
!= NULL_TREE
)
8129 grokclassfn (ctype
, decl
, flags
);
8132 if (cxx_dialect
>= cxx11
8133 && DECL_DESTRUCTOR_P (decl
)
8134 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
8135 && !processing_template_decl
)
8136 deduce_noexcept_on_destructor (decl
);
8138 decl
= check_explicit_specialization (orig_declarator
, decl
,
8141 4 * (friendp
!= 0) +
8143 if (decl
== error_mark_node
)
8146 if (DECL_STATIC_FUNCTION_P (decl
))
8147 check_static_quals (decl
, quals
);
8151 cplus_decl_attributes (&decl
, *attrlist
, 0);
8152 *attrlist
= NULL_TREE
;
8155 /* Check main's type after attributes have been applied. */
8156 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
8158 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
8161 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8163 error ("%<::main%> must return %<int%>");
8164 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
8165 TREE_TYPE (decl
) = newtype
;
8168 check_main_parameter_types (decl
);
8171 if (ctype
!= NULL_TREE
8172 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
8175 tree old_decl
= check_classfn (ctype
, decl
,
8176 (processing_template_decl
8177 > template_class_depth (ctype
))
8178 ? current_template_parms
8181 if (old_decl
== error_mark_node
)
8189 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
8190 /* Because grokfndecl is always supposed to return a
8191 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
8192 here. We depend on our callers to figure out that its
8193 really a template that's being returned. */
8194 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
8196 if (DECL_STATIC_FUNCTION_P (old_decl
)
8197 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
8199 /* Remove the `this' parm added by grokclassfn. */
8200 revert_static_member_fn (decl
);
8201 check_static_quals (decl
, quals
);
8203 if (DECL_ARTIFICIAL (old_decl
))
8205 error ("definition of implicitly-declared %qD", old_decl
);
8208 else if (DECL_DEFAULTED_FN (old_decl
))
8210 error ("definition of explicitly-defaulted %q+D", decl
);
8211 error ("%q+#D explicitly defaulted here", old_decl
);
8215 /* Since we've smashed OLD_DECL to its
8216 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8217 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8218 decl
= DECL_TEMPLATE_RESULT (decl
);
8220 /* Attempt to merge the declarations. This can fail, in
8221 the case of some invalid specialization declarations. */
8222 pushed_scope
= push_scope (ctype
);
8223 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8225 pop_scope (pushed_scope
);
8228 error ("no %q#D member function declared in class %qT",
8232 if (ok
== error_mark_node
)
8238 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8241 if (ctype
== NULL_TREE
|| check
)
8245 DECL_VIRTUAL_P (decl
) = 1;
8250 /* decl is a FUNCTION_DECL.
8251 specifiers are the parsed virt-specifiers.
8253 Set flags to reflect the virt-specifiers.
8258 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8260 if (decl
== NULL_TREE
)
8262 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8263 DECL_OVERRIDE_P (decl
) = 1;
8264 if (specifiers
& VIRT_SPEC_FINAL
)
8265 DECL_FINAL_P (decl
) = 1;
8269 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8270 the linkage that DECL will receive in the object file. */
8273 set_linkage_for_static_data_member (tree decl
)
8275 /* A static data member always has static storage duration and
8276 external linkage. Note that static data members are forbidden in
8277 local classes -- the only situation in which a class has
8278 non-external linkage. */
8279 TREE_PUBLIC (decl
) = 1;
8280 TREE_STATIC (decl
) = 1;
8281 /* For non-template classes, static data members are always put
8282 out in exactly those files where they are defined, just as
8283 with ordinary namespace-scope variables. */
8284 if (!processing_template_decl
)
8285 DECL_INTERFACE_KNOWN (decl
) = 1;
8288 /* Create a VAR_DECL named NAME with the indicated TYPE.
8290 If SCOPE is non-NULL, it is the class type or namespace containing
8291 the variable. If SCOPE is NULL, the variable should is created in
8292 the innermost enclosing scope. */
8295 grokvardecl (tree type
,
8297 tree orig_declarator
,
8298 const cp_decl_specifier_seq
*declspecs
,
8305 tree explicit_scope
;
8307 gcc_assert (!name
|| identifier_p (name
));
8309 bool constp
= flags
&1;
8310 bool conceptp
= flags
&2;
8312 /* Compute the scope in which to place the variable, but remember
8313 whether or not that scope was explicitly specified by the user. */
8314 explicit_scope
= scope
;
8317 /* An explicit "extern" specifier indicates a namespace-scope
8319 if (declspecs
->storage_class
== sc_extern
)
8320 scope
= current_decl_namespace ();
8321 else if (!at_function_scope_p ())
8322 scope
= current_scope ();
8326 && (/* If the variable is a namespace-scope variable declared in a
8327 template, we need DECL_LANG_SPECIFIC. */
8328 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8329 /* Similarly for namespace-scope variables with language linkage
8331 || (TREE_CODE (scope
) == NAMESPACE_DECL
8332 && current_lang_name
!= lang_name_cplusplus
)
8333 /* Similarly for static data members. */
8335 /* Similarly for explicit specializations. */
8337 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8338 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8340 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8342 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8343 set_decl_namespace (decl
, explicit_scope
, 0);
8345 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
8347 if (declspecs
->storage_class
== sc_extern
)
8349 DECL_THIS_EXTERN (decl
) = 1;
8350 DECL_EXTERNAL (decl
) = !initialized
;
8353 if (DECL_CLASS_SCOPE_P (decl
))
8355 set_linkage_for_static_data_member (decl
);
8356 /* This function is only called with out-of-class definitions. */
8357 DECL_EXTERNAL (decl
) = 0;
8358 check_class_member_definition_namespace (decl
);
8360 /* At top level, either `static' or no s.c. makes a definition
8361 (perhaps tentative), and absence of `static' makes it public. */
8362 else if (toplevel_bindings_p ())
8364 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
8365 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8366 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8368 /* Not at top level, only `static' makes a static definition. */
8371 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
8372 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8375 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
8377 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
8379 CP_DECL_THREAD_LOCAL_P (decl
) = true;
8380 if (!processing_template_decl
)
8381 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
8383 if (declspecs
->gnu_thread_keyword_p
)
8384 SET_DECL_GNU_TLS_P (decl
);
8387 /* If the type of the decl has no linkage, make sure that we'll
8388 notice that in mark_used. */
8389 if (cxx_dialect
> cxx98
8390 && decl_linkage (decl
) != lk_none
8391 && DECL_LANG_SPECIFIC (decl
) == NULL
8392 && !DECL_EXTERN_C_P (decl
)
8393 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
8394 retrofit_lang_decl (decl
);
8396 if (TREE_PUBLIC (decl
))
8398 /* [basic.link]: A name with no linkage (notably, the name of a class
8399 or enumeration declared in a local scope) shall not be used to
8400 declare an entity with linkage.
8402 DR 757 relaxes this restriction for C++0x. */
8403 if (cxx_dialect
< cxx11
)
8404 no_linkage_error (decl
);
8407 DECL_INTERFACE_KNOWN (decl
) = 1;
8409 if (DECL_NAME (decl
)
8410 && MAIN_NAME_P (DECL_NAME (decl
))
8411 && scope
== global_namespace
)
8412 error ("cannot declare %<::main%> to be a global variable");
8414 /* Check that the variable can be safely declared as a concept.
8415 Note that this also forbids explicit specializations. */
8418 if (!processing_template_decl
)
8420 error ("a non-template variable cannot be %<concept%>");
8424 DECL_DECLARED_CONCEPT_P (decl
) = true;
8425 if (!same_type_ignoring_top_level_qualifiers_p (type
, boolean_type_node
))
8426 error_at (declspecs
->locations
[ds_type_spec
],
8427 "concept must have type %<bool%>");
8429 else if (flag_concepts
8430 && processing_template_decl
> template_class_depth (scope
))
8432 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
8433 tree ci
= build_constraints (reqs
, NULL_TREE
);
8434 set_constraints (decl
, ci
);
8437 // Handle explicit specializations and instantiations of variable templates.
8438 if (orig_declarator
)
8439 decl
= check_explicit_specialization (orig_declarator
, decl
,
8440 template_count
, conceptp
* 8);
8442 return decl
!= error_mark_node
? decl
: NULL_TREE
;
8445 /* Create and return a canonical pointer to member function type, for
8446 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8449 build_ptrmemfunc_type (tree type
)
8454 if (type
== error_mark_node
)
8457 /* Make sure that we always have the unqualified pointer-to-member
8459 if (cp_cv_quals quals
= cp_type_quals (type
))
8461 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8462 return cp_build_qualified_type (unqual
, quals
);
8465 /* If a canonical type already exists for this type, use it. We use
8466 this method instead of type_hash_canon, because it only does a
8467 simple equality check on the list of field members. */
8469 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8472 t
= make_node (RECORD_TYPE
);
8474 /* Let the front end know this is a pointer to member function. */
8475 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8477 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8480 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8482 DECL_CHAIN (field
) = fields
;
8485 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8487 /* Zap out the name so that the back end will give us the debugging
8488 information for this anonymous RECORD_TYPE. */
8489 TYPE_NAME (t
) = NULL_TREE
;
8491 /* Cache this pointer-to-member type so that we can find it again
8493 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8495 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8496 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8497 else if (TYPE_CANONICAL (type
) != type
)
8498 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8503 /* Create and return a pointer to data member type. */
8506 build_ptrmem_type (tree class_type
, tree member_type
)
8508 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8510 cp_cv_quals quals
= type_memfn_quals (member_type
);
8511 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8512 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8513 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8517 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8518 return build_offset_type (class_type
, member_type
);
8522 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8523 Check to see that the definition is valid. Issue appropriate error
8524 messages. Return 1 if the definition is particularly bad, or 0
8528 check_static_variable_definition (tree decl
, tree type
)
8530 /* Can't check yet if we don't know the type. */
8531 if (dependent_type_p (type
))
8533 /* If DECL is declared constexpr, we'll do the appropriate checks
8534 in check_initializer. */
8535 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8537 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8539 if (!COMPLETE_TYPE_P (type
))
8540 error ("in-class initialization of static data member %q#D of "
8541 "incomplete type", decl
);
8542 else if (literal_type_p (type
))
8543 permerror (input_location
,
8544 "%<constexpr%> needed for in-class initialization of "
8545 "static data member %q#D of non-integral type", decl
);
8547 error ("in-class initialization of static data member %q#D of "
8548 "non-literal type", decl
);
8552 /* Motion 10 at San Diego: If a static const integral data member is
8553 initialized with an integral constant expression, the initializer
8554 may appear either in the declaration (within the class), or in
8555 the definition, but not both. If it appears in the class, the
8556 member is a member constant. The file-scope definition is always
8558 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8560 error ("invalid in-class initialization of static data member "
8561 "of non-integral type %qT",
8565 else if (!CP_TYPE_CONST_P (type
))
8566 error ("ISO C++ forbids in-class initialization of non-const "
8567 "static member %qD",
8569 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8570 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8571 "%qD of non-integral type %qT", decl
, type
);
8576 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8577 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8578 expressions out into temporary variables so that walk_tree doesn't
8579 step into them (c++/15764). */
8582 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8584 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
8585 tree expr
= *expr_p
;
8586 if (TREE_CODE (expr
) == SAVE_EXPR
)
8588 tree op
= TREE_OPERAND (expr
, 0);
8589 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8590 if (TREE_SIDE_EFFECTS (op
))
8591 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8594 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8599 /* Entry point for the above. */
8602 stabilize_vla_size (tree size
)
8604 hash_set
<tree
> pset
;
8605 /* Break out any function calls into temporary variables. */
8606 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
8609 /* Reduce a SIZEOF_EXPR to its value. */
8612 fold_sizeof_expr (tree t
)
8615 if (SIZEOF_EXPR_TYPE_P (t
))
8616 r
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t
, 0)),
8617 SIZEOF_EXPR
, false);
8618 else if (TYPE_P (TREE_OPERAND (t
, 0)))
8619 r
= cxx_sizeof_or_alignof_type (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8622 r
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (t
, 0), SIZEOF_EXPR
,
8624 if (r
== error_mark_node
)
8629 /* Given the SIZE (i.e., number of elements) in an array, compute an
8630 appropriate index type for the array. If non-NULL, NAME is the
8631 name of the thing being declared. */
8634 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8639 if (error_operand_p (size
))
8640 return error_mark_node
;
8642 if (!type_dependent_expression_p (size
))
8644 tree type
= TREE_TYPE (size
);
8646 mark_rvalue_use (size
);
8648 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8649 && TREE_SIDE_EFFECTS (size
))
8650 /* In C++98, we mark a non-constant array bound with a magic
8651 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8654 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
8656 if (CLASS_TYPE_P (type
)
8657 && CLASSTYPE_LITERAL_P (type
))
8659 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8662 if (!(complain
& tf_error
))
8663 return error_mark_node
;
8665 error ("size of array %qD has non-integral type %qT",
8668 error ("size of array has non-integral type %qT", type
);
8669 size
= integer_one_node
;
8671 if (size
== error_mark_node
)
8672 return error_mark_node
;
8673 type
= TREE_TYPE (size
);
8676 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8677 size
= maybe_constant_value (size
);
8679 if (!TREE_CONSTANT (size
))
8683 if (error_operand_p (size
))
8684 return error_mark_node
;
8686 /* The array bound must be an integer type. */
8687 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8689 if (!(complain
& tf_error
))
8690 return error_mark_node
;
8692 error ("size of array %qD has non-integral type %qT", name
, type
);
8694 error ("size of array has non-integral type %qT", type
);
8695 size
= integer_one_node
;
8696 type
= TREE_TYPE (size
);
8700 /* A type is dependent if it is...an array type constructed from any
8701 dependent type or whose size is specified by a constant expression
8702 that is value-dependent. */
8703 /* We can only call value_dependent_expression_p on integral constant
8704 expressions; treat non-constant expressions as dependent, too. */
8705 if (processing_template_decl
8706 && (type_dependent_expression_p (size
)
8707 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8709 /* We cannot do any checking for a SIZE that isn't known to be
8710 constant. Just build the index type and mark that it requires
8711 structural equality checks. */
8712 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8713 size
, size_one_node
));
8714 TYPE_DEPENDENT_P (itype
) = 1;
8715 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8716 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8720 if (TREE_CODE (size
) != INTEGER_CST
)
8722 tree folded
= cp_fully_fold (size
);
8723 if (TREE_CODE (folded
) == INTEGER_CST
)
8724 pedwarn (location_of (size
), OPT_Wpedantic
,
8725 "size of array is not an integral constant-expression");
8726 /* Use the folded result for VLAs, too; it will have resolved
8731 /* Normally, the array-bound will be a constant. */
8732 if (TREE_CODE (size
) == INTEGER_CST
)
8734 /* Check to see if the array bound overflowed. Make that an
8735 error, no matter how generous we're being. */
8736 constant_expression_error (size
);
8738 /* An array must have a positive number of elements. */
8739 if (tree_int_cst_lt (size
, integer_zero_node
))
8741 if (!(complain
& tf_error
))
8742 return error_mark_node
;
8744 error ("size of array %qD is negative", name
);
8746 error ("size of array is negative");
8747 size
= integer_one_node
;
8749 /* As an extension we allow zero-sized arrays. */
8750 else if (integer_zerop (size
))
8752 if (!(complain
& tf_error
))
8753 /* We must fail if performing argument deduction (as
8754 indicated by the state of complain), so that
8755 another substitution can be found. */
8756 return error_mark_node
;
8757 else if (in_system_header_at (input_location
))
8758 /* Allow them in system headers because glibc uses them. */;
8760 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8762 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8765 else if (TREE_CONSTANT (size
)
8766 /* We don't allow VLAs at non-function scopes, or during
8767 tentative template substitution. */
8768 || !at_function_scope_p ()
8769 || !(complain
& tf_error
))
8771 if (!(complain
& tf_error
))
8772 return error_mark_node
;
8773 /* `(int) &fn' is not a valid array bound. */
8775 error ("size of array %qD is not an integral constant-expression",
8778 error ("size of array is not an integral constant-expression");
8779 size
= integer_one_node
;
8781 else if (pedantic
&& warn_vla
!= 0)
8784 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8786 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8788 else if (warn_vla
> 0)
8792 "variable length array %qD is used", name
);
8795 "variable length array is used");
8798 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8799 /* A variable sized array. */
8800 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8803 HOST_WIDE_INT saved_processing_template_decl
;
8805 /* Compute the index of the largest element in the array. It is
8806 one less than the number of elements in the array. We save
8807 and restore PROCESSING_TEMPLATE_DECL so that computations in
8808 cp_build_binary_op will be appropriately folded. */
8809 saved_processing_template_decl
= processing_template_decl
;
8810 processing_template_decl
= 0;
8811 itype
= cp_build_binary_op (input_location
,
8813 cp_convert (ssizetype
, size
, complain
),
8814 cp_convert (ssizetype
, integer_one_node
,
8817 itype
= maybe_constant_value (itype
);
8818 processing_template_decl
= saved_processing_template_decl
;
8820 if (!TREE_CONSTANT (itype
))
8822 /* A variable sized array. */
8823 itype
= variable_size (itype
);
8825 stabilize_vla_size (itype
);
8827 if (flag_sanitize
& SANITIZE_VLA
8828 && do_ubsan_in_current_function ())
8830 /* We have to add 1 -- in the ubsan routine we generate
8831 LE_EXPR rather than LT_EXPR. */
8832 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8833 build_one_cst (TREE_TYPE (itype
)));
8834 t
= ubsan_instrument_vla (input_location
, t
);
8835 finish_expr_stmt (t
);
8838 /* Make sure that there was no overflow when creating to a signed
8839 index type. (For example, on a 32-bit machine, an array with
8840 size 2^32 - 1 is too big.) */
8841 else if (TREE_CODE (itype
) == INTEGER_CST
8842 && TREE_OVERFLOW (itype
))
8844 if (!(complain
& tf_error
))
8845 return error_mark_node
;
8846 error ("overflow in array dimension");
8847 TREE_OVERFLOW (itype
) = 0;
8851 /* Create and return the appropriate index type. */
8852 itype
= build_index_type (itype
);
8854 /* If the index type were dependent, we would have returned early, so
8855 remember that it isn't. */
8856 TYPE_DEPENDENT_P (itype
) = 0;
8857 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8861 /* Returns the scope (if any) in which the entity declared by
8862 DECLARATOR will be located. If the entity was declared with an
8863 unqualified name, NULL_TREE is returned. */
8866 get_scope_of_declarator (const cp_declarator
*declarator
)
8868 while (declarator
&& declarator
->kind
!= cdk_id
)
8869 declarator
= declarator
->declarator
;
8871 /* If the declarator-id is a SCOPE_REF, the scope in which the
8872 declaration occurs is the first operand. */
8874 && declarator
->u
.id
.qualifying_scope
)
8875 return declarator
->u
.id
.qualifying_scope
;
8877 /* Otherwise, the declarator is not a qualified name; the entity will
8878 be declared in the current scope. */
8882 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8883 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8887 create_array_type_for_decl (tree name
, tree type
, tree size
)
8889 tree itype
= NULL_TREE
;
8891 /* If things have already gone awry, bail now. */
8892 if (type
== error_mark_node
|| size
== error_mark_node
)
8893 return error_mark_node
;
8895 /* 8.3.4/1: If the type of the identifier of D contains the auto
8896 type-specifier, the program is ill-formed. */
8897 if (type_uses_auto (type
))
8899 error ("%qD declared as array of %qT", name
, type
);
8900 return error_mark_node
;
8903 /* If there are some types which cannot be array elements,
8904 issue an error-message and return. */
8905 switch (TREE_CODE (type
))
8909 error ("declaration of %qD as array of void", name
);
8911 error ("creating array of void");
8912 return error_mark_node
;
8916 error ("declaration of %qD as array of functions", name
);
8918 error ("creating array of functions");
8919 return error_mark_node
;
8921 case REFERENCE_TYPE
:
8923 error ("declaration of %qD as array of references", name
);
8925 error ("creating array of references");
8926 return error_mark_node
;
8930 error ("declaration of %qD as array of function members", name
);
8932 error ("creating array of function members");
8933 return error_mark_node
;
8941 The constant expressions that specify the bounds of the arrays
8942 can be omitted only for the first member of the sequence. */
8943 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8946 error ("declaration of %qD as multidimensional array must "
8947 "have bounds for all dimensions except the first",
8950 error ("multidimensional array must have bounds for all "
8951 "dimensions except the first");
8953 return error_mark_node
;
8956 /* Figure out the index type for the array. */
8958 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8961 T is called the array element type; this type shall not be [...] an
8962 abstract class type. */
8963 abstract_virtuals_error (name
, type
);
8965 return build_cplus_array_type (type
, itype
);
8968 /* Returns the smallest location != UNKNOWN_LOCATION among the
8969 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
8970 and LOCATIONS[ds_restrict]. */
8973 smallest_type_quals_location (int type_quals
, const location_t
* locations
)
8975 location_t loc
= UNKNOWN_LOCATION
;
8977 if (type_quals
& TYPE_QUAL_CONST
)
8978 loc
= locations
[ds_const
];
8980 if ((type_quals
& TYPE_QUAL_VOLATILE
)
8981 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_volatile
] < loc
))
8982 loc
= locations
[ds_volatile
];
8984 if ((type_quals
& TYPE_QUAL_RESTRICT
)
8985 && (loc
== UNKNOWN_LOCATION
|| locations
[ds_restrict
] < loc
))
8986 loc
= locations
[ds_restrict
];
8991 /* Check that it's OK to declare a function with the indicated TYPE
8992 and TYPE_QUALS. SFK indicates the kind of special function (if any)
8993 that this function is. OPTYPE is the type given in a conversion
8994 operator declaration, or the class type for a constructor/destructor.
8995 Returns the actual return type of the function; that may be different
8996 than TYPE if an error occurs, or for certain special functions. */
8999 check_special_function_return_type (special_function_kind sfk
,
9003 const location_t
* locations
)
9007 case sfk_constructor
:
9009 error ("return type specification for constructor invalid");
9010 else if (type_quals
!= TYPE_UNQUALIFIED
)
9011 error_at (smallest_type_quals_location (type_quals
, locations
),
9012 "qualifiers are not allowed on constructor declaration");
9014 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9015 type
= build_pointer_type (optype
);
9017 type
= void_type_node
;
9020 case sfk_destructor
:
9022 error ("return type specification for destructor invalid");
9023 else if (type_quals
!= TYPE_UNQUALIFIED
)
9024 error_at (smallest_type_quals_location (type_quals
, locations
),
9025 "qualifiers are not allowed on destructor declaration");
9027 /* We can't use the proper return type here because we run into
9028 problems with ambiguous bases and covariant returns.
9029 Java classes are left unchanged because (void *) isn't a valid
9030 Java type, and we don't want to change the Java ABI. */
9031 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
9032 type
= build_pointer_type (void_type_node
);
9034 type
= void_type_node
;
9037 case sfk_conversion
:
9039 error ("return type specified for %<operator %T%>", optype
);
9040 else if (type_quals
!= TYPE_UNQUALIFIED
)
9041 error_at (smallest_type_quals_location (type_quals
, locations
),
9042 "qualifiers are not allowed on declaration of "
9043 "%<operator %T%>", optype
);
9055 /* A variable or data member (whose unqualified name is IDENTIFIER)
9056 has been declared with the indicated TYPE. If the TYPE is not
9057 acceptable, issue an error message and return a type to use for
9058 error-recovery purposes. */
9061 check_var_type (tree identifier
, tree type
)
9063 if (VOID_TYPE_P (type
))
9066 error ("unnamed variable or field declared void");
9067 else if (identifier_p (identifier
))
9069 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
9070 error ("variable or field %qE declared void", identifier
);
9073 error ("variable or field declared void");
9074 type
= error_mark_node
;
9080 /* Given declspecs and a declarator (abstract or otherwise), determine
9081 the name and type of the object declared and construct a DECL node
9084 DECLSPECS points to the representation of declaration-specifier
9085 sequence that precedes declarator.
9087 DECL_CONTEXT says which syntactic context this declaration is in:
9088 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
9089 FUNCDEF for a function definition. Like NORMAL but a few different
9090 error messages in each case. Return value may be zero meaning
9091 this definition is too screwy to try to parse.
9092 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
9093 handle member functions (which have FIELD context).
9094 Return value may be zero meaning this definition is too screwy to
9096 PARM for a parameter declaration (either within a function prototype
9097 or before a function body). Make a PARM_DECL, or return void_type_node.
9098 TPARM for a template parameter declaration.
9099 CATCHPARM for a parameter declaration before a catch clause.
9100 TYPENAME if for a typename (in a cast or sizeof).
9101 Don't make a DECL node; just return the ..._TYPE node.
9102 FIELD for a struct or union field; make a FIELD_DECL.
9103 BITFIELD for a field with specified width.
9105 INITIALIZED is as for start_decl.
9107 ATTRLIST is a pointer to the list of attributes, which may be NULL
9108 if there are none; *ATTRLIST may be modified if attributes from inside
9109 the declarator should be applied to the declaration.
9111 When this function is called, scoping variables (such as
9112 CURRENT_CLASS_TYPE) should reflect the scope in which the
9113 declaration occurs, not the scope in which the new declaration will
9114 be placed. For example, on:
9118 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
9121 Returns a DECL (if a declarator is present), a TYPE (if there is no
9122 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
9126 grokdeclarator (const cp_declarator
*declarator
,
9127 cp_decl_specifier_seq
*declspecs
,
9128 enum decl_context decl_context
,
9132 tree type
= NULL_TREE
;
9134 int explicit_intN
= 0;
9135 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
9136 int explicit_int
= 0;
9137 int explicit_char
= 0;
9138 int defaulted_int
= 0;
9140 tree typedef_decl
= NULL_TREE
;
9141 const char *name
= NULL
;
9142 tree typedef_type
= NULL_TREE
;
9143 /* True if this declarator is a function definition. */
9144 bool funcdef_flag
= false;
9145 cp_declarator_kind innermost_code
= cdk_error
;
9148 /* See the code below that used this. */
9149 tree decl_attr
= NULL_TREE
;
9152 /* Keep track of what sort of function is being processed
9153 so that we can warn about default return values, or explicit
9154 return values which do not match prescribed defaults. */
9155 special_function_kind sfk
= sfk_none
;
9157 tree dname
= NULL_TREE
;
9158 tree ctor_return_type
= NULL_TREE
;
9159 enum overload_flags flags
= NO_SPECIAL
;
9160 /* cv-qualifiers that apply to the declarator, for a declaration of
9161 a member function. */
9162 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
9163 /* virt-specifiers that apply to the declarator, for a declaration of
9164 a member function. */
9165 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
9166 /* ref-qualifier that applies to the declarator, for a declaration of
9167 a member function. */
9168 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
9169 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
9170 int type_quals
= TYPE_UNQUALIFIED
;
9171 tree raises
= NULL_TREE
;
9172 int template_count
= 0;
9173 tree returned_attrs
= NULL_TREE
;
9174 tree parms
= NULL_TREE
;
9175 const cp_declarator
*id_declarator
;
9176 /* The unqualified name of the declarator; either an
9177 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
9178 tree unqualified_id
;
9179 /* The class type, if any, in which this entity is located,
9180 or NULL_TREE if none. Note that this value may be different from
9181 the current class type; for example if an attempt is made to declare
9182 "A::f" inside "B", this value will be "A". */
9183 tree ctype
= current_class_type
;
9184 /* The NAMESPACE_DECL for the namespace in which this entity is
9185 located. If an unqualified name is used to declare the entity,
9186 this value will be NULL_TREE, even if the entity is located at
9188 tree in_namespace
= NULL_TREE
;
9189 cp_storage_class storage_class
;
9190 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
9191 bool type_was_error_mark_node
= false;
9192 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
9193 bool template_type_arg
= false;
9194 bool template_parm_flag
= false;
9195 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
9196 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
9197 bool late_return_type_p
= false;
9198 bool array_parameter_p
= false;
9199 source_location saved_loc
= input_location
;
9201 tree reqs
= NULL_TREE
;
9203 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
9204 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
9205 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
9206 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
9207 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
9208 explicit_intN
= declspecs
->explicit_intN_p
;
9209 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
9211 // Was concept_p specified? Note that ds_concept
9212 // implies ds_constexpr!
9213 bool concept_p
= decl_spec_seq_has_spec_p (declspecs
, ds_concept
);
9217 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9218 type_quals
|= TYPE_QUAL_CONST
;
9219 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9220 type_quals
|= TYPE_QUAL_VOLATILE
;
9221 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9222 type_quals
|= TYPE_QUAL_RESTRICT
;
9224 if (decl_context
== FUNCDEF
)
9225 funcdef_flag
= true, decl_context
= NORMAL
;
9226 else if (decl_context
== MEMFUNCDEF
)
9227 funcdef_flag
= true, decl_context
= FIELD
;
9228 else if (decl_context
== BITFIELD
)
9229 bitfield
= 1, decl_context
= FIELD
;
9230 else if (decl_context
== TEMPLATE_TYPE_ARG
)
9231 template_type_arg
= true, decl_context
= TYPENAME
;
9232 else if (decl_context
== TPARM
)
9233 template_parm_flag
= true, decl_context
= PARM
;
9235 if (initialized
> 1)
9236 funcdef_flag
= true;
9238 /* Look inside a declarator for the name being declared
9239 and get it as a string, for an error message. */
9240 for (id_declarator
= declarator
;
9242 id_declarator
= id_declarator
->declarator
)
9244 if (id_declarator
->kind
!= cdk_id
)
9245 innermost_code
= id_declarator
->kind
;
9247 switch (id_declarator
->kind
)
9250 if (id_declarator
->declarator
9251 && id_declarator
->declarator
->kind
== cdk_id
)
9253 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
9254 if (sfk
== sfk_destructor
)
9261 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
9262 tree decl
= id_declarator
->u
.id
.unqualified_name
;
9265 if (qualifying_scope
)
9267 if (at_function_scope_p ())
9271 A declarator-id shall not be qualified except
9274 None of the cases are permitted in block
9276 if (qualifying_scope
== global_namespace
)
9277 error ("invalid use of qualified-name %<::%D%>",
9279 else if (TYPE_P (qualifying_scope
))
9280 error ("invalid use of qualified-name %<%T::%D%>",
9281 qualifying_scope
, decl
);
9283 error ("invalid use of qualified-name %<%D::%D%>",
9284 qualifying_scope
, decl
);
9285 return error_mark_node
;
9287 else if (TYPE_P (qualifying_scope
))
9289 ctype
= qualifying_scope
;
9290 if (!MAYBE_CLASS_TYPE_P (ctype
))
9292 error ("%q#T is not a class or a namespace", ctype
);
9295 else if (innermost_code
!= cdk_function
9296 && current_class_type
9297 && !uniquely_derived_from_p (ctype
,
9298 current_class_type
))
9300 error ("invalid use of qualified-name %<%T::%D%>",
9301 qualifying_scope
, decl
);
9302 return error_mark_node
;
9305 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
9306 in_namespace
= qualifying_scope
;
9308 switch (TREE_CODE (decl
))
9314 if (innermost_code
!= cdk_function
)
9316 error ("declaration of %qD as non-function", decl
);
9317 return error_mark_node
;
9319 else if (!qualifying_scope
9320 && !(current_class_type
&& at_class_scope_p ()))
9322 error ("declaration of %qD as non-member", decl
);
9323 return error_mark_node
;
9326 type
= TREE_OPERAND (decl
, 0);
9328 type
= constructor_name (type
);
9329 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
9334 case TEMPLATE_ID_EXPR
:
9336 tree fns
= TREE_OPERAND (decl
, 0);
9339 if (!identifier_p (dname
))
9341 if (variable_template_p (dname
))
9342 dname
= DECL_NAME (dname
);
9345 gcc_assert (is_overloaded_fn (dname
));
9346 dname
= DECL_NAME (get_first_fn (dname
));
9352 case IDENTIFIER_NODE
:
9353 if (identifier_p (decl
))
9356 if (C_IS_RESERVED_WORD (dname
))
9358 error ("declarator-id missing; using reserved word %qD",
9360 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9362 else if (!IDENTIFIER_TYPENAME_P (dname
))
9363 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9366 gcc_assert (flags
== NO_SPECIAL
);
9367 flags
= TYPENAME_FLAG
;
9368 ctor_return_type
= TREE_TYPE (dname
);
9369 sfk
= sfk_conversion
;
9370 if (is_typename_at_global_scope (dname
))
9371 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9373 name
= "<invalid operator>";
9390 return error_mark_node
;
9395 if (id_declarator
->kind
== cdk_id
)
9401 The declarator in a function-definition shall have the form
9402 D1 ( parameter-declaration-clause) ... */
9403 if (funcdef_flag
&& innermost_code
!= cdk_function
)
9405 error ("function definition does not declare parameters");
9406 return error_mark_node
;
9409 if (flags
== TYPENAME_FLAG
9410 && innermost_code
!= cdk_function
9411 && ! (ctype
&& !declspecs
->any_specifiers_p
))
9413 error ("declaration of %qD as non-function", dname
);
9414 return error_mark_node
;
9418 && identifier_p (dname
)
9419 && UDLIT_OPER_P (dname
)
9420 && innermost_code
!= cdk_function
)
9422 error ("declaration of %qD as non-function", dname
);
9423 return error_mark_node
;
9426 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9430 error ("declaration of %qD as %<typedef%>", dname
);
9431 return error_mark_node
;
9433 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9435 error ("declaration of %qD as parameter", dname
);
9436 return error_mark_node
;
9440 /* Anything declared one level down from the top level
9441 must be one of the parameters of a function
9442 (because the body is at least two levels down). */
9444 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9445 by not allowing C++ class definitions to specify their parameters
9446 with xdecls (must be spec.d in the parmlist).
9448 Since we now wait to push a class scope until we are sure that
9449 we are in a legitimate method context, we must set oldcname
9450 explicitly (since current_class_name is not yet alive).
9452 We also want to avoid calling this a PARM if it is in a namespace. */
9454 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9456 cp_binding_level
*b
= current_binding_level
;
9457 current_binding_level
= b
->level_chain
;
9458 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9459 decl_context
= PARM
;
9460 current_binding_level
= b
;
9464 name
= decl_context
== PARM
? "parameter" : "type name";
9466 if (concept_p
&& typedef_p
)
9468 error ("%<concept%> cannot appear in a typedef declaration");
9469 return error_mark_node
;
9472 if (constexpr_p
&& typedef_p
)
9474 error ("%<constexpr%> cannot appear in a typedef declaration");
9475 return error_mark_node
;
9478 /* If there were multiple types specified in the decl-specifier-seq,
9479 issue an error message. */
9480 if (declspecs
->multiple_types_p
)
9482 error ("two or more data types in declaration of %qs", name
);
9483 return error_mark_node
;
9486 if (declspecs
->conflicting_specifiers_p
)
9488 error ("conflicting specifiers in declaration of %qs", name
);
9489 return error_mark_node
;
9492 /* Extract the basic type from the decl-specifier-seq. */
9493 type
= declspecs
->type
;
9494 if (type
== error_mark_node
)
9497 type_was_error_mark_node
= true;
9499 /* If the entire declaration is itself tagged as deprecated then
9500 suppress reports of deprecated items. */
9501 if (type
&& TREE_DEPRECATED (type
)
9502 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9503 warn_deprecated_use (type
, NULL_TREE
);
9504 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9506 typedef_decl
= type
;
9507 type
= TREE_TYPE (typedef_decl
);
9508 if (TREE_DEPRECATED (type
)
9509 && DECL_ARTIFICIAL (typedef_decl
)
9510 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9511 warn_deprecated_use (type
, NULL_TREE
);
9513 /* No type at all: default to `int', and set DEFAULTED_INT
9514 because it was not a user-defined typedef. */
9515 if (type
== NULL_TREE
)
9517 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
9519 /* These imply 'int'. */
9520 type
= integer_type_node
;
9523 /* If we just have "complex", it is equivalent to "complex double". */
9524 else if (!longlong
&& !explicit_intN
9525 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9527 type
= double_type_node
;
9528 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
9529 "ISO C++ does not support plain %<complex%> meaning "
9530 "%<double complex%>");
9534 explicit_int
= declspecs
->explicit_int_p
;
9535 explicit_char
= declspecs
->explicit_char_p
;
9538 /* See the code below that used this. */
9540 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9542 typedef_type
= type
;
9545 if (sfk
!= sfk_conversion
)
9546 ctor_return_type
= ctype
;
9548 if (sfk
!= sfk_none
)
9550 type
= check_special_function_return_type (sfk
, type
,
9553 declspecs
->locations
);
9554 type_quals
= TYPE_UNQUALIFIED
;
9556 else if (type
== NULL_TREE
)
9562 /* We handle `main' specially here, because 'main () { }' is so
9563 common. With no options, it is allowed. With -Wreturn-type,
9564 it is a warning. It is only an error with -pedantic-errors. */
9565 is_main
= (funcdef_flag
9566 && dname
&& identifier_p (dname
)
9567 && MAIN_NAME_P (dname
)
9568 && ctype
== NULL_TREE
9569 && in_namespace
== NULL_TREE
9570 && current_namespace
== global_namespace
);
9572 if (type_was_error_mark_node
)
9573 /* We've already issued an error, don't complain more. */;
9574 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9575 /* Allow it, sigh. */;
9577 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9579 pedwarn (input_location
, OPT_Wpedantic
,
9580 "ISO C++ forbids declaration of %qs with no type", name
);
9582 warning (OPT_Wreturn_type
,
9583 "ISO C++ forbids declaration of %qs with no type", name
);
9585 if (type_was_error_mark_node
&& template_parm_flag
)
9586 /* FIXME we should be able to propagate the error_mark_node as is
9587 for other contexts too. */
9588 type
= error_mark_node
;
9590 type
= integer_type_node
;
9597 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
9599 error ("%<__int%d%> is not supported by this target",
9600 int_n_data
[declspecs
->int_n_idx
].bitsize
);
9601 explicit_intN
= false;
9603 else if (pedantic
&& ! in_system_header_at (input_location
))
9604 pedwarn (input_location
, OPT_Wpedantic
,
9605 "ISO C++ does not support %<__int%d%> for %qs",
9606 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
9609 /* Now process the modifiers that were specified
9610 and check for invalid combinations. */
9612 /* Long double is a special combination. */
9613 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9616 type
= cp_build_qualified_type (long_double_type_node
,
9617 cp_type_quals (type
));
9620 /* Check all other uses of type modifiers. */
9622 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9626 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9627 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9628 else if (signed_p
&& unsigned_p
)
9629 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9630 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9631 error ("%<long long%> invalid for %qs", name
);
9632 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9633 error ("%<long%> invalid for %qs", name
);
9634 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9635 error ("%<short%> invalid for %qs", name
);
9636 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9637 error ("%<long%> or %<short%> invalid for %qs", name
);
9638 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
9639 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9640 else if ((long_p
|| short_p
) && explicit_char
)
9641 error ("%<long%> or %<short%> specified with char for %qs", name
);
9642 else if (long_p
&& short_p
)
9643 error ("%<long%> and %<short%> specified together for %qs", name
);
9644 else if (type
== char16_type_node
|| type
== char32_type_node
)
9646 if (signed_p
|| unsigned_p
)
9647 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9648 else if (short_p
|| long_p
)
9649 error ("%<short%> or %<long%> invalid for %qs", name
);
9654 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
9656 pedwarn (input_location
, OPT_Wpedantic
,
9657 "long, short, signed or unsigned used invalidly for %qs",
9659 if (flag_pedantic_errors
)
9664 /* Discard the type modifiers if they are invalid. */
9675 /* Decide whether an integer type is signed or not.
9676 Optionally treat bitfields as signed by default. */
9680 It is implementation-defined whether a plain (neither
9681 explicitly signed or unsigned) char, short, int, or long
9682 bit-field is signed or unsigned.
9684 Naturally, we extend this to long long as well. Note that
9685 this does not include wchar_t. */
9686 || (bitfield
&& !flag_signed_bitfields
9688 /* A typedef for plain `int' without `signed' can be
9689 controlled just like plain `int', but a typedef for
9690 `signed int' cannot be so controlled. */
9692 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9693 && TREE_CODE (type
) == INTEGER_TYPE
9694 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9697 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
9699 type
= long_long_unsigned_type_node
;
9701 type
= long_unsigned_type_node
;
9703 type
= short_unsigned_type_node
;
9704 else if (type
== char_type_node
)
9705 type
= unsigned_char_type_node
;
9706 else if (typedef_decl
)
9707 type
= unsigned_type_for (type
);
9709 type
= unsigned_type_node
;
9711 else if (signed_p
&& type
== char_type_node
)
9712 type
= signed_char_type_node
;
9713 else if (explicit_intN
)
9714 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
9716 type
= long_long_integer_type_node
;
9718 type
= long_integer_type_node
;
9720 type
= short_integer_type_node
;
9722 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9724 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9725 error ("complex invalid for %qs", name
);
9726 /* If a modifier is specified, the resulting complex is the complex
9727 form of TYPE. E.g, "complex short" is "complex short int". */
9728 else if (type
== integer_type_node
)
9729 type
= complex_integer_type_node
;
9730 else if (type
== float_type_node
)
9731 type
= complex_float_type_node
;
9732 else if (type
== double_type_node
)
9733 type
= complex_double_type_node
;
9734 else if (type
== long_double_type_node
)
9735 type
= complex_long_double_type_node
;
9737 type
= build_complex_type (type
);
9740 /* If we're using the injected-class-name to form a compound type or a
9741 declaration, replace it with the underlying class so we don't get
9742 redundant typedefs in the debug output. But if we are returning the
9743 type unchanged, leave it alone so that it's available to
9744 maybe_get_template_decl_from_type_decl. */
9745 if (CLASS_TYPE_P (type
)
9746 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9747 && type
== TREE_TYPE (TYPE_NAME (type
))
9748 && (declarator
|| type_quals
))
9749 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9751 type_quals
|= cp_type_quals (type
);
9752 type
= cp_build_qualified_type_real
9753 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
9754 || declspecs
->decltype_p
)
9755 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9756 /* We might have ignored or rejected some of the qualifiers. */
9757 type_quals
= cp_type_quals (type
);
9760 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9761 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9762 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9764 storage_class
= declspecs
->storage_class
;
9765 if (storage_class
== sc_static
)
9766 staticp
= 1 + (decl_context
== FIELD
);
9768 if (virtualp
&& staticp
== 2)
9770 error ("member %qD cannot be declared both virtual and static", dname
);
9771 storage_class
= sc_none
;
9774 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9776 /* Issue errors about use of storage classes for parameters. */
9777 if (decl_context
== PARM
)
9781 error ("typedef declaration invalid in parameter declaration");
9782 return error_mark_node
;
9784 else if (template_parm_flag
&& storage_class
!= sc_none
)
9786 error ("storage class specified for template parameter %qs", name
);
9787 return error_mark_node
;
9789 else if (storage_class
== sc_static
9790 || storage_class
== sc_extern
9792 error ("storage class specifiers invalid in parameter declarations");
9794 /* Function parameters cannot be concept. */
9796 error ("a parameter cannot be declared %<concept%>");
9797 /* Function parameters cannot be constexpr. If we saw one, moan
9798 and pretend it wasn't there. */
9799 else if (constexpr_p
)
9801 error ("a parameter cannot be declared %<constexpr%>");
9806 /* Give error if `virtual' is used outside of class declaration. */
9808 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9810 error_at (declspecs
->locations
[ds_virtual
],
9811 "%<virtual%> outside class declaration");
9815 /* Static anonymous unions are dealt with here. */
9816 if (staticp
&& decl_context
== TYPENAME
9818 && ANON_AGGR_TYPE_P (declspecs
->type
))
9819 decl_context
= FIELD
;
9821 /* Warn about storage classes that are invalid for certain
9822 kinds of declarations (parameters, typenames, etc.). */
9825 && storage_class
!= sc_extern
9826 && storage_class
!= sc_static
)
9829 error ("multiple storage classes in declaration of %qs", name
);
9832 if (decl_context
!= NORMAL
9833 && ((storage_class
!= sc_none
9834 && storage_class
!= sc_mutable
)
9837 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9838 && (storage_class
== sc_register
9839 || storage_class
== sc_auto
))
9843 else if (decl_context
== FIELD
9844 /* C++ allows static class elements. */
9845 && storage_class
== sc_static
)
9846 /* C++ also allows inlines and signed and unsigned elements,
9847 but in those cases we don't come in here. */
9851 if (decl_context
== FIELD
)
9852 error ("storage class specified for %qs", name
);
9855 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9856 error ("storage class specified for parameter %qs", name
);
9858 error ("storage class specified for typename");
9860 if (storage_class
== sc_register
9861 || storage_class
== sc_auto
9862 || storage_class
== sc_extern
9864 storage_class
= sc_none
;
9867 else if (storage_class
== sc_extern
&& funcdef_flag
9868 && ! toplevel_bindings_p ())
9869 error ("nested function %qs declared %<extern%>", name
);
9870 else if (toplevel_bindings_p ())
9872 if (storage_class
== sc_auto
)
9873 error ("top-level declaration of %qs specifies %<auto%>", name
);
9876 && storage_class
!= sc_extern
9877 && storage_class
!= sc_static
)
9879 if (declspecs
->gnu_thread_keyword_p
)
9880 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9881 "declared %<__thread%>", name
);
9883 /* When thread_local is applied to a variable of block scope the
9884 storage-class-specifier static is implied if it does not appear
9886 storage_class
= declspecs
->storage_class
= sc_static
;
9890 if (storage_class
&& friendp
)
9892 error ("storage class specifiers invalid in friend function declarations");
9893 storage_class
= sc_none
;
9898 unqualified_id
= NULL_TREE
;
9901 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9902 switch (TREE_CODE (unqualified_id
))
9905 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9906 if (TYPE_P (unqualified_id
))
9907 unqualified_id
= constructor_name (unqualified_id
);
9910 case IDENTIFIER_NODE
:
9911 case TEMPLATE_ID_EXPR
:
9919 if (declspecs
->std_attributes
)
9921 /* Apply the c++11 attributes to the type preceding them. */
9922 input_location
= declspecs
->locations
[ds_std_attribute
];
9923 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9924 input_location
= saved_loc
;
9927 /* Determine the type of the entity declared by recurring on the
9929 for (; declarator
; declarator
= declarator
->declarator
)
9931 const cp_declarator
*inner_declarator
;
9934 if (type
== error_mark_node
)
9935 return error_mark_node
;
9937 attrs
= declarator
->attributes
;
9943 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9944 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9945 if (declarator
->kind
== cdk_function
)
9946 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9947 if (declarator
->kind
== cdk_array
)
9948 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9949 returned_attrs
= decl_attributes (&type
,
9950 chainon (returned_attrs
, attrs
),
9954 if (declarator
->kind
== cdk_id
)
9957 inner_declarator
= declarator
->declarator
;
9959 switch (declarator
->kind
)
9962 type
= create_array_type_for_decl (dname
, type
,
9963 declarator
->u
.array
.bounds
);
9964 if (!valid_array_size_p (input_location
, type
, dname
))
9965 type
= error_mark_node
;
9967 if (declarator
->std_attributes
)
9970 The optional attribute-specifier-seq appertains to the
9972 returned_attrs
= chainon (returned_attrs
,
9973 declarator
->std_attributes
);
9981 /* Declaring a function type.
9982 Make sure we have a valid type for the function to return. */
9984 if (type_quals
!= TYPE_UNQUALIFIED
)
9986 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9987 warning (OPT_Wignored_qualifiers
,
9988 "type qualifiers ignored on function return type");
9989 /* We now know that the TYPE_QUALS don't apply to the
9990 decl, but to its return type. */
9991 type_quals
= TYPE_UNQUALIFIED
;
9993 errmsg
= targetm
.invalid_return_type (type
);
9997 type
= integer_type_node
;
10000 /* Error about some types functions can't return. */
10002 if (TREE_CODE (type
) == FUNCTION_TYPE
)
10004 error ("%qs declared as function returning a function", name
);
10005 return error_mark_node
;
10007 if (TREE_CODE (type
) == ARRAY_TYPE
)
10009 error ("%qs declared as function returning an array", name
);
10010 return error_mark_node
;
10013 input_location
= declspecs
->locations
[ds_type_spec
];
10014 abstract_virtuals_error (ACU_RETURN
, type
);
10015 input_location
= saved_loc
;
10017 /* Pick up type qualifiers which should be applied to `this'. */
10018 memfn_quals
= declarator
->u
.function
.qualifiers
;
10019 /* Pick up virt-specifiers. */
10020 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
10021 /* And ref-qualifier, too */
10022 rqual
= declarator
->u
.function
.ref_qualifier
;
10023 /* And tx-qualifier. */
10024 tree tx_qual
= declarator
->u
.function
.tx_qualifier
;
10025 /* Pick up the exception specifications. */
10026 raises
= declarator
->u
.function
.exception_specification
;
10027 /* If the exception-specification is ill-formed, let's pretend
10028 there wasn't one. */
10029 if (raises
== error_mark_node
)
10030 raises
= NULL_TREE
;
10033 error_at (location_of (reqs
), "requires-clause on return type");
10034 reqs
= declarator
->u
.function
.requires_clause
;
10036 /* Say it's a definition only for the CALL_EXPR
10037 closest to the identifier. */
10038 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
10040 /* Handle a late-specified return type. */
10043 if (type_uses_auto (type
))
10045 if (!declarator
->u
.function
.late_return_type
)
10047 if (current_class_type
10048 && LAMBDA_TYPE_P (current_class_type
))
10049 /* OK for C++11 lambdas. */;
10050 else if (cxx_dialect
< cxx14
)
10052 error ("%qs function uses "
10053 "%<auto%> type specifier without trailing "
10054 "return type", name
);
10055 inform (input_location
, "deduced return type "
10056 "only available with -std=c++14 or "
10061 error ("virtual function cannot "
10062 "have deduced return type");
10066 else if (!is_auto (type
) && sfk
!= sfk_conversion
)
10068 error ("%qs function with trailing return type has"
10069 " %qT as its type rather than plain %<auto%>",
10071 return error_mark_node
;
10074 else if (declarator
->u
.function
.late_return_type
10075 && sfk
!= sfk_conversion
)
10077 if (cxx_dialect
< cxx11
)
10078 /* Not using maybe_warn_cpp0x because this should
10079 always be an error. */
10080 error ("trailing return type only available with "
10081 "-std=c++11 or -std=gnu++11");
10083 error ("%qs function with trailing return type not "
10084 "declared with %<auto%> type specifier", name
);
10085 return error_mark_node
;
10088 type
= splice_late_return_type
10089 (type
, declarator
->u
.function
.late_return_type
);
10090 if (type
== error_mark_node
)
10091 return error_mark_node
;
10093 if (declarator
->u
.function
.late_return_type
)
10094 late_return_type_p
= true;
10096 if (ctype
== NULL_TREE
10097 && decl_context
== FIELD
10100 ctype
= current_class_type
;
10102 if (ctype
&& (sfk
== sfk_constructor
10103 || sfk
== sfk_destructor
))
10105 /* We are within a class's scope. If our declarator name
10106 is the same as the class name, and we are defining
10107 a function, then it is a constructor/destructor, and
10108 therefore returns a void type. */
10110 /* ISO C++ 12.4/2. A destructor may not be declared
10111 const or volatile. A destructor may not be static.
10112 A destructor may not be declared with ref-qualifier.
10114 ISO C++ 12.1. A constructor may not be declared
10115 const or volatile. A constructor may not be
10116 virtual. A constructor may not be static.
10117 A constructor may not be declared with ref-qualifier. */
10119 error ((flags
== DTOR_FLAG
)
10120 ? G_("destructor cannot be static member function")
10121 : G_("constructor cannot be static member function"));
10124 error ((flags
== DTOR_FLAG
)
10125 ? G_("destructors may not be cv-qualified")
10126 : G_("constructors may not be cv-qualified"));
10127 memfn_quals
= TYPE_UNQUALIFIED
;
10132 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
10133 error ((flags
== DTOR_FLAG
)
10134 ? "destructors may not be ref-qualified"
10135 : "constructors may not be ref-qualified");
10136 rqual
= REF_QUAL_NONE
;
10139 if (decl_context
== FIELD
10140 && !member_function_or_else (ctype
,
10141 current_class_type
,
10143 return error_mark_node
;
10145 if (flags
!= DTOR_FLAG
)
10147 /* It's a constructor. */
10148 if (explicitp
== 1)
10152 permerror (input_location
, "constructors cannot be declared virtual");
10155 if (decl_context
== FIELD
10156 && sfk
!= sfk_constructor
)
10157 return error_mark_node
;
10159 if (decl_context
== FIELD
)
10166 /* Cannot be both friend and virtual. */
10167 error ("virtual functions cannot be friends");
10170 if (decl_context
== NORMAL
)
10171 error ("friend declaration not in class definition");
10172 if (current_function_decl
&& funcdef_flag
)
10173 error ("can%'t define friend function %qs in a local "
10174 "class definition",
10177 else if (ctype
&& sfk
== sfk_conversion
)
10179 if (explicitp
== 1)
10181 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
10184 if (late_return_type_p
)
10185 error ("a conversion function cannot have a trailing return type");
10188 arg_types
= grokparms (declarator
->u
.function
.parameters
,
10191 if (inner_declarator
10192 && inner_declarator
->kind
== cdk_id
10193 && inner_declarator
->u
.id
.sfk
== sfk_destructor
10194 && arg_types
!= void_list_node
)
10196 error ("destructors may not have parameters");
10197 arg_types
= void_list_node
;
10201 type
= build_function_type (type
, arg_types
);
10203 tree attrs
= declarator
->std_attributes
;
10206 tree att
= build_tree_list (tx_qual
, NULL_TREE
);
10207 /* transaction_safe applies to the type, but
10208 transaction_safe_dynamic applies to the function. */
10209 if (is_attribute_p ("transaction_safe", tx_qual
))
10210 attrs
= chainon (attrs
, att
);
10212 returned_attrs
= chainon (returned_attrs
, att
);
10217 The optional attribute-specifier-seq appertains to
10218 the function type. */
10219 decl_attributes (&type
, attrs
, 0);
10224 case cdk_reference
:
10226 /* Filter out pointers-to-references and references-to-references.
10227 We can get these if a TYPE_DECL is used. */
10229 if (TREE_CODE (type
) == REFERENCE_TYPE
)
10231 if (declarator
->kind
!= cdk_reference
)
10233 error ("cannot declare pointer to %q#T", type
);
10234 type
= TREE_TYPE (type
);
10237 /* In C++0x, we allow reference to reference declarations
10238 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
10239 and template type arguments [14.3.1/4 temp.arg.type]. The
10240 check for direct reference to reference declarations, which
10241 are still forbidden, occurs below. Reasoning behind the change
10242 can be found in DR106, DR540, and the rvalue reference
10244 else if (cxx_dialect
== cxx98
)
10246 error ("cannot declare reference to %q#T", type
);
10247 type
= TREE_TYPE (type
);
10250 else if (VOID_TYPE_P (type
))
10252 if (declarator
->kind
== cdk_reference
)
10253 error ("cannot declare reference to %q#T", type
);
10254 else if (declarator
->kind
== cdk_ptrmem
)
10255 error ("cannot declare pointer to %q#T member", type
);
10258 /* We now know that the TYPE_QUALS don't apply to the decl,
10259 but to the target of the pointer. */
10260 type_quals
= TYPE_UNQUALIFIED
;
10262 /* This code used to handle METHOD_TYPE, but I don't think it's
10263 possible to get it here anymore. */
10264 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
10265 if (declarator
->kind
== cdk_ptrmem
10266 && TREE_CODE (type
) == FUNCTION_TYPE
)
10268 memfn_quals
|= type_memfn_quals (type
);
10269 type
= build_memfn_type (type
,
10270 declarator
->u
.pointer
.class_type
,
10273 if (type
== error_mark_node
)
10274 return error_mark_node
;
10276 rqual
= REF_QUAL_NONE
;
10277 memfn_quals
= TYPE_UNQUALIFIED
;
10280 if (TREE_CODE (type
) == FUNCTION_TYPE
10281 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
10282 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
10283 error (declarator
->kind
== cdk_reference
10284 ? G_("cannot declare reference to qualified function type %qT")
10285 : G_("cannot declare pointer to qualified function type %qT"),
10288 /* When the pointed-to type involves components of variable size,
10289 care must be taken to ensure that the size evaluation code is
10290 emitted early enough to dominate all the possible later uses
10291 and late enough for the variables on which it depends to have
10294 This is expected to happen automatically when the pointed-to
10295 type has a name/declaration of it's own, but special attention
10296 is required if the type is anonymous.
10298 We handle the NORMAL and FIELD contexts here by inserting a
10299 dummy statement that just evaluates the size at a safe point
10300 and ensures it is not deferred until e.g. within a deeper
10301 conditional context (c++/43555).
10303 We expect nothing to be needed here for PARM or TYPENAME.
10304 Evaluating the size at this point for TYPENAME would
10305 actually be incorrect, as we might be in the middle of an
10306 expression with side effects on the pointed-to type size
10307 "arguments" prior to the pointer declaration point and the
10308 size evaluation could end up prior to the side effects. */
10310 if (!TYPE_NAME (type
)
10311 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
10312 && at_function_scope_p ()
10313 && variably_modified_type_p (type
, NULL_TREE
))
10314 /* Force evaluation of the SAVE_EXPR. */
10315 finish_expr_stmt (TYPE_SIZE (type
));
10317 if (declarator
->kind
== cdk_reference
)
10319 /* In C++0x, the type we are creating a reference to might be
10320 a typedef which is itself a reference type. In that case,
10321 we follow the reference collapsing rules in
10322 [7.1.3/8 dcl.typedef] to create the final reference type:
10324 "If a typedef TD names a type that is a reference to a type
10325 T, an attempt to create the type 'lvalue reference to cv TD'
10326 creates the type 'lvalue reference to T,' while an attempt
10327 to create the type "rvalue reference to cv TD' creates the
10330 if (VOID_TYPE_P (type
))
10331 /* We already gave an error. */;
10332 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10334 if (declarator
->u
.reference
.rvalue_ref
)
10335 /* Leave type alone. */;
10337 type
= cp_build_reference_type (TREE_TYPE (type
), false);
10340 type
= cp_build_reference_type
10341 (type
, declarator
->u
.reference
.rvalue_ref
);
10343 /* In C++0x, we need this check for direct reference to
10344 reference declarations, which are forbidden by
10345 [8.3.2/5 dcl.ref]. Reference to reference declarations
10346 are only allowed indirectly through typedefs and template
10347 type arguments. Example:
10349 void foo(int & &); // invalid ref-to-ref decl
10351 typedef int & int_ref;
10352 void foo(int_ref &); // valid ref-to-ref decl
10354 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
10355 error ("cannot declare reference to %q#T, which is not "
10356 "a typedef or a template type argument", type
);
10358 else if (TREE_CODE (type
) == METHOD_TYPE
)
10359 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10360 else if (declarator
->kind
== cdk_ptrmem
)
10362 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
10363 != NAMESPACE_DECL
);
10364 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
10365 /* We will already have complained. */
10366 type
= error_mark_node
;
10368 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
10372 type
= build_pointer_type (type
);
10374 /* Process a list of type modifier keywords (such as
10375 const or volatile) that were given inside the `*' or `&'. */
10377 if (declarator
->u
.pointer
.qualifiers
)
10380 = cp_build_qualified_type (type
,
10381 declarator
->u
.pointer
.qualifiers
);
10382 type_quals
= cp_type_quals (type
);
10385 /* Apply C++11 attributes to the pointer, and not to the
10386 type pointed to. This is unlike what is done for GNU
10387 attributes above. It is to comply with [dcl.ptr]/1:
10389 [the optional attribute-specifier-seq (7.6.1) appertains
10390 to the pointer and not to the object pointed to]. */
10391 if (declarator
->std_attributes
)
10392 decl_attributes (&type
, declarator
->std_attributes
,
10402 gcc_unreachable ();
10406 /* A `constexpr' specifier used in an object declaration declares
10407 the object as `const'. */
10408 if (constexpr_p
&& innermost_code
!= cdk_function
)
10410 /* DR1688 says that a `constexpr' specifier in combination with
10411 `volatile' is valid. */
10413 if (TREE_CODE (type
) != REFERENCE_TYPE
)
10415 type_quals
|= TYPE_QUAL_CONST
;
10416 type
= cp_build_qualified_type (type
, type_quals
);
10420 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
10421 && TREE_CODE (type
) != FUNCTION_TYPE
10422 && TREE_CODE (type
) != METHOD_TYPE
10423 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
10425 error ("template-id %qD used as a declarator",
10427 unqualified_id
= dname
;
10430 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10431 qualified with a class-name, turn it into a METHOD_TYPE, unless
10432 we know that the function is static. We take advantage of this
10433 opportunity to do other processing that pertains to entities
10434 explicitly declared to be class members. Note that if DECLARATOR
10435 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10436 would not have exited the loop above. */
10438 && declarator
->u
.id
.qualifying_scope
10439 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
10441 ctype
= declarator
->u
.id
.qualifying_scope
;
10442 ctype
= TYPE_MAIN_VARIANT (ctype
);
10443 template_count
= num_template_headers_for_class (ctype
);
10445 if (ctype
== current_class_type
)
10449 permerror (input_location
, "member functions are implicitly friends of their class");
10453 permerror (declarator
->id_loc
,
10454 "extra qualification %<%T::%> on member %qs",
10457 else if (/* If the qualifying type is already complete, then we
10458 can skip the following checks. */
10459 !COMPLETE_TYPE_P (ctype
)
10460 && (/* If the function is being defined, then
10461 qualifying type must certainly be complete. */
10463 /* A friend declaration of "T::f" is OK, even if
10464 "T" is a template parameter. But, if this
10465 function is not a friend, the qualifying type
10466 must be a class. */
10467 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10468 /* For a declaration, the type need not be
10469 complete, if either it is dependent (since there
10470 is no meaningful definition of complete in that
10471 case) or the qualifying class is currently being
10473 || !(dependent_type_p (ctype
)
10474 || currently_open_class (ctype
)))
10475 /* Check that the qualifying type is complete. */
10476 && !complete_type_or_else (ctype
, NULL_TREE
))
10477 return error_mark_node
;
10478 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10480 if (current_class_type
10481 && (!friendp
|| funcdef_flag
))
10483 error (funcdef_flag
10484 ? G_("cannot define member function %<%T::%s%> "
10486 : G_("cannot declare member function %<%T::%s%> "
10488 ctype
, name
, current_class_type
);
10489 return error_mark_node
;
10492 else if (typedef_p
&& current_class_type
)
10494 error ("cannot declare member %<%T::%s%> within %qT",
10495 ctype
, name
, current_class_type
);
10496 return error_mark_node
;
10500 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10501 ctype
= current_class_type
;
10503 /* Now TYPE has the actual type. */
10505 if (returned_attrs
)
10508 *attrlist
= chainon (returned_attrs
, *attrlist
);
10510 attrlist
= &returned_attrs
;
10514 && declarator
->kind
== cdk_id
10515 && declarator
->std_attributes
)
10516 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10517 a declarator-id appertains to the entity that is declared. */
10518 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10520 /* Handle parameter packs. */
10521 if (parameter_pack_p
)
10523 if (decl_context
== PARM
)
10524 /* Turn the type into a pack expansion.*/
10525 type
= make_pack_expansion (type
);
10527 error ("non-parameter %qs cannot be a parameter pack", name
);
10530 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10531 && !processing_template_decl
10532 && variably_modified_type_p (type
, NULL_TREE
))
10534 if (decl_context
== FIELD
)
10535 error ("data member may not have variably modified type %qT", type
);
10537 error ("parameter may not have variably modified type %qT", type
);
10538 type
= error_mark_node
;
10541 if (explicitp
== 1 || (explicitp
&& friendp
))
10543 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10544 in the declaration of a constructor or conversion function within
10545 a class definition. */
10546 if (!current_class_type
)
10547 error_at (declspecs
->locations
[ds_explicit
],
10548 "%<explicit%> outside class declaration");
10550 error_at (declspecs
->locations
[ds_explicit
],
10551 "%<explicit%> in friend declaration");
10553 error_at (declspecs
->locations
[ds_explicit
],
10554 "only declarations of constructors and conversion operators "
10555 "can be %<explicit%>");
10559 if (storage_class
== sc_mutable
)
10561 if (decl_context
!= FIELD
|| friendp
)
10563 error ("non-member %qs cannot be declared %<mutable%>", name
);
10564 storage_class
= sc_none
;
10566 else if (decl_context
== TYPENAME
|| typedef_p
)
10568 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10569 storage_class
= sc_none
;
10571 else if (TREE_CODE (type
) == FUNCTION_TYPE
10572 || TREE_CODE (type
) == METHOD_TYPE
)
10574 error ("function %qs cannot be declared %<mutable%>", name
);
10575 storage_class
= sc_none
;
10579 error ("static %qs cannot be declared %<mutable%>", name
);
10580 storage_class
= sc_none
;
10582 else if (type_quals
& TYPE_QUAL_CONST
)
10584 error ("const %qs cannot be declared %<mutable%>", name
);
10585 storage_class
= sc_none
;
10587 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10589 permerror (input_location
, "reference %qs cannot be declared "
10590 "%<mutable%>", name
);
10591 storage_class
= sc_none
;
10595 /* If this is declaring a typedef name, return a TYPE_DECL. */
10596 if (typedef_p
&& decl_context
!= TYPENAME
)
10600 /* Note that the grammar rejects storage classes
10601 in typenames, fields or parameters. */
10602 if (current_lang_name
== lang_name_java
)
10603 TYPE_FOR_JAVA (type
) = 1;
10605 /* This declaration:
10607 typedef void f(int) const;
10609 declares a function type which is not a member of any
10610 particular class, but which is cv-qualified; for
10611 example "f S::*" declares a pointer to a const-qualified
10612 member function of S. We record the cv-qualification in the
10614 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10616 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10618 /* We have now dealt with these qualifiers. */
10619 memfn_quals
= TYPE_UNQUALIFIED
;
10620 rqual
= REF_QUAL_NONE
;
10623 if (type_uses_auto (type
))
10625 error ("typedef declared %<auto%>");
10626 type
= error_mark_node
;
10630 error_at (location_of (reqs
), "requires-clause on typedef");
10632 if (decl_context
== FIELD
)
10633 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10635 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10636 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10637 error_at (DECL_SOURCE_LOCATION (decl
),
10638 "typedef name may not be a nested-name-specifier");
10639 TREE_TYPE (decl
) = error_mark_node
;
10642 if (decl_context
!= FIELD
)
10644 if (!current_function_decl
)
10645 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10646 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10647 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10648 (current_function_decl
)))
10649 /* The TYPE_DECL is "abstract" because there will be
10650 clones of this constructor/destructor, and there will
10651 be copies of this TYPE_DECL generated in those
10652 clones. The decloning optimization (for space) may
10653 revert this subsequently if it determines that
10654 the clones should share a common implementation. */
10655 DECL_ABSTRACT_P (decl
) = true;
10657 else if (current_class_type
10658 && constructor_name_p (unqualified_id
, current_class_type
))
10659 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10660 "as enclosing class",
10663 /* If the user declares "typedef struct {...} foo" then the
10664 struct will have an anonymous name. Fill that name in now.
10665 Nothing can refer to it, so nothing needs know about the name
10667 if (type
!= error_mark_node
10669 && TYPE_NAME (type
)
10670 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10671 && TYPE_ANONYMOUS_P (type
)
10672 && declspecs
->type_definition_p
10673 && attributes_naming_typedef_ok (*attrlist
)
10674 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10678 /* Replace the anonymous name with the real name everywhere. */
10679 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10681 if (anon_aggrname_p (TYPE_IDENTIFIER (t
)))
10682 /* We do not rename the debug info representing the
10683 anonymous tagged type because the standard says in
10684 [dcl.typedef] that the naming applies only for
10685 linkage purposes. */
10686 /*debug_hooks->set_name (t, decl);*/
10687 TYPE_NAME (t
) = decl
;
10690 if (TYPE_LANG_SPECIFIC (type
))
10691 TYPE_WAS_ANONYMOUS (type
) = 1;
10693 /* If this is a typedef within a template class, the nested
10694 type is a (non-primary) template. The name for the
10695 template needs updating as well. */
10696 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10697 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10698 = TYPE_IDENTIFIER (type
);
10700 /* Adjust linkage now that we aren't anonymous anymore. */
10701 reset_type_linkage (type
);
10703 /* FIXME remangle member functions; member functions of a
10704 type with external linkage have external linkage. */
10708 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10709 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10711 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10712 memfn_quals
!= TYPE_UNQUALIFIED
,
10713 inlinep
, friendp
, raises
!= NULL_TREE
);
10715 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10716 /* Acknowledge that this was written:
10717 `using analias = atype;'. */
10718 TYPE_DECL_ALIAS_P (decl
) = 1;
10723 /* Detect the case of an array type of unspecified size
10724 which came, as such, direct from a typedef name.
10725 We must copy the type, so that the array's domain can be
10726 individually set by the object's initializer. */
10728 if (type
&& typedef_type
10729 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10730 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10731 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10733 /* Detect where we're using a typedef of function type to declare a
10734 function. PARMS will not be set, so we must create it now. */
10736 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10738 tree decls
= NULL_TREE
;
10741 for (args
= TYPE_ARG_TYPES (type
);
10742 args
&& args
!= void_list_node
;
10743 args
= TREE_CHAIN (args
))
10745 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10747 DECL_CHAIN (decl
) = decls
;
10751 parms
= nreverse (decls
);
10753 if (decl_context
!= TYPENAME
)
10755 /* The qualifiers on the function type become the qualifiers on
10756 the non-static member function. */
10757 memfn_quals
|= type_memfn_quals (type
);
10758 rqual
= type_memfn_rqual (type
);
10759 type_quals
= TYPE_UNQUALIFIED
;
10763 /* If this is a type name (such as, in a cast or sizeof),
10764 compute the type and return it now. */
10766 if (decl_context
== TYPENAME
)
10768 /* Note that here we don't care about type_quals. */
10770 /* Special case: "friend class foo" looks like a TYPENAME context. */
10775 error ("%<inline%> specified for friend class declaration");
10781 /* Don't allow friend declaration without a class-key. */
10782 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10783 permerror (input_location
, "template parameters cannot be friends");
10784 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10785 permerror (input_location
, "friend declaration requires class-key, "
10786 "i.e. %<friend class %T::%D%>",
10787 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10789 permerror (input_location
, "friend declaration requires class-key, "
10790 "i.e. %<friend %#T%>",
10794 /* Only try to do this stuff if we didn't already give up. */
10795 if (type
!= integer_type_node
)
10797 /* A friendly class? */
10798 if (current_class_type
)
10799 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10800 /*complain=*/true);
10802 error ("trying to make class %qT a friend of global scope",
10805 type
= void_type_node
;
10808 else if (memfn_quals
|| rqual
)
10810 if (ctype
== NULL_TREE
10811 && TREE_CODE (type
) == METHOD_TYPE
)
10812 ctype
= TYPE_METHOD_BASETYPE (type
);
10815 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10816 /* Core issue #547: need to allow this in template type args.
10817 Allow it in general in C++11 for alias-declarations. */
10818 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10819 && TREE_CODE (type
) == FUNCTION_TYPE
)
10820 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10822 error ("invalid qualifiers on non-member function type");
10826 error_at (location_of (reqs
), "requires-clause on type-id");
10830 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10831 && decl_context
!= CATCHPARM
10832 && TREE_CODE (type
) != UNION_TYPE
10835 error ("abstract declarator %qT used as declaration", type
);
10836 return error_mark_node
;
10839 /* Only functions may be declared using an operator-function-id. */
10841 && IDENTIFIER_OPNAME_P (unqualified_id
)
10842 && TREE_CODE (type
) != FUNCTION_TYPE
10843 && TREE_CODE (type
) != METHOD_TYPE
)
10845 error ("declaration of %qD as non-function", unqualified_id
);
10846 return error_mark_node
;
10850 && TREE_CODE (type
) != FUNCTION_TYPE
10851 && TREE_CODE (type
) != METHOD_TYPE
)
10852 error_at (location_of (reqs
),
10853 "requires-clause on declaration of non-function type %qT",
10856 /* We don't check parameter types here because we can emit a better
10857 error message later. */
10858 if (decl_context
!= PARM
)
10860 type
= check_var_type (unqualified_id
, type
);
10861 if (type
== error_mark_node
)
10862 return error_mark_node
;
10865 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10866 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10868 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10870 if (ctype
|| in_namespace
)
10871 error ("cannot use %<::%> in parameter declaration");
10873 if (type_uses_auto (type
))
10875 if (cxx_dialect
>= cxx14
)
10876 error ("%<auto%> parameter not permitted in this context");
10878 error ("parameter declared %<auto%>");
10879 type
= error_mark_node
;
10882 /* A parameter declared as an array of T is really a pointer to T.
10883 One declared as a function is really a pointer to a function.
10884 One declared as a member is really a pointer to member. */
10886 if (TREE_CODE (type
) == ARRAY_TYPE
)
10888 /* Transfer const-ness of array into that of type pointed to. */
10889 type
= build_pointer_type (TREE_TYPE (type
));
10890 type_quals
= TYPE_UNQUALIFIED
;
10891 array_parameter_p
= true;
10893 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10894 type
= build_pointer_type (type
);
10897 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10898 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10900 cp_cv_quals real_quals
= memfn_quals
;
10901 if (cxx_dialect
< cxx14
&& constexpr_p
10902 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10903 real_quals
|= TYPE_QUAL_CONST
;
10904 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10910 if (decl_context
== PARM
)
10912 decl
= cp_build_parm_decl (unqualified_id
, type
);
10913 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
10915 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10916 memfn_quals
!= TYPE_UNQUALIFIED
,
10917 inlinep
, friendp
, raises
!= NULL_TREE
);
10919 else if (decl_context
== FIELD
)
10921 if (!staticp
&& !friendp
&& TREE_CODE (type
) != METHOD_TYPE
10922 && type_uses_auto (type
))
10924 error ("non-static data member declared %<auto%>");
10925 type
= error_mark_node
;
10928 /* The C99 flexible array extension. */
10929 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10930 && TYPE_DOMAIN (type
) == NULL_TREE
)
10932 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10933 tf_warning_or_error
);
10934 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10937 if (type
== error_mark_node
)
10939 /* Happens when declaring arrays of sizes which
10940 are error_mark_node, for example. */
10943 else if (in_namespace
&& !friendp
)
10945 /* Something like struct S { int N::j; }; */
10946 error ("invalid use of %<::%>");
10947 return error_mark_node
;
10949 else if (TREE_CODE (type
) == FUNCTION_TYPE
10950 || TREE_CODE (type
) == METHOD_TYPE
)
10953 tree function_context
;
10957 /* This should never happen in pure C++ (the check
10958 could be an assert). It could happen in
10959 Objective-C++ if someone writes invalid code that
10960 uses a function declaration for an instance
10961 variable or property (instance variables and
10962 properties are parsed as FIELD_DECLs, but they are
10963 part of an Objective-C class, not a C++ class).
10964 That code is invalid and is caught by this
10968 error ("declaration of function %qD in invalid context",
10970 return error_mark_node
;
10973 /* ``A union may [ ... ] not [ have ] virtual functions.''
10975 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10977 error ("function %qD declared virtual inside a union",
10979 return error_mark_node
;
10982 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10986 error ("%qD cannot be declared virtual, since it "
10987 "is always static",
10994 /* Check that the name used for a destructor makes sense. */
10995 if (sfk
== sfk_destructor
)
10997 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
11001 gcc_assert (friendp
);
11002 error ("expected qualified name in friend declaration "
11003 "for destructor %qD", uqname
);
11004 return error_mark_node
;
11007 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
11009 error ("declaration of %qD as member of %qT",
11011 return error_mark_node
;
11015 error ("a destructor cannot be %<concept%>");
11016 return error_mark_node
;
11020 error ("a destructor cannot be %<constexpr%>");
11021 return error_mark_node
;
11024 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
11026 error ("expected qualified name in friend declaration "
11027 "for constructor %qD",
11028 id_declarator
->u
.id
.unqualified_name
);
11029 return error_mark_node
;
11031 if (sfk
== sfk_constructor
)
11034 error ("a constructor cannot be %<concept%>");
11035 return error_mark_node
;
11039 error ("a concept cannot be a member function");
11043 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11045 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
11046 if (variable_template_p (tmpl
))
11048 error ("specialization of variable template %qD "
11049 "declared as function", tmpl
);
11050 inform (DECL_SOURCE_LOCATION (tmpl
),
11051 "variable template declared here");
11052 return error_mark_node
;
11056 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
11057 function_context
= (ctype
!= NULL_TREE
) ?
11058 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
11059 publicp
= (! friendp
|| ! staticp
)
11060 && function_context
== NULL_TREE
;
11062 if (late_return_type_p
)
11063 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11065 decl
= grokfndecl (ctype
, type
,
11066 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
11067 ? unqualified_id
: dname
,
11071 virtualp
, flags
, memfn_quals
, rqual
, raises
,
11072 friendp
? -1 : 0, friendp
, publicp
,
11073 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11074 initialized
== SD_DELETED
, sfk
,
11075 funcdef_flag
, template_count
, in_namespace
,
11076 attrlist
, declarator
->id_loc
);
11077 decl
= set_virt_specifiers (decl
, virt_specifiers
);
11078 if (decl
== NULL_TREE
)
11079 return error_mark_node
;
11081 /* This clobbers the attrs stored in `decl' from `attrlist'. */
11082 /* The decl and setting of decl_attr is also turned off. */
11083 decl
= build_decl_attribute_variant (decl
, decl_attr
);
11086 /* [class.conv.ctor]
11088 A constructor declared without the function-specifier
11089 explicit that can be called with a single parameter
11090 specifies a conversion from the type of its first
11091 parameter to the type of its class. Such a constructor
11092 is called a converting constructor. */
11093 if (explicitp
== 2)
11094 DECL_NONCONVERTING_P (decl
) = 1;
11096 else if (!staticp
&& !dependent_type_p (type
)
11097 && !COMPLETE_TYPE_P (complete_type (type
))
11098 && (TREE_CODE (type
) != ARRAY_TYPE
11099 || !COMPLETE_TYPE_P (TREE_TYPE (type
))
11100 || initialized
== 0))
11102 if (unqualified_id
)
11104 error ("field %qD has incomplete type %qT",
11105 unqualified_id
, type
);
11106 cxx_incomplete_type_inform (strip_array_types (type
));
11109 error ("name %qT has incomplete type", type
);
11111 type
= error_mark_node
;
11118 error ("%qE is neither function nor member function; "
11119 "cannot be declared friend", unqualified_id
);
11127 /* Friends are treated specially. */
11128 if (ctype
== current_class_type
)
11129 ; /* We already issued a permerror. */
11130 else if (decl
&& DECL_NAME (decl
))
11132 if (template_class_depth (current_class_type
) == 0)
11134 decl
= check_explicit_specialization
11135 (unqualified_id
, decl
, template_count
,
11136 2 * funcdef_flag
+ 4);
11137 if (decl
== error_mark_node
)
11138 return error_mark_node
;
11141 decl
= do_friend (ctype
, unqualified_id
, decl
,
11147 return error_mark_node
;
11150 /* Structure field. It may not be a function, except for C++. */
11152 if (decl
== NULL_TREE
)
11156 /* C++ allows static class members. All other work
11157 for this is done by grokfield. */
11158 decl
= build_lang_decl_loc (declarator
11159 ? declarator
->id_loc
11161 VAR_DECL
, unqualified_id
, type
);
11162 set_linkage_for_static_data_member (decl
);
11163 /* Even if there is an in-class initialization, DECL
11164 is considered undefined until an out-of-class
11165 definition is provided. */
11166 DECL_EXTERNAL (decl
) = 1;
11170 CP_DECL_THREAD_LOCAL_P (decl
) = true;
11171 if (!processing_template_decl
)
11172 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
11173 if (declspecs
->gnu_thread_keyword_p
)
11174 SET_DECL_GNU_TLS_P (decl
);
11177 error ("static data member %qE declared %<concept%>",
11179 else if (constexpr_p
&& !initialized
)
11181 error ("constexpr static data member %qD must have an "
11182 "initializer", decl
);
11183 constexpr_p
= false;
11189 error ("non-static data member %qE declared %<concept%>",
11191 else if (constexpr_p
)
11193 error ("non-static data member %qE declared %<constexpr%>",
11195 constexpr_p
= false;
11197 decl
= build_decl (input_location
,
11198 FIELD_DECL
, unqualified_id
, type
);
11199 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
11200 if (bitfield
&& !unqualified_id
)
11201 TREE_NO_WARNING (decl
) = 1;
11203 if (storage_class
== sc_mutable
)
11205 DECL_MUTABLE_P (decl
) = 1;
11206 storage_class
= sc_none
;
11211 /* An attempt is being made to initialize a non-static
11212 member. This is new in C++11. */
11213 maybe_warn_cpp0x (CPP0X_NSDMI
);
11215 /* If this has been parsed with static storage class, but
11216 errors forced staticp to be cleared, ensure NSDMI is
11218 if (declspecs
->storage_class
== sc_static
)
11219 DECL_INITIAL (decl
) = error_mark_node
;
11223 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
11224 memfn_quals
!= TYPE_UNQUALIFIED
,
11225 inlinep
, friendp
, raises
!= NULL_TREE
);
11228 else if (TREE_CODE (type
) == FUNCTION_TYPE
11229 || TREE_CODE (type
) == METHOD_TYPE
)
11231 tree original_name
;
11234 if (!unqualified_id
)
11235 return error_mark_node
;
11237 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
11238 original_name
= dname
;
11240 original_name
= unqualified_id
;
11242 if (storage_class
== sc_auto
)
11243 error ("storage class %<auto%> invalid for function %qs", name
);
11244 else if (storage_class
== sc_register
)
11245 error ("storage class %<register%> invalid for function %qs", name
);
11248 if (declspecs
->gnu_thread_keyword_p
)
11249 error ("storage class %<__thread%> invalid for function %qs",
11252 error ("storage class %<thread_local%> invalid for function %qs",
11256 if (virt_specifiers
)
11257 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
11258 /* Function declaration not at top level.
11259 Storage classes other than `extern' are not allowed
11260 and `extern' makes no difference. */
11261 if (! toplevel_bindings_p ()
11262 && (storage_class
== sc_static
11263 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
11266 if (storage_class
== sc_static
)
11267 pedwarn (input_location
, OPT_Wpedantic
,
11268 "%<static%> specified invalid for function %qs "
11269 "declared out of global scope", name
);
11271 pedwarn (input_location
, OPT_Wpedantic
,
11272 "%<inline%> specifier invalid for function %qs "
11273 "declared out of global scope", name
);
11276 if (ctype
== NULL_TREE
)
11280 error ("virtual non-class function %qs", name
);
11283 else if (sfk
== sfk_constructor
11284 || sfk
== sfk_destructor
)
11286 error (funcdef_flag
11287 ? G_("%qs defined in a non-class scope")
11288 : G_("%qs declared in a non-class scope"), name
);
11293 /* Record whether the function is public. */
11294 publicp
= (ctype
!= NULL_TREE
11295 || storage_class
!= sc_static
);
11297 if (late_return_type_p
)
11298 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
11300 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
11301 reqs
, virtualp
, flags
, memfn_quals
, rqual
, raises
,
11304 inlinep
| (2 * constexpr_p
) | (4 * concept_p
),
11305 initialized
== SD_DELETED
,
11308 template_count
, in_namespace
, attrlist
,
11309 declarator
->id_loc
);
11310 if (decl
== NULL_TREE
)
11311 return error_mark_node
;
11315 int invalid_static
= 0;
11317 /* Don't allow a static member function in a class, and forbid
11318 declaring main to be static. */
11319 if (TREE_CODE (type
) == METHOD_TYPE
)
11321 permerror (input_location
, "cannot declare member function %qD to have "
11322 "static linkage", decl
);
11323 invalid_static
= 1;
11325 else if (current_function_decl
)
11327 /* FIXME need arm citation */
11328 error ("cannot declare static function inside another function");
11329 invalid_static
= 1;
11332 if (invalid_static
)
11335 storage_class
= sc_none
;
11341 /* It's a variable. */
11343 /* An uninitialized decl with `extern' is a reference. */
11344 decl
= grokvardecl (type
, dname
, unqualified_id
,
11347 ((type_quals
& TYPE_QUAL_CONST
) != 0) | (2 * concept_p
),
11349 ctype
? ctype
: in_namespace
);
11350 if (decl
== NULL_TREE
)
11351 return error_mark_node
;
11353 bad_specifiers (decl
, BSP_VAR
, virtualp
,
11354 memfn_quals
!= TYPE_UNQUALIFIED
,
11355 inlinep
, friendp
, raises
!= NULL_TREE
);
11359 DECL_CONTEXT (decl
) = ctype
;
11362 permerror (input_location
, "%<static%> may not be used when defining "
11363 "(as opposed to declaring) a static data member");
11365 storage_class
= sc_none
;
11367 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
11369 error ("static member %qD declared %<register%>", decl
);
11370 storage_class
= sc_none
;
11372 if (storage_class
== sc_extern
&& pedantic
)
11374 pedwarn (input_location
, OPT_Wpedantic
,
11375 "cannot explicitly declare member %q#D to have "
11376 "extern linkage", decl
);
11377 storage_class
= sc_none
;
11380 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
11382 error ("declaration of constexpr variable %qD is not a definition",
11384 constexpr_p
= false;
11388 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
11390 if (toplevel_bindings_p ())
11392 /* It's common practice (and completely valid) to have a const
11393 be initialized and declared extern. */
11394 if (!(type_quals
& TYPE_QUAL_CONST
))
11395 warning (0, "%qs initialized and declared %<extern%>", name
);
11399 error ("%qs has both %<extern%> and initializer", name
);
11400 return error_mark_node
;
11404 /* Record `register' declaration for warnings on &
11405 and in case doing stupid register allocation. */
11407 if (storage_class
== sc_register
)
11408 DECL_REGISTER (decl
) = 1;
11409 else if (storage_class
== sc_extern
)
11410 DECL_THIS_EXTERN (decl
) = 1;
11411 else if (storage_class
== sc_static
)
11412 DECL_THIS_STATIC (decl
) = 1;
11414 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11415 if (constexpr_p
&& VAR_P (decl
))
11416 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
11418 /* Record constancy and volatility on the DECL itself . There's
11419 no need to do this when processing a template; we'll do this
11420 for the instantiated declaration based on the type of DECL. */
11421 if (!processing_template_decl
)
11422 cp_apply_type_quals_to_decl (type_quals
, decl
);
11428 /* Subroutine of start_function. Ensure that each of the parameter
11429 types (as listed in PARMS) is complete, as is required for a
11430 function definition. */
11433 require_complete_types_for_parms (tree parms
)
11435 for (; parms
; parms
= DECL_CHAIN (parms
))
11437 if (dependent_type_p (TREE_TYPE (parms
)))
11439 if (!VOID_TYPE_P (TREE_TYPE (parms
))
11440 && complete_type_or_else (TREE_TYPE (parms
), parms
))
11442 relayout_decl (parms
);
11443 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
11446 /* grokparms or complete_type_or_else will have already issued
11448 TREE_TYPE (parms
) = error_mark_node
;
11452 /* Returns nonzero if T is a local variable. */
11455 local_variable_p (const_tree t
)
11458 /* A VAR_DECL with a context that is a _TYPE is a static data
11460 && !TYPE_P (CP_DECL_CONTEXT (t
))
11461 /* Any other non-local variable must be at namespace scope. */
11462 && !DECL_NAMESPACE_SCOPE_P (t
))
11463 || (TREE_CODE (t
) == PARM_DECL
))
11469 /* Like local_variable_p, but suitable for use as a tree-walking
11473 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
11476 if (local_variable_p (*tp
)
11477 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
11479 else if (TYPE_P (*tp
))
11480 *walk_subtrees
= 0;
11485 /* Check that ARG, which is a default-argument expression for a
11486 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11487 something goes wrong. DECL may also be a _TYPE node, rather than a
11488 DECL, if there is no DECL available. */
11491 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
11496 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11497 /* We get a DEFAULT_ARG when looking at an in-class declaration
11498 with a default argument. Ignore the argument for now; we'll
11499 deal with it after the class is complete. */
11508 decl_type
= TREE_TYPE (decl
);
11510 if (arg
== error_mark_node
11511 || decl
== error_mark_node
11512 || TREE_TYPE (arg
) == error_mark_node
11513 || decl_type
== error_mark_node
)
11514 /* Something already went wrong. There's no need to check
11516 return error_mark_node
;
11518 /* [dcl.fct.default]
11520 A default argument expression is implicitly converted to the
11522 ++cp_unevaluated_operand
;
11523 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
11525 --cp_unevaluated_operand
;
11527 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
11529 if (TYPE_PTR_OR_PTRMEM_P (decl_type
)
11530 && null_ptr_cst_p (arg
))
11531 return nullptr_node
;
11533 /* [dcl.fct.default]
11535 Local variables shall not be used in default argument
11538 The keyword `this' shall not be used in a default argument of a
11539 member function. */
11540 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11543 if (complain
& tf_warning_or_error
)
11545 if (DECL_NAME (var
) == this_identifier
)
11546 permerror (input_location
, "default argument %qE uses %qD",
11549 error ("default argument %qE uses local variable %qD", arg
, var
);
11551 return error_mark_node
;
11558 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11561 type_is_deprecated (tree type
)
11563 enum tree_code code
;
11564 if (TREE_DEPRECATED (type
))
11566 if (TYPE_NAME (type
)
11567 && TREE_DEPRECATED (TYPE_NAME (type
)))
11570 /* Do warn about using typedefs to a deprecated class. */
11571 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11572 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11574 code
= TREE_CODE (type
);
11576 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11577 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11578 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11579 return type_is_deprecated (TREE_TYPE (type
));
11581 if (TYPE_PTRMEMFUNC_P (type
))
11582 return type_is_deprecated
11583 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11588 /* Decode the list of parameter types for a function type.
11589 Given the list of things declared inside the parens,
11590 return a list of types.
11592 If this parameter does not end with an ellipsis, we append
11595 *PARMS is set to the chain of PARM_DECLs created. */
11598 grokparms (tree parmlist
, tree
*parms
)
11600 tree result
= NULL_TREE
;
11601 tree decls
= NULL_TREE
;
11605 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11607 tree type
= NULL_TREE
;
11608 tree init
= TREE_PURPOSE (parm
);
11609 tree decl
= TREE_VALUE (parm
);
11610 const char *errmsg
;
11612 if (parm
== void_list_node
)
11615 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11618 type
= TREE_TYPE (decl
);
11619 if (VOID_TYPE_P (type
))
11621 if (same_type_p (type
, void_type_node
)
11623 && !DECL_NAME (decl
) && !result
11624 && TREE_CHAIN (parm
) == void_list_node
)
11625 /* DR 577: A parameter list consisting of a single
11626 unnamed parameter of non-dependent type 'void'. */
11628 else if (cv_qualified_p (type
))
11629 error_at (DECL_SOURCE_LOCATION (decl
),
11630 "invalid use of cv-qualified type %qT in "
11631 "parameter declaration", type
);
11633 error_at (DECL_SOURCE_LOCATION (decl
),
11634 "invalid use of type %<void%> in parameter "
11636 /* It's not a good idea to actually create parameters of
11637 type `void'; other parts of the compiler assume that a
11638 void type terminates the parameter list. */
11639 type
= error_mark_node
;
11640 TREE_TYPE (decl
) = error_mark_node
;
11643 if (type
!= error_mark_node
11644 && TYPE_FOR_JAVA (type
)
11645 && MAYBE_CLASS_TYPE_P (type
))
11647 error ("parameter %qD has Java class type", decl
);
11648 type
= error_mark_node
;
11649 TREE_TYPE (decl
) = error_mark_node
;
11653 if (type
!= error_mark_node
11654 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11657 type
= error_mark_node
;
11658 TREE_TYPE (decl
) = error_mark_node
;
11661 if (type
!= error_mark_node
)
11663 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11665 tree deptype
= type_is_deprecated (type
);
11667 warn_deprecated_use (deptype
, NULL_TREE
);
11670 /* Top-level qualifiers on the parameters are
11671 ignored for function types. */
11672 type
= cp_build_qualified_type (type
, 0);
11673 if (TREE_CODE (type
) == METHOD_TYPE
)
11675 error ("parameter %qD invalidly declared method type", decl
);
11676 type
= build_pointer_type (type
);
11677 TREE_TYPE (decl
) = type
;
11679 else if (abstract_virtuals_error (decl
, type
))
11680 any_error
= 1; /* Seems like a good idea. */
11681 else if (POINTER_TYPE_P (type
))
11683 /* [dcl.fct]/6, parameter types cannot contain pointers
11684 (references) to arrays of unknown bound. */
11685 tree t
= TREE_TYPE (type
);
11686 int ptr
= TYPE_PTR_P (type
);
11690 if (TYPE_PTR_P (t
))
11692 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11694 else if (!TYPE_DOMAIN (t
))
11698 if (TREE_CODE (t
) == ARRAY_TYPE
)
11700 ? G_("parameter %qD includes pointer to array of "
11701 "unknown bound %qT")
11702 : G_("parameter %qD includes reference to array of "
11703 "unknown bound %qT"),
11709 else if (init
&& !processing_template_decl
)
11710 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11713 DECL_CHAIN (decl
) = decls
;
11715 result
= tree_cons (init
, type
, result
);
11717 decls
= nreverse (decls
);
11718 result
= nreverse (result
);
11720 result
= chainon (result
, void_list_node
);
11727 /* D is a constructor or overloaded `operator='.
11729 Let T be the class in which D is declared. Then, this function
11732 -1 if D's is an ill-formed constructor or copy assignment operator
11733 whose first parameter is of type `T'.
11734 0 if D is not a copy constructor or copy assignment
11736 1 if D is a copy constructor or copy assignment operator whose
11737 first parameter is a reference to non-const qualified T.
11738 2 if D is a copy constructor or copy assignment operator whose
11739 first parameter is a reference to const qualified T.
11741 This function can be used as a predicate. Positive values indicate
11742 a copy constructor and nonzero values indicate a copy assignment
11746 copy_fn_p (const_tree d
)
11752 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11754 if (TREE_CODE (d
) == TEMPLATE_DECL
11755 || (DECL_TEMPLATE_INFO (d
)
11756 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11757 /* Instantiations of template member functions are never copy
11758 functions. Note that member functions of templated classes are
11759 represented as template functions internally, and we must
11760 accept those as copy functions. */
11763 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11767 arg_type
= TREE_VALUE (args
);
11768 if (arg_type
== error_mark_node
)
11771 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11773 /* Pass by value copy assignment operator. */
11776 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11777 && !TYPE_REF_IS_RVALUE (arg_type
)
11778 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11780 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11786 args
= TREE_CHAIN (args
);
11788 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11789 /* There are more non-optional args. */
11795 /* D is a constructor or overloaded `operator='.
11797 Let T be the class in which D is declared. Then, this function
11798 returns true when D is a move constructor or move assignment
11799 operator, false otherwise. */
11802 move_fn_p (const_tree d
)
11804 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11806 if (cxx_dialect
== cxx98
)
11807 /* There are no move constructors if we are in C++98 mode. */
11810 if (TREE_CODE (d
) == TEMPLATE_DECL
11811 || (DECL_TEMPLATE_INFO (d
)
11812 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11813 /* Instantiations of template member functions are never move
11814 functions. Note that member functions of templated classes are
11815 represented as template functions internally, and we must
11816 accept those as move functions. */
11819 return move_signature_fn_p (d
);
11822 /* D is a constructor or overloaded `operator='.
11824 Then, this function returns true when D has the same signature as a move
11825 constructor or move assignment operator (because either it is such a
11826 ctor/op= or it is a template specialization with the same signature),
11827 false otherwise. */
11830 move_signature_fn_p (const_tree d
)
11834 bool result
= false;
11836 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11840 arg_type
= TREE_VALUE (args
);
11841 if (arg_type
== error_mark_node
)
11844 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11845 && TYPE_REF_IS_RVALUE (arg_type
)
11846 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11850 args
= TREE_CHAIN (args
);
11852 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11853 /* There are more non-optional args. */
11859 /* Remember any special properties of member function DECL. */
11862 grok_special_member_properties (tree decl
)
11866 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11869 class_type
= DECL_CONTEXT (decl
);
11870 if (DECL_CONSTRUCTOR_P (decl
))
11872 int ctor
= copy_fn_p (decl
);
11874 if (!DECL_ARTIFICIAL (decl
))
11875 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11881 A non-template constructor for class X is a copy
11882 constructor if its first parameter is of type X&, const
11883 X&, volatile X& or const volatile X&, and either there
11884 are no other parameters or else all other parameters have
11885 default arguments. */
11886 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11887 if (user_provided_p (decl
))
11888 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11890 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11892 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11893 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11894 else if (move_fn_p (decl
) && user_provided_p (decl
))
11895 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11896 else if (is_list_ctor (decl
))
11897 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11899 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11900 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11901 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11903 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11907 A non-template assignment operator for class X is a copy
11908 assignment operator if its parameter is of type X, X&, const
11909 X&, volatile X& or const volatile X&. */
11911 int assop
= copy_fn_p (decl
);
11915 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11916 if (user_provided_p (decl
))
11917 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11919 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11921 else if (move_fn_p (decl
) && user_provided_p (decl
))
11922 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11924 /* Destructors are handled in check_methods. */
11927 /* Check a constructor DECL has the correct form. Complains
11928 if the class has a constructor of the form X(X). */
11931 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11933 int ctor_parm
= copy_fn_p (decl
);
11939 A declaration of a constructor for a class X is ill-formed if
11940 its first parameter is of type (optionally cv-qualified) X
11941 and either there are no other parameters or else all other
11942 parameters have default arguments.
11944 We *don't* complain about member template instantiations that
11945 have this form, though; they can occur as we try to decide
11946 what constructor to use during overload resolution. Since
11947 overload resolution will never prefer such a constructor to
11948 the non-template copy constructor (which is either explicitly
11949 or implicitly defined), there's no need to worry about their
11950 existence. Theoretically, they should never even be
11951 instantiated, but that's hard to forestall. */
11952 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11960 /* An operator with this code is unary, but can also be binary. */
11963 ambi_op_p (enum tree_code code
)
11965 return (code
== INDIRECT_REF
11966 || code
== ADDR_EXPR
11967 || code
== UNARY_PLUS_EXPR
11968 || code
== NEGATE_EXPR
11969 || code
== PREINCREMENT_EXPR
11970 || code
== PREDECREMENT_EXPR
);
11973 /* An operator with this name can only be unary. */
11976 unary_op_p (enum tree_code code
)
11978 return (code
== TRUTH_NOT_EXPR
11979 || code
== BIT_NOT_EXPR
11980 || code
== COMPONENT_REF
11981 || code
== TYPE_EXPR
);
11984 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11985 errors are issued for invalid declarations. */
11988 grok_op_properties (tree decl
, bool complain
)
11990 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11992 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11993 tree name
= DECL_NAME (decl
);
11994 enum tree_code operator_code
;
11999 /* Count the number of arguments and check for ellipsis. */
12000 for (argtype
= argtypes
, arity
= 0;
12001 argtype
&& argtype
!= void_list_node
;
12002 argtype
= TREE_CHAIN (argtype
))
12004 ellipsis_p
= !argtype
;
12006 class_type
= DECL_CONTEXT (decl
);
12007 if (class_type
&& !CLASS_TYPE_P (class_type
))
12008 class_type
= NULL_TREE
;
12010 if (DECL_CONV_FN_P (decl
))
12011 operator_code
= TYPE_EXPR
;
12015 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
12016 if (ansi_opname (CODE) == name) \
12018 operator_code = (CODE); \
12021 else if (ansi_assopname (CODE) == name) \
12023 operator_code = (CODE); \
12024 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
12028 #include "operators.def"
12029 #undef DEF_OPERATOR
12031 gcc_unreachable ();
12034 gcc_assert (operator_code
!= MAX_TREE_CODES
);
12035 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12038 switch (operator_code
)
12041 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
12045 TYPE_GETS_DELETE (class_type
) |= 1;
12049 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
12052 case VEC_DELETE_EXPR
:
12053 TYPE_GETS_DELETE (class_type
) |= 2;
12060 /* [basic.std.dynamic.allocation]/1:
12062 A program is ill-formed if an allocation function is declared
12063 in a namespace scope other than global scope or declared static
12066 The same also holds true for deallocation functions. */
12067 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
12068 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12070 if (DECL_NAMESPACE_SCOPE_P (decl
))
12072 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
12074 error ("%qD may not be declared within a namespace", decl
);
12077 else if (!TREE_PUBLIC (decl
))
12079 error ("%qD may not be declared as static", decl
);
12085 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
12087 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
12088 DECL_IS_OPERATOR_NEW (decl
) = 1;
12090 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
12091 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
12094 /* An operator function must either be a non-static member function
12095 or have at least one parameter of a class, a reference to a class,
12096 an enumeration, or a reference to an enumeration. 13.4.0.6 */
12097 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
12099 if (operator_code
== TYPE_EXPR
12100 || operator_code
== CALL_EXPR
12101 || operator_code
== COMPONENT_REF
12102 || operator_code
== ARRAY_REF
12103 || operator_code
== NOP_EXPR
)
12105 error ("%qD must be a nonstatic member function", decl
);
12112 if (DECL_STATIC_FUNCTION_P (decl
))
12114 error ("%qD must be either a non-static member "
12115 "function or a non-member function", decl
);
12119 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
12121 tree arg
= non_reference (TREE_VALUE (p
));
12122 if (arg
== error_mark_node
)
12125 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
12126 because these checks are performed even on
12127 template functions. */
12128 if (MAYBE_CLASS_TYPE_P (arg
)
12129 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
12133 if (!p
|| p
== void_list_node
)
12136 error ("%qD must have an argument of class or "
12137 "enumerated type", decl
);
12143 /* There are no restrictions on the arguments to an overloaded
12145 if (operator_code
== CALL_EXPR
)
12148 /* Warn about conversion operators that will never be used. */
12149 if (IDENTIFIER_TYPENAME_P (name
)
12150 && ! DECL_TEMPLATE_INFO (decl
)
12152 /* Warn only declaring the function; there is no need to
12153 warn again about out-of-class definitions. */
12154 && class_type
== current_class_type
)
12156 tree t
= TREE_TYPE (name
);
12157 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
12160 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
12162 if (VOID_TYPE_P (t
))
12163 warning (OPT_Wconversion
,
12165 ? G_("conversion to a reference to void "
12166 "will never use a type conversion operator")
12167 : G_("conversion to void "
12168 "will never use a type conversion operator"));
12169 else if (class_type
)
12171 if (t
== class_type
)
12172 warning (OPT_Wconversion
,
12174 ? G_("conversion to a reference to the same type "
12175 "will never use a type conversion operator")
12176 : G_("conversion to the same type "
12177 "will never use a type conversion operator"));
12178 /* Don't force t to be complete here. */
12179 else if (MAYBE_CLASS_TYPE_P (t
)
12180 && COMPLETE_TYPE_P (t
)
12181 && DERIVED_FROM_P (t
, class_type
))
12182 warning (OPT_Wconversion
,
12184 ? G_("conversion to a reference to a base class "
12185 "will never use a type conversion operator")
12186 : G_("conversion to a base class "
12187 "will never use a type conversion operator"));
12192 if (operator_code
== COND_EXPR
)
12195 error ("ISO C++ prohibits overloading operator ?:");
12198 else if (ellipsis_p
)
12200 error ("%qD must not have variable number of arguments", decl
);
12203 else if (ambi_op_p (operator_code
))
12206 /* We pick the one-argument operator codes by default, so
12207 we don't have to change anything. */
12209 else if (arity
== 2)
12211 /* If we thought this was a unary operator, we now know
12212 it to be a binary operator. */
12213 switch (operator_code
)
12216 operator_code
= MULT_EXPR
;
12220 operator_code
= BIT_AND_EXPR
;
12223 case UNARY_PLUS_EXPR
:
12224 operator_code
= PLUS_EXPR
;
12228 operator_code
= MINUS_EXPR
;
12231 case PREINCREMENT_EXPR
:
12232 operator_code
= POSTINCREMENT_EXPR
;
12235 case PREDECREMENT_EXPR
:
12236 operator_code
= POSTDECREMENT_EXPR
;
12240 gcc_unreachable ();
12243 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
12245 if ((operator_code
== POSTINCREMENT_EXPR
12246 || operator_code
== POSTDECREMENT_EXPR
)
12247 && ! processing_template_decl
12248 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
12251 error ("postfix %qD must take %<int%> as its argument",
12254 error ("postfix %qD must take %<int%> as its second "
12262 error ("%qD must take either zero or one argument", decl
);
12264 error ("%qD must take either one or two arguments", decl
);
12268 /* More Effective C++ rule 6. */
12270 && (operator_code
== POSTINCREMENT_EXPR
12271 || operator_code
== POSTDECREMENT_EXPR
12272 || operator_code
== PREINCREMENT_EXPR
12273 || operator_code
== PREDECREMENT_EXPR
))
12275 tree arg
= TREE_VALUE (argtypes
);
12276 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
12277 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
12278 arg
= TREE_TYPE (arg
);
12279 arg
= TYPE_MAIN_VARIANT (arg
);
12280 if (operator_code
== PREINCREMENT_EXPR
12281 || operator_code
== PREDECREMENT_EXPR
)
12283 if (TREE_CODE (ret
) != REFERENCE_TYPE
12284 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
12286 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
12287 build_reference_type (arg
));
12291 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
12292 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
12296 else if (unary_op_p (operator_code
))
12301 error ("%qD must take %<void%>", decl
);
12303 error ("%qD must take exactly one argument", decl
);
12307 else /* if (binary_op_p (operator_code)) */
12312 error ("%qD must take exactly one argument", decl
);
12314 error ("%qD must take exactly two arguments", decl
);
12318 /* More Effective C++ rule 7. */
12320 && (operator_code
== TRUTH_ANDIF_EXPR
12321 || operator_code
== TRUTH_ORIF_EXPR
12322 || operator_code
== COMPOUND_EXPR
))
12323 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
12327 /* Effective C++ rule 23. */
12330 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
12331 && (operator_code
== PLUS_EXPR
12332 || operator_code
== MINUS_EXPR
12333 || operator_code
== TRUNC_DIV_EXPR
12334 || operator_code
== MULT_EXPR
12335 || operator_code
== TRUNC_MOD_EXPR
)
12336 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12337 warning (OPT_Weffc__
, "%qD should return by value", decl
);
12339 /* [over.oper]/8 */
12340 for (; argtypes
&& argtypes
!= void_list_node
;
12341 argtypes
= TREE_CHAIN (argtypes
))
12342 if (TREE_PURPOSE (argtypes
))
12344 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12345 if (operator_code
== POSTINCREMENT_EXPR
12346 || operator_code
== POSTDECREMENT_EXPR
)
12348 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
12353 error ("%qD cannot have default arguments", decl
);
12361 /* Return a string giving the keyword associate with CODE. */
12363 static const char *
12364 tag_name (enum tag_types code
)
12376 case typename_type
:
12379 gcc_unreachable ();
12383 /* Name lookup in an elaborated-type-specifier (after the keyword
12384 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12385 elaborated-type-specifier is invalid, issue a diagnostic and return
12386 error_mark_node; otherwise, return the *_TYPE to which it referred.
12387 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12390 check_elaborated_type_specifier (enum tag_types tag_code
,
12392 bool allow_template_p
)
12398 struct S { struct S *p; };
12400 name lookup will find the TYPE_DECL for the implicit "S::S"
12401 typedef. Adjust for that here. */
12402 if (DECL_SELF_REFERENCE_P (decl
))
12403 decl
= TYPE_NAME (TREE_TYPE (decl
));
12405 type
= TREE_TYPE (decl
);
12407 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12408 is false for this case as well. */
12409 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12411 error ("using template type parameter %qT after %qs",
12412 type
, tag_name (tag_code
));
12413 return error_mark_node
;
12415 /* Accept template template parameters. */
12416 else if (allow_template_p
12417 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
12418 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
12422 If the identifier resolves to a typedef-name or the
12423 simple-template-id resolves to an alias template
12424 specialization, the elaborated-type-specifier is ill-formed.
12426 In other words, the only legitimate declaration to use in the
12427 elaborated type specifier is the implicit typedef created when
12428 the type is declared. */
12429 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
12430 && !DECL_SELF_REFERENCE_P (decl
)
12431 && tag_code
!= typename_type
)
12433 if (alias_template_specialization_p (type
))
12434 error ("using alias template specialization %qT after %qs",
12435 type
, tag_name (tag_code
));
12437 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
12438 inform (DECL_SOURCE_LOCATION (decl
),
12439 "%qD has a previous declaration here", decl
);
12440 return error_mark_node
;
12442 else if (TREE_CODE (type
) != RECORD_TYPE
12443 && TREE_CODE (type
) != UNION_TYPE
12444 && tag_code
!= enum_type
12445 && tag_code
!= typename_type
)
12447 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
12448 inform (input_location
, "%q+T has a previous declaration here", type
);
12449 return error_mark_node
;
12451 else if (TREE_CODE (type
) != ENUMERAL_TYPE
12452 && tag_code
== enum_type
)
12454 error ("%qT referred to as enum", type
);
12455 inform (input_location
, "%q+T has a previous declaration here", type
);
12456 return error_mark_node
;
12458 else if (!allow_template_p
12459 && TREE_CODE (type
) == RECORD_TYPE
12460 && CLASSTYPE_IS_TEMPLATE (type
))
12462 /* If a class template appears as elaborated type specifier
12463 without a template header such as:
12465 template <class T> class C {};
12466 void f(class C); // No template header here
12468 then the required template argument is missing. */
12469 error ("template argument required for %<%s %T%>",
12470 tag_name (tag_code
),
12471 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
12472 return error_mark_node
;
12478 /* Lookup NAME in elaborate type specifier in scope according to
12479 SCOPE and issue diagnostics if necessary.
12480 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12481 found, and ERROR_MARK_NODE for type error. */
12484 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
12485 tag_scope scope
, bool template_header_p
)
12489 if (scope
== ts_global
)
12491 /* First try ordinary name lookup, ignoring hidden class name
12492 injected via friend declaration. */
12493 decl
= lookup_name_prefer_type (name
, 2);
12494 decl
= strip_using_decl (decl
);
12495 /* If that fails, the name will be placed in the smallest
12496 non-class, non-function-prototype scope according to 3.3.1/5.
12497 We may already have a hidden name declared as friend in this
12498 scope. So lookup again but not ignoring hidden names.
12499 If we find one, that name will be made visible rather than
12500 creating a new tag. */
12502 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
12505 decl
= lookup_type_scope (name
, scope
);
12508 && (DECL_CLASS_TEMPLATE_P (decl
)
12509 /* If scope is ts_current we're defining a class, so ignore a
12510 template template parameter. */
12511 || (scope
!= ts_current
12512 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
12513 decl
= DECL_TEMPLATE_RESULT (decl
);
12515 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
12517 /* Look for invalid nested type:
12521 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
12523 error ("%qD has the same name as the class in which it is "
12526 return error_mark_node
;
12529 /* Two cases we need to consider when deciding if a class
12530 template is allowed as an elaborated type specifier:
12531 1. It is a self reference to its own class.
12532 2. It comes with a template header.
12536 template <class T> class C {
12537 class C *c1; // DECL_SELF_REFERENCE_P is true
12540 template <class U> class C; // template_header_p is true
12541 template <class T> class C<T>::D {
12542 class C *c2; // DECL_SELF_REFERENCE_P is true
12545 t
= check_elaborated_type_specifier (tag_code
,
12548 | DECL_SELF_REFERENCE_P (decl
));
12551 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12553 error ("reference to %qD is ambiguous", name
);
12554 print_candidates (decl
);
12555 return error_mark_node
;
12561 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12562 Define the tag as a forward-reference if it is not defined.
12564 If a declaration is given, process it here, and report an error if
12565 multiple declarations are not identical.
12567 SCOPE is TS_CURRENT when this is also a definition. Only look in
12568 the current frame for the name (since C++ allows new names in any
12569 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12570 declaration. Only look beginning from the current scope outward up
12571 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12573 TEMPLATE_HEADER_P is true when this declaration is preceded by
12574 a set of template parameters. */
12577 xref_tag_1 (enum tag_types tag_code
, tree name
,
12578 tag_scope orig_scope
, bool template_header_p
)
12580 enum tree_code code
;
12582 tree context
= NULL_TREE
;
12585 gcc_assert (identifier_p (name
));
12591 code
= RECORD_TYPE
;
12597 code
= ENUMERAL_TYPE
;
12600 gcc_unreachable ();
12603 if (orig_scope
== ts_lambda
)
12604 scope
= ts_current
;
12606 scope
= orig_scope
;
12608 /* In case of anonymous name, xref_tag is only called to
12609 make type node and push name. Name lookup is not required. */
12610 if (anon_aggrname_p (name
))
12613 t
= lookup_and_check_tag (tag_code
, name
,
12614 scope
, template_header_p
);
12616 if (t
== error_mark_node
)
12617 return error_mark_node
;
12619 if (scope
!= ts_current
&& t
&& current_class_type
12620 && template_class_depth (current_class_type
)
12621 && template_header_p
)
12623 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12626 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12627 definition of this tag. Since, in addition, we are currently
12628 processing a (member) template declaration of a template
12629 class, we must be very careful; consider:
12636 { template <class V>
12637 friend struct S1; };
12639 Here, the S2::S1 declaration should not be confused with the
12640 outer declaration. In particular, the inner version should
12641 have a template parameter of level 2, not level 1. This
12642 would be particularly important if the member declaration
12645 template <class V = U> friend struct S1;
12647 say, when we should tsubst into `U' when instantiating
12648 S2. On the other hand, when presented with:
12658 we must find the inner binding eventually. We
12659 accomplish this by making sure that the new type we
12660 create to represent this declaration has the right
12662 context
= TYPE_CONTEXT (t
);
12668 /* If no such tag is yet defined, create a forward-reference node
12669 and record it as the "definition".
12670 When a real declaration of this type is found,
12671 the forward-reference will be altered into a real type. */
12672 if (code
== ENUMERAL_TYPE
)
12674 error ("use of enum %q#D without previous declaration", name
);
12675 return error_mark_node
;
12679 t
= make_class_type (code
);
12680 TYPE_CONTEXT (t
) = context
;
12681 if (orig_scope
== ts_lambda
)
12682 /* Remember that we're declaring a lambda to avoid bogus errors
12683 in push_template_decl. */
12684 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12685 t
= pushtag (name
, t
, scope
);
12690 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12692 /* Check that we aren't trying to overload a class with different
12694 tree constr
= NULL_TREE
;
12695 if (current_template_parms
)
12697 tree reqs
= TEMPLATE_PARMS_CONSTRAINTS (current_template_parms
);
12698 constr
= build_constraints (reqs
, NULL_TREE
);
12700 if (!redeclare_class_template (t
, current_template_parms
, constr
))
12701 return error_mark_node
;
12703 else if (!processing_template_decl
12704 && CLASS_TYPE_P (t
)
12705 && CLASSTYPE_IS_TEMPLATE (t
))
12707 error ("redeclaration of %qT as a non-template", t
);
12708 error ("previous declaration %q+D", t
);
12709 return error_mark_node
;
12712 /* Make injected friend class visible. */
12713 if (scope
!= ts_within_enclosing_non_class
12714 && hidden_name_p (TYPE_NAME (t
)))
12716 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12717 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12719 if (TYPE_TEMPLATE_INFO (t
))
12721 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12722 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12730 /* Wrapper for xref_tag_1. */
12733 xref_tag (enum tag_types tag_code
, tree name
,
12734 tag_scope scope
, bool template_header_p
)
12738 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12739 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12740 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12746 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12748 enum tag_types tag_kind
;
12750 if (TREE_CODE (old
) == RECORD_TYPE
)
12751 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12753 tag_kind
= union_type
;
12755 if (id
== NULL_TREE
)
12756 id
= TYPE_IDENTIFIER (old
);
12758 return xref_tag (tag_kind
, id
, scope
, false);
12761 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12762 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12763 access_* node, and the TREE_VALUE is the type of the base-class.
12764 Non-NULL TREE_TYPE indicates virtual inheritance.
12766 Returns true if the binfo hierarchy was successfully created,
12767 false if an error was detected. */
12770 xref_basetypes (tree ref
, tree base_list
)
12773 tree binfo
, base_binfo
;
12774 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12775 unsigned max_bases
= 0; /* Maximum direct bases. */
12776 unsigned max_dvbases
= 0; /* Maximum direct virtual bases. */
12778 tree default_access
;
12779 tree igo_prev
; /* Track Inheritance Graph Order. */
12781 if (ref
== error_mark_node
)
12784 /* The base of a derived class is private by default, all others are
12786 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12787 && CLASSTYPE_DECLARED_CLASS (ref
)
12788 ? access_private_node
: access_public_node
);
12790 /* First, make sure that any templates in base-classes are
12791 instantiated. This ensures that if we call ourselves recursively
12792 we do not get confused about which classes are marked and which
12794 basep
= &base_list
;
12797 tree basetype
= TREE_VALUE (*basep
);
12799 /* The dependent_type_p call below should really be dependent_scope_p
12800 so that we give a hard error about using an incomplete type as a
12801 base, but we allow it with a pedwarn for backward
12803 if (processing_template_decl
12804 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12805 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12806 if (!dependent_type_p (basetype
)
12807 && !complete_type_or_else (basetype
, NULL
))
12808 /* An incomplete type. Remove it from the list. */
12809 *basep
= TREE_CHAIN (*basep
);
12813 if (TREE_TYPE (*basep
))
12815 if (CLASS_TYPE_P (basetype
))
12816 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12817 basep
= &TREE_CHAIN (*basep
);
12820 max_vbases
+= max_dvbases
;
12822 TYPE_MARKED_P (ref
) = 1;
12824 /* The binfo slot should be empty, unless this is an (ill-formed)
12826 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12828 error ("redefinition of %q#T", ref
);
12832 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12834 binfo
= make_tree_binfo (max_bases
);
12836 TYPE_BINFO (ref
) = binfo
;
12837 BINFO_OFFSET (binfo
) = size_zero_node
;
12838 BINFO_TYPE (binfo
) = ref
;
12840 /* Apply base-class info set up to the variants of this type. */
12841 fixup_type_variants (ref
);
12845 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12846 /* An aggregate cannot have baseclasses. */
12847 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12849 if (TREE_CODE (ref
) == UNION_TYPE
)
12851 error ("derived union %qT invalid", ref
);
12858 if (TYPE_FOR_JAVA (ref
))
12860 error ("Java class %qT cannot have multiple bases", ref
);
12864 warning (OPT_Wmultiple_inheritance
,
12865 "%qT defined with multiple direct bases", ref
);
12870 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12872 if (TYPE_FOR_JAVA (ref
))
12874 error ("Java class %qT cannot have virtual bases", ref
);
12877 else if (max_dvbases
)
12878 warning (OPT_Wvirtual_inheritance
,
12879 "%qT defined with direct virtual base", ref
);
12882 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12884 tree access
= TREE_PURPOSE (base_list
);
12885 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12886 tree basetype
= TREE_VALUE (base_list
);
12888 if (access
== access_default_node
)
12889 access
= default_access
;
12891 if (PACK_EXPANSION_P (basetype
))
12892 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12893 if (TREE_CODE (basetype
) == TYPE_DECL
)
12894 basetype
= TREE_TYPE (basetype
);
12895 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12897 error ("base type %qT fails to be a struct or class type",
12902 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12903 TYPE_FOR_JAVA (ref
) = 1;
12905 base_binfo
= NULL_TREE
;
12906 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12908 base_binfo
= TYPE_BINFO (basetype
);
12909 /* The original basetype could have been a typedef'd type. */
12910 basetype
= BINFO_TYPE (base_binfo
);
12912 /* Inherit flags from the base. */
12913 TYPE_HAS_NEW_OPERATOR (ref
)
12914 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12915 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12916 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12917 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12918 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12919 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12920 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12921 CLASSTYPE_REPEATED_BASE_P (ref
)
12922 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12925 /* We must do this test after we've seen through a typedef
12927 if (TYPE_MARKED_P (basetype
))
12929 if (basetype
== ref
)
12930 error ("recursive type %qT undefined", basetype
);
12932 error ("duplicate base type %qT invalid", basetype
);
12936 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12937 /* Regenerate the pack expansion for the bases. */
12938 basetype
= make_pack_expansion (basetype
);
12940 TYPE_MARKED_P (basetype
) = 1;
12942 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12943 &igo_prev
, via_virtual
);
12944 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12945 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12947 BINFO_BASE_APPEND (binfo
, base_binfo
);
12948 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12951 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12952 /* If we didn't get max_vbases vbases, we must have shared at
12953 least one of them, and are therefore diamond shaped. */
12954 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12956 /* Unmark all the types. */
12957 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12958 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12959 TYPE_MARKED_P (ref
) = 0;
12961 /* Now see if we have a repeated base type. */
12962 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12964 for (base_binfo
= binfo
; base_binfo
;
12965 base_binfo
= TREE_CHAIN (base_binfo
))
12967 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12969 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12972 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12974 for (base_binfo
= binfo
; base_binfo
;
12975 base_binfo
= TREE_CHAIN (base_binfo
))
12976 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12977 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12986 /* Copies the enum-related properties from type SRC to type DST.
12987 Used with the underlying type of an enum and the enum itself. */
12989 copy_type_enum (tree dst
, tree src
)
12992 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12994 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12995 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12996 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12997 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12998 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12999 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
13000 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
13001 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
13002 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
13006 /* Begin compiling the definition of an enumeration type.
13009 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
13011 UNDERLYING_TYPE is the type that will be used as the storage for
13012 the enumeration type. This should be NULL_TREE if no storage type
13015 SCOPED_ENUM_P is true if this is a scoped enumeration type.
13017 if IS_NEW is not NULL, gets TRUE iff a new type is created.
13019 Returns the type object, as yet incomplete.
13020 Also records info about it so that build_enumerator
13021 may be used to declare the individual values as they are read. */
13024 start_enum (tree name
, tree enumtype
, tree underlying_type
,
13025 bool scoped_enum_p
, bool *is_new
)
13027 tree prevtype
= NULL_TREE
;
13028 gcc_assert (identifier_p (name
));
13032 /* [C++0x dcl.enum]p5:
13034 If not explicitly specified, the underlying type of a scoped
13035 enumeration type is int. */
13036 if (!underlying_type
&& scoped_enum_p
)
13037 underlying_type
= integer_type_node
;
13039 if (underlying_type
)
13040 underlying_type
= cv_unqualified (underlying_type
);
13042 /* If this is the real definition for a previous forward reference,
13043 fill in the contents in the same object that used to be the
13044 forward reference. */
13046 enumtype
= lookup_and_check_tag (enum_type
, name
,
13047 /*tag_scope=*/ts_current
,
13048 /*template_header_p=*/false);
13050 /* In case of a template_decl, the only check that should be deferred
13051 to instantiation time is the comparison of underlying types. */
13052 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
13054 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
13056 error_at (input_location
, "scoped/unscoped mismatch "
13057 "in enum %q#T", enumtype
);
13058 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13059 "previous definition here");
13060 enumtype
= error_mark_node
;
13062 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
13064 error_at (input_location
, "underlying type mismatch "
13065 "in enum %q#T", enumtype
);
13066 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13067 "previous definition here");
13068 enumtype
= error_mark_node
;
13070 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
13071 && !dependent_type_p (underlying_type
)
13072 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
13073 && !same_type_p (underlying_type
,
13074 ENUM_UNDERLYING_TYPE (enumtype
)))
13076 error_at (input_location
, "different underlying type "
13077 "in enum %q#T", enumtype
);
13078 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
13079 "previous definition here");
13080 underlying_type
= NULL_TREE
;
13084 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
13085 || processing_template_decl
)
13087 /* In case of error, make a dummy enum to allow parsing to
13089 if (enumtype
== error_mark_node
)
13091 name
= make_anon_name ();
13092 enumtype
= NULL_TREE
;
13095 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
13096 of an opaque enum, or an opaque enum of an already defined
13097 enumeration (C++0x only).
13098 In any other case, it'll be NULL_TREE. */
13104 prevtype
= enumtype
;
13106 /* Do not push the decl more than once, unless we need to
13107 compare underlying types at instantiation time */
13109 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
13110 || (underlying_type
13111 && dependent_type_p (underlying_type
))
13112 || (ENUM_UNDERLYING_TYPE (enumtype
)
13113 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
13115 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
13116 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
13119 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
13122 if (enumtype
== error_mark_node
)
13123 return error_mark_node
;
13125 /* The enum is considered opaque until the opening '{' of the
13126 enumerator list. */
13127 SET_OPAQUE_ENUM_P (enumtype
, true);
13128 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
13131 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
13133 if (underlying_type
)
13135 if (CP_INTEGRAL_TYPE_P (underlying_type
))
13137 copy_type_enum (enumtype
, underlying_type
);
13138 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13140 else if (dependent_type_p (underlying_type
))
13141 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
13143 error ("underlying type %<%T%> of %<%T%> must be an integral type",
13144 underlying_type
, enumtype
);
13147 /* If into a template class, the returned enum is always the first
13148 declaration (opaque or not) seen. This way all the references to
13149 this type will be to the same declaration. The following ones are used
13150 only to check for definition errors. */
13151 if (prevtype
&& processing_template_decl
)
13157 /* After processing and defining all the values of an enumeration type,
13158 install their decls in the enumeration type.
13159 ENUMTYPE is the type object. */
13162 finish_enum_value_list (tree enumtype
)
13165 tree underlying_type
;
13168 tree minnode
, maxnode
;
13171 bool fixed_underlying_type_p
13172 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
13174 /* We built up the VALUES in reverse order. */
13175 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
13177 /* For an enum defined in a template, just set the type of the values;
13178 all further processing is postponed until the template is
13179 instantiated. We need to set the type so that tsubst of a CONST_DECL
13181 if (processing_template_decl
)
13183 for (values
= TYPE_VALUES (enumtype
);
13185 values
= TREE_CHAIN (values
))
13186 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
13190 /* Determine the minimum and maximum values of the enumerators. */
13191 if (TYPE_VALUES (enumtype
))
13193 minnode
= maxnode
= NULL_TREE
;
13195 for (values
= TYPE_VALUES (enumtype
);
13197 values
= TREE_CHAIN (values
))
13199 decl
= TREE_VALUE (values
);
13201 /* [dcl.enum]: Following the closing brace of an enum-specifier,
13202 each enumerator has the type of its enumeration. Prior to the
13203 closing brace, the type of each enumerator is the type of its
13204 initializing value. */
13205 TREE_TYPE (decl
) = enumtype
;
13207 /* Update the minimum and maximum values, if appropriate. */
13208 value
= DECL_INITIAL (decl
);
13209 if (value
== error_mark_node
)
13210 value
= integer_zero_node
;
13211 /* Figure out what the minimum and maximum values of the
13212 enumerators are. */
13214 minnode
= maxnode
= value
;
13215 else if (tree_int_cst_lt (maxnode
, value
))
13217 else if (tree_int_cst_lt (value
, minnode
))
13224 If the enumerator-list is empty, the underlying type is as if
13225 the enumeration had a single enumerator with value 0. */
13226 minnode
= maxnode
= integer_zero_node
;
13228 if (!fixed_underlying_type_p
)
13230 /* Compute the number of bits require to represent all values of the
13231 enumeration. We must do this before the type of MINNODE and
13232 MAXNODE are transformed, since tree_int_cst_min_precision relies
13233 on the TREE_TYPE of the value it is passed. */
13234 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
13235 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
13236 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
13237 int precision
= MAX (lowprec
, highprec
);
13239 bool use_short_enum
;
13241 /* Determine the underlying type of the enumeration.
13245 The underlying type of an enumeration is an integral type that
13246 can represent all the enumerator values defined in the
13247 enumeration. It is implementation-defined which integral type is
13248 used as the underlying type for an enumeration except that the
13249 underlying type shall not be larger than int unless the value of
13250 an enumerator cannot fit in an int or unsigned int.
13252 We use "int" or an "unsigned int" as the underlying type, even if
13253 a smaller integral type would work, unless the user has
13254 explicitly requested that we use the smallest possible type. The
13255 user can request that for all enumerations with a command line
13256 flag, or for just one enumeration with an attribute. */
13258 use_short_enum
= flag_short_enums
13259 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
13261 for (itk
= (use_short_enum
? itk_char
: itk_int
);
13265 underlying_type
= integer_types
[itk
];
13266 if (underlying_type
!= NULL_TREE
13267 && TYPE_PRECISION (underlying_type
) >= precision
13268 && TYPE_SIGN (underlying_type
) == sgn
)
13271 if (itk
== itk_none
)
13275 IF no integral type can represent all the enumerator values, the
13276 enumeration is ill-formed. */
13277 error ("no integral type can represent all of the enumerator values "
13278 "for %qT", enumtype
);
13279 precision
= TYPE_PRECISION (long_long_integer_type_node
);
13280 underlying_type
= integer_types
[itk_unsigned_long_long
];
13285 The value of sizeof() applied to an enumeration type, an object
13286 of an enumeration type, or an enumerator, is the value of sizeof()
13287 applied to the underlying type. */
13288 copy_type_enum (enumtype
, underlying_type
);
13290 /* Compute the minimum and maximum values for the type.
13294 For an enumeration where emin is the smallest enumerator and emax
13295 is the largest, the values of the enumeration are the values of the
13296 underlying type in the range bmin to bmax, where bmin and bmax are,
13297 respectively, the smallest and largest values of the smallest bit-
13298 field that can store emin and emax. */
13300 /* The middle-end currently assumes that types with TYPE_PRECISION
13301 narrower than their underlying type are suitably zero or sign
13302 extended to fill their mode. Similarly, it assumes that the front
13303 end assures that a value of a particular type must be within
13304 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
13306 We used to set these fields based on bmin and bmax, but that led
13307 to invalid assumptions like optimizing away bounds checking. So
13308 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
13309 TYPE_MAX_VALUE to the values for the mode above and only restrict
13310 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
13311 ENUM_UNDERLYING_TYPE (enumtype
)
13312 = build_distinct_type_copy (underlying_type
);
13313 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
13314 set_min_and_max_values_for_integral_type
13315 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
13317 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
13318 if (flag_strict_enums
)
13319 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
13322 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
13324 /* Convert each of the enumerators to the type of the underlying
13325 type of the enumeration. */
13326 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13328 location_t saved_location
;
13330 decl
= TREE_VALUE (values
);
13331 saved_location
= input_location
;
13332 input_location
= DECL_SOURCE_LOCATION (decl
);
13333 if (fixed_underlying_type_p
)
13334 /* If the enumeration type has a fixed underlying type, we
13335 already checked all of the enumerator values. */
13336 value
= DECL_INITIAL (decl
);
13338 value
= perform_implicit_conversion (underlying_type
,
13339 DECL_INITIAL (decl
),
13340 tf_warning_or_error
);
13341 input_location
= saved_location
;
13343 /* Do not clobber shared ints. */
13344 value
= copy_node (value
);
13346 TREE_TYPE (value
) = enumtype
;
13347 DECL_INITIAL (decl
) = value
;
13350 /* Fix up all variant types of this enum type. */
13351 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
13352 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
13354 if (at_class_scope_p ()
13355 && COMPLETE_TYPE_P (current_class_type
)
13356 && UNSCOPED_ENUM_P (enumtype
))
13357 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
13358 current_class_type
);
13360 /* Finish debugging output for this type. */
13361 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13364 /* Finishes the enum type. This is called only the first time an
13365 enumeration is seen, be it opaque or odinary.
13366 ENUMTYPE is the type object. */
13369 finish_enum (tree enumtype
)
13371 if (processing_template_decl
)
13373 if (at_function_scope_p ())
13374 add_stmt (build_min (TAG_DEFN
, enumtype
));
13378 /* If this is a forward declaration, there should not be any variants,
13379 though we can get a variant in the middle of an enum-specifier with
13380 wacky code like 'enum E { e = sizeof(const E*) };' */
13381 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
13382 && (TYPE_VALUES (enumtype
)
13383 || !TYPE_NEXT_VARIANT (enumtype
)));
13386 /* Build and install a CONST_DECL for an enumeration constant of the
13387 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13388 Apply ATTRIBUTES if available. LOC is the location of NAME.
13389 Assignment of sequential values by default is handled here. */
13392 build_enumerator (tree name
, tree value
, tree enumtype
, tree attributes
,
13399 /* scalar_constant_value will pull out this expression, so make sure
13400 it's folded as appropriate. */
13401 if (processing_template_decl
)
13402 value
= fold_non_dependent_expr (value
);
13404 /* If the VALUE was erroneous, pretend it wasn't there; that will
13405 result in the enum being assigned the next value in sequence. */
13406 if (value
== error_mark_node
)
13409 /* Remove no-op casts from the value. */
13411 STRIP_TYPE_NOPS (value
);
13413 if (! processing_template_decl
)
13415 /* Validate and default VALUE. */
13416 if (value
!= NULL_TREE
)
13418 if (!ENUM_UNDERLYING_TYPE (enumtype
))
13420 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
13425 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
13426 (TREE_TYPE (value
)))
13427 value
= perform_implicit_conversion_flags
13428 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
13429 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
13431 if (value
== error_mark_node
)
13434 if (value
!= NULL_TREE
)
13436 value
= cxx_constant_value (value
);
13438 if (TREE_CODE (value
) != INTEGER_CST
13439 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13441 error ("enumerator value for %qD is not an integer constant",
13448 /* Default based on previous value. */
13449 if (value
== NULL_TREE
)
13451 if (TYPE_VALUES (enumtype
))
13456 /* C++03 7.2/4: If no initializer is specified for the first
13457 enumerator, the type is an unspecified integral
13458 type. Otherwise the type is the same as the type of the
13459 initializing value of the preceding enumerator unless the
13460 incremented value is not representable in that type, in
13461 which case the type is an unspecified integral type
13462 sufficient to contain the incremented value. */
13463 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13464 if (error_operand_p (prev_value
))
13465 value
= error_mark_node
;
13468 tree type
= TREE_TYPE (prev_value
);
13469 signop sgn
= TYPE_SIGN (type
);
13470 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
13474 bool pos
= !wi::neg_p (wi
, sgn
);
13475 if (!wi::fits_to_tree_p (wi
, type
))
13478 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
13480 type
= integer_types
[itk
];
13481 if (type
!= NULL_TREE
13482 && (pos
|| !TYPE_UNSIGNED (type
))
13483 && wi::fits_to_tree_p (wi
, type
))
13486 if (type
&& cxx_dialect
< cxx11
13487 && itk
> itk_unsigned_long
)
13488 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
13489 incremented enumerator value is too large for %<unsigned long%>" : "\
13490 incremented enumerator value is too large for %<long%>");
13492 if (type
== NULL_TREE
)
13495 value
= wide_int_to_tree (type
, wi
);
13500 error ("overflow in enumeration values at %qD", name
);
13501 value
= error_mark_node
;
13506 value
= integer_zero_node
;
13509 /* Remove no-op casts from the value. */
13510 STRIP_TYPE_NOPS (value
);
13512 /* If the underlying type of the enum is fixed, check whether
13513 the enumerator values fits in the underlying type. If it
13514 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13515 if (ENUM_UNDERLYING_TYPE (enumtype
)
13517 && TREE_CODE (value
) == INTEGER_CST
)
13519 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
13520 error ("enumerator value %E is outside the range of underlying "
13521 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
13523 /* Convert the value to the appropriate type. */
13524 value
= fold_convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
13528 /* C++ associates enums with global, function, or class declarations. */
13529 context
= current_scope ();
13531 /* Build the actual enumeration constant. Note that the enumeration
13532 constants have the underlying type of the enum (if it is fixed)
13533 or the type of their initializer (if the underlying type of the
13534 enum is not fixed):
13538 If the underlying type is fixed, the type of each enumerator
13539 prior to the closing brace is the underlying type; if the
13540 initializing value of an enumerator cannot be represented by
13541 the underlying type, the program is ill-formed. If the
13542 underlying type is not fixed, the type of each enumerator is
13543 the type of its initializing value.
13545 If the underlying type is not fixed, it will be computed by
13546 finish_enum and we will reset the type of this enumerator. Of
13547 course, if we're processing a template, there may be no value. */
13548 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13550 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
13552 DECL_CONTEXT (decl
) = enumtype
;
13553 TREE_CONSTANT (decl
) = 1;
13554 TREE_READONLY (decl
) = 1;
13555 DECL_INITIAL (decl
) = value
;
13558 cplus_decl_attributes (&decl
, attributes
, 0);
13560 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
13561 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13562 on the TYPE_FIELDS list for `S'. (That's so that you can say
13563 things like `S::i' later.) */
13564 finish_member_declaration (decl
);
13568 /* Add this enumeration constant to the list for this type. */
13569 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13572 /* Look for an enumerator with the given NAME within the enumeration
13573 type ENUMTYPE. This routine is used primarily for qualified name
13574 lookup into an enumerator in C++0x, e.g.,
13576 enum class Color { Red, Green, Blue };
13578 Color color = Color::Red;
13580 Returns the value corresponding to the enumerator, or
13581 NULL_TREE if no such enumerator was found. */
13583 lookup_enumerator (tree enumtype
, tree name
)
13586 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13588 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13589 return e
? TREE_VALUE (e
) : NULL_TREE
;
13593 /* We're defining DECL. Make sure that its type is OK. */
13596 check_function_type (tree decl
, tree current_function_parms
)
13598 tree fntype
= TREE_TYPE (decl
);
13599 tree return_type
= complete_type (TREE_TYPE (fntype
));
13601 /* In a function definition, arg types must be complete. */
13602 require_complete_types_for_parms (current_function_parms
);
13604 if (dependent_type_p (return_type
)
13605 || type_uses_auto (return_type
))
13607 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13608 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13610 tree args
= TYPE_ARG_TYPES (fntype
);
13612 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13613 error ("return type %q#T is incomplete", return_type
);
13615 error ("return type has Java class type %q#T", return_type
);
13617 /* Make it return void instead. */
13618 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13619 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13621 TREE_CHAIN (args
));
13623 fntype
= build_function_type (void_type_node
, args
);
13625 = build_exception_variant (fntype
,
13626 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13627 fntype
= (cp_build_type_attribute_variant
13628 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13629 TREE_TYPE (decl
) = fntype
;
13632 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13635 /* True iff FN is an implicitly-defined default constructor. */
13638 implicit_default_ctor_p (tree fn
)
13640 return (DECL_CONSTRUCTOR_P (fn
)
13641 && !user_provided_p (fn
)
13642 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn
)));
13645 /* Create the FUNCTION_DECL for a function definition.
13646 DECLSPECS and DECLARATOR are the parts of the declaration;
13647 they describe the function's name and the type it returns,
13648 but twisted together in a fashion that parallels the syntax of C.
13650 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13651 DECLARATOR is really the DECL for the function we are about to
13652 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13653 indicating that the function is an inline defined in-class.
13655 This function creates a binding context for the function body
13656 as well as setting up the FUNCTION_DECL in current_function_decl.
13658 For C++, we must first check whether that datum makes any sense.
13659 For example, "class A local_a(1,2);" means that variable local_a
13660 is an aggregate of type A, which should have a constructor
13661 applied to it with the argument list [1, 2].
13663 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13664 or may be a BLOCK if the function has been defined previously
13665 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13666 error_mark_node if the function has never been defined, or
13667 a BLOCK if the function has been defined somewhere. */
13670 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13672 tree ctype
= NULL_TREE
;
13675 int doing_friend
= 0;
13676 cp_binding_level
*bl
;
13677 tree current_function_parms
;
13678 struct c_fileinfo
*finfo
13679 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13680 bool honor_interface
;
13682 /* Sanity check. */
13683 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13684 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13686 fntype
= TREE_TYPE (decl1
);
13687 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13688 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13690 /* ISO C++ 11.4/5. A friend function defined in a class is in
13691 the (lexical) scope of the class in which it is defined. */
13692 if (!ctype
&& DECL_FRIEND_P (decl1
))
13694 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13696 /* CTYPE could be null here if we're dealing with a template;
13697 for example, `inline friend float foo()' inside a template
13698 will have no CTYPE set. */
13699 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13705 if (DECL_DECLARED_INLINE_P (decl1
)
13706 && lookup_attribute ("noinline", attrs
))
13707 warning_at (DECL_SOURCE_LOCATION (decl1
), 0,
13708 "inline function %qD given attribute noinline", decl1
);
13710 /* Handle gnu_inline attribute. */
13711 if (GNU_INLINE_P (decl1
))
13713 DECL_EXTERNAL (decl1
) = 1;
13714 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13715 DECL_INTERFACE_KNOWN (decl1
) = 1;
13716 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13719 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13720 /* This is a constructor, we must ensure that any default args
13721 introduced by this definition are propagated to the clones
13722 now. The clones are used directly in overload resolution. */
13723 adjust_clone_args (decl1
);
13725 /* Sometimes we don't notice that a function is a static member, and
13726 build a METHOD_TYPE for it. Fix that up now. */
13727 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13728 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13730 /* Set up current_class_type, and enter the scope of the class, if
13733 push_nested_class (ctype
);
13734 else if (DECL_STATIC_FUNCTION_P (decl1
))
13735 push_nested_class (DECL_CONTEXT (decl1
));
13737 /* Now that we have entered the scope of the class, we must restore
13738 the bindings for any template parameters surrounding DECL1, if it
13739 is an inline member template. (Order is important; consider the
13740 case where a template parameter has the same name as a field of
13741 the class.) It is not until after this point that
13742 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13743 if (flags
& SF_INCLASS_INLINE
)
13744 maybe_begin_member_template_processing (decl1
);
13746 /* Effective C++ rule 15. */
13748 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13749 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13750 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13752 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13753 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13754 if (!DECL_INITIAL (decl1
))
13755 DECL_INITIAL (decl1
) = error_mark_node
;
13757 /* This function exists in static storage.
13758 (This does not mean `static' in the C sense!) */
13759 TREE_STATIC (decl1
) = 1;
13761 /* We must call push_template_decl after current_class_type is set
13762 up. (If we are processing inline definitions after exiting a
13763 class scope, current_class_type will be NULL_TREE until set above
13764 by push_nested_class.) */
13765 if (processing_template_decl
)
13767 tree newdecl1
= push_template_decl (decl1
);
13768 if (newdecl1
== error_mark_node
)
13770 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13771 pop_nested_class ();
13777 /* We are now in the scope of the function being defined. */
13778 current_function_decl
= decl1
;
13780 /* Save the parm names or decls from this function's declarator
13781 where store_parm_decls will find them. */
13782 current_function_parms
= DECL_ARGUMENTS (decl1
);
13784 /* Make sure the parameter and return types are reasonable. When
13785 you declare a function, these types can be incomplete, but they
13786 must be complete when you define the function. */
13787 check_function_type (decl1
, current_function_parms
);
13789 /* Build the return declaration for the function. */
13790 restype
= TREE_TYPE (fntype
);
13792 if (DECL_RESULT (decl1
) == NULL_TREE
)
13796 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13797 DECL_ARTIFICIAL (resdecl
) = 1;
13798 DECL_IGNORED_P (resdecl
) = 1;
13799 DECL_RESULT (decl1
) = resdecl
;
13801 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13804 /* Let the user know we're compiling this function. */
13805 announce_function (decl1
);
13807 /* Record the decl so that the function name is defined.
13808 If we already have a decl for this name, and it is a FUNCTION_DECL,
13809 use the old decl. */
13810 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13812 /* A specialization is not used to guide overload resolution. */
13813 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13814 && !(DECL_USE_TEMPLATE (decl1
) &&
13815 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13817 tree olddecl
= pushdecl (decl1
);
13819 if (olddecl
== error_mark_node
)
13820 /* If something went wrong when registering the declaration,
13821 use DECL1; we have to have a FUNCTION_DECL to use when
13822 parsing the body of the function. */
13826 /* Otherwise, OLDDECL is either a previous declaration
13827 of the same function or DECL1 itself. */
13829 if (warn_missing_declarations
13830 && olddecl
== decl1
13831 && !DECL_MAIN_P (decl1
)
13832 && TREE_PUBLIC (decl1
)
13833 && !DECL_DECLARED_INLINE_P (decl1
))
13837 /* Check whether DECL1 is in an anonymous
13839 for (context
= DECL_CONTEXT (decl1
);
13841 context
= DECL_CONTEXT (context
))
13843 if (TREE_CODE (context
) == NAMESPACE_DECL
13844 && DECL_NAME (context
) == NULL_TREE
)
13848 if (context
== NULL
)
13849 warning_at (DECL_SOURCE_LOCATION (decl1
),
13850 OPT_Wmissing_declarations
,
13851 "no previous declaration for %qD", decl1
);
13859 /* We need to set the DECL_CONTEXT. */
13860 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13861 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13863 fntype
= TREE_TYPE (decl1
);
13864 restype
= TREE_TYPE (fntype
);
13866 /* If #pragma weak applies, mark the decl appropriately now.
13867 The pragma only applies to global functions. Because
13868 determining whether or not the #pragma applies involves
13869 computing the mangled name for the declaration, we cannot
13870 apply the pragma until after we have merged this declaration
13871 with any previous declarations; if the original declaration
13872 has a linkage specification, that specification applies to
13873 the definition as well, and may affect the mangled name. */
13874 if (DECL_FILE_SCOPE_P (decl1
))
13875 maybe_apply_pragma_weak (decl1
);
13878 /* Reset this in case the call to pushdecl changed it. */
13879 current_function_decl
= decl1
;
13881 gcc_assert (DECL_INITIAL (decl1
));
13883 /* This function may already have been parsed, in which case just
13884 return; our caller will skip over the body without parsing. */
13885 if (DECL_INITIAL (decl1
) != error_mark_node
)
13888 /* Initialize RTL machinery. We cannot do this until
13889 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13890 even when processing a template; this is how we get
13891 CFUN set up, and our per-function variables initialized.
13892 FIXME factor out the non-RTL stuff. */
13893 bl
= current_binding_level
;
13894 allocate_struct_function (decl1
, processing_template_decl
);
13896 /* Initialize the language data structures. Whenever we start
13897 a new function, we destroy temporaries in the usual way. */
13898 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
13899 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13900 current_binding_level
= bl
;
13902 if (!processing_template_decl
&& type_uses_auto (restype
))
13904 FNDECL_USED_AUTO (decl1
) = true;
13905 current_function_auto_return_pattern
= restype
;
13908 /* Start the statement-tree, start the tree now. */
13909 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13911 /* If we are (erroneously) defining a function that we have already
13912 defined before, wipe out what we knew before. */
13913 if (!DECL_PENDING_INLINE_P (decl1
))
13914 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13916 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13918 /* We know that this was set up by `grokclassfn'. We do not
13919 wait until `store_parm_decls', since evil parse errors may
13920 never get us to that point. Here we keep the consistency
13921 between `current_class_type' and `current_class_ptr'. */
13922 tree t
= DECL_ARGUMENTS (decl1
);
13924 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13925 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13927 cp_function_chain
->x_current_class_ref
13928 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13929 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13930 cp_function_chain
->x_current_class_ptr
= t
;
13932 /* Constructors and destructors need to know whether they're "in
13933 charge" of initializing virtual base classes. */
13934 t
= DECL_CHAIN (t
);
13935 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13937 current_in_charge_parm
= t
;
13938 t
= DECL_CHAIN (t
);
13940 if (DECL_HAS_VTT_PARM_P (decl1
))
13942 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13943 current_vtt_parm
= t
;
13947 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13948 /* Implicitly-defined methods (like the
13949 destructor for a class in which no destructor
13950 is explicitly declared) must not be defined
13951 until their definition is needed. So, we
13952 ignore interface specifications for
13953 compiler-generated functions. */
13954 && !DECL_ARTIFICIAL (decl1
));
13956 if (processing_template_decl
)
13957 /* Don't mess with interface flags. */;
13958 else if (DECL_INTERFACE_KNOWN (decl1
))
13960 tree ctx
= decl_function_context (decl1
);
13962 if (DECL_NOT_REALLY_EXTERN (decl1
))
13963 DECL_EXTERNAL (decl1
) = 0;
13965 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13966 /* This is a function in a local class in an extern inline
13967 or template function. */
13968 comdat_linkage (decl1
);
13970 /* If this function belongs to an interface, it is public.
13971 If it belongs to someone else's interface, it is also external.
13972 This only affects inlines and template instantiations. */
13973 else if (!finfo
->interface_unknown
&& honor_interface
)
13975 if (DECL_DECLARED_INLINE_P (decl1
)
13976 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13978 DECL_EXTERNAL (decl1
)
13979 = (finfo
->interface_only
13980 || (DECL_DECLARED_INLINE_P (decl1
)
13981 && ! flag_implement_inlines
13982 && !DECL_VINDEX (decl1
)));
13984 /* For WIN32 we also want to put these in linkonce sections. */
13985 maybe_make_one_only (decl1
);
13988 DECL_EXTERNAL (decl1
) = 0;
13989 DECL_INTERFACE_KNOWN (decl1
) = 1;
13990 /* If this function is in an interface implemented in this file,
13991 make sure that the back end knows to emit this function
13993 if (!DECL_EXTERNAL (decl1
))
13994 mark_needed (decl1
);
13996 else if (finfo
->interface_unknown
&& finfo
->interface_only
13997 && honor_interface
)
13999 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
14000 interface, we will have both finfo->interface_unknown and
14001 finfo->interface_only set. In that case, we don't want to
14002 use the normal heuristics because someone will supply a
14003 #pragma implementation elsewhere, and deducing it here would
14004 produce a conflict. */
14005 comdat_linkage (decl1
);
14006 DECL_EXTERNAL (decl1
) = 0;
14007 DECL_INTERFACE_KNOWN (decl1
) = 1;
14008 DECL_DEFER_OUTPUT (decl1
) = 1;
14012 /* This is a definition, not a reference.
14013 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
14014 if (!GNU_INLINE_P (decl1
))
14015 DECL_EXTERNAL (decl1
) = 0;
14017 if ((DECL_DECLARED_INLINE_P (decl1
)
14018 || DECL_TEMPLATE_INSTANTIATION (decl1
))
14019 && ! DECL_INTERFACE_KNOWN (decl1
))
14020 DECL_DEFER_OUTPUT (decl1
) = 1;
14022 DECL_INTERFACE_KNOWN (decl1
) = 1;
14025 /* Determine the ELF visibility attribute for the function. We must not
14026 do this before calling "pushdecl", as we must allow "duplicate_decls"
14027 to merge any attributes appropriately. We also need to wait until
14029 if (!DECL_CLONED_FUNCTION_P (decl1
))
14030 determine_visibility (decl1
);
14032 if (!processing_template_decl
)
14033 maybe_instantiate_noexcept (decl1
);
14035 begin_scope (sk_function_parms
, decl1
);
14039 if (DECL_DESTRUCTOR_P (decl1
)
14040 || (DECL_CONSTRUCTOR_P (decl1
)
14041 && targetm
.cxx
.cdtor_returns_this ()))
14043 cdtor_label
= create_artificial_label (input_location
);
14046 start_fname_decls ();
14048 store_parm_decls (current_function_parms
);
14050 if (!processing_template_decl
14051 && flag_lifetime_dse
&& DECL_CONSTRUCTOR_P (decl1
)
14052 /* We can't clobber safely for an implicitly-defined default constructor
14053 because part of the initialization might happen before we enter the
14054 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
14055 && !implicit_default_ctor_p (decl1
))
14057 /* Insert a clobber to let the back end know that the object storage
14058 is dead when we enter the constructor. */
14059 tree btype
= CLASSTYPE_AS_BASE (current_class_type
);
14060 tree clobber
= build_constructor (btype
, NULL
);
14061 TREE_THIS_VOLATILE (clobber
) = true;
14062 tree bref
= build_nop (build_reference_type (btype
), current_class_ptr
);
14063 bref
= convert_from_reference (bref
);
14064 tree exprstmt
= build2 (MODIFY_EXPR
, btype
, bref
, clobber
);
14065 finish_expr_stmt (exprstmt
);
14072 /* Like start_preparsed_function, except that instead of a
14073 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
14075 Returns true on success. If the DECLARATOR is not suitable
14076 for a function, we return false, which tells the parser to
14077 skip the entire function. */
14080 start_function (cp_decl_specifier_seq
*declspecs
,
14081 const cp_declarator
*declarator
,
14086 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
14087 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION
, decl1
);
14088 if (decl1
== error_mark_node
)
14090 /* If the declarator is not suitable for a function definition,
14091 cause a syntax error. */
14092 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
14094 error ("invalid function declaration");
14098 if (DECL_MAIN_P (decl1
))
14099 /* main must return int. grokfndecl should have corrected it
14100 (and issued a diagnostic) if the user got it wrong. */
14101 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
14102 integer_type_node
));
14104 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
14107 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
14111 use_eh_spec_block (tree fn
)
14113 return (flag_exceptions
&& flag_enforce_eh_specs
14114 && !processing_template_decl
14115 && !type_throw_all_p (TREE_TYPE (fn
))
14116 /* We insert the EH_SPEC_BLOCK only in the original
14117 function; then, it is copied automatically to the
14119 && !DECL_CLONED_FUNCTION_P (fn
)
14120 /* Implicitly-generated constructors and destructors have
14121 exception specifications. However, those specifications
14122 are the union of the possible exceptions specified by the
14123 constructors/destructors for bases and members, so no
14124 unallowed exception will ever reach this function. By
14125 not creating the EH_SPEC_BLOCK we save a little memory,
14126 and we avoid spurious warnings about unreachable
14128 && !DECL_DEFAULTED_FN (fn
));
14131 /* Store the parameter declarations into the current function declaration.
14132 This is called after parsing the parameter declarations, before
14133 digesting the body of the function.
14135 Also install to binding contour return value identifier, if any. */
14138 store_parm_decls (tree current_function_parms
)
14140 tree fndecl
= current_function_decl
;
14143 /* This is a chain of any other decls that came in among the parm
14144 declarations. If a parm is declared with enum {foo, bar} x;
14145 then CONST_DECLs for foo and bar are put here. */
14146 tree nonparms
= NULL_TREE
;
14148 if (current_function_parms
)
14150 /* This case is when the function was defined with an ANSI prototype.
14151 The parms already have decls, so we need not do anything here
14152 except record them as in effect
14153 and complain if any redundant old-style parm decls were written. */
14155 tree specparms
= current_function_parms
;
14158 /* Must clear this because it might contain TYPE_DECLs declared
14160 current_binding_level
->names
= NULL
;
14162 /* If we're doing semantic analysis, then we'll call pushdecl
14163 for each of these. We must do them in reverse order so that
14164 they end in the correct forward order. */
14165 specparms
= nreverse (specparms
);
14167 for (parm
= specparms
; parm
; parm
= next
)
14169 next
= DECL_CHAIN (parm
);
14170 if (TREE_CODE (parm
) == PARM_DECL
)
14172 if (DECL_NAME (parm
) == NULL_TREE
14173 || !VOID_TYPE_P (parm
))
14176 error ("parameter %qD declared void", parm
);
14180 /* If we find an enum constant or a type tag,
14181 put it aside for the moment. */
14182 TREE_CHAIN (parm
) = NULL_TREE
;
14183 nonparms
= chainon (nonparms
, parm
);
14187 /* Get the decls in their original chain order and record in the
14188 function. This is all and only the PARM_DECLs that were
14189 pushed into scope by the loop above. */
14190 DECL_ARGUMENTS (fndecl
) = getdecls ();
14193 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
14195 /* Now store the final chain of decls for the arguments
14196 as the decl-chain of the current lexical scope.
14197 Put the enumerators in as well, at the front so that
14198 DECL_ARGUMENTS is not modified. */
14199 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
14201 if (use_eh_spec_block (current_function_decl
))
14202 current_eh_spec_block
= begin_eh_spec_block ();
14206 /* We have finished doing semantic analysis on DECL, but have not yet
14207 generated RTL for its body. Save away our current state, so that
14208 when we want to generate RTL later we know what to do. */
14211 save_function_data (tree decl
)
14213 struct language_function
*f
;
14215 /* Save the language-specific per-function data so that we can
14216 get it back when we really expand this function. */
14217 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
14220 f
= ggc_alloc
<language_function
> ();
14221 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
14222 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
14224 /* Clear out the bits we don't need. */
14225 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
14226 f
->bindings
= NULL
;
14227 f
->x_local_names
= NULL
;
14228 f
->base
.local_typedefs
= NULL
;
14232 /* Set the return value of the constructor (if present). */
14235 finish_constructor_body (void)
14240 if (targetm
.cxx
.cdtor_returns_this ()
14241 && (! TYPE_FOR_JAVA (current_class_type
)))
14243 /* Any return from a constructor will end up here. */
14244 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14246 val
= DECL_ARGUMENTS (current_function_decl
);
14247 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14248 DECL_RESULT (current_function_decl
), val
);
14249 /* Return the address of the object. */
14250 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14251 add_stmt (exprstmt
);
14255 /* Do all the processing for the beginning of a destructor; set up the
14256 vtable pointers and cleanups for bases and members. */
14259 begin_destructor_body (void)
14261 tree compound_stmt
;
14263 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
14264 issued an error message. We still want to try to process the
14265 body of the function, but initialize_vtbl_ptrs will crash if
14266 TYPE_BINFO is NULL. */
14267 if (COMPLETE_TYPE_P (current_class_type
))
14269 compound_stmt
= begin_compound_stmt (0);
14270 /* Make all virtual function table pointers in non-virtual base
14271 classes point to CURRENT_CLASS_TYPE's virtual function
14273 initialize_vtbl_ptrs (current_class_ptr
);
14274 finish_compound_stmt (compound_stmt
);
14276 if (flag_lifetime_dse
)
14278 /* Insert a cleanup to let the back end know that the object is dead
14279 when we exit the destructor, either normally or via exception. */
14280 tree btype
= CLASSTYPE_AS_BASE (current_class_type
);
14281 tree clobber
= build_constructor (btype
, NULL
);
14282 TREE_THIS_VOLATILE (clobber
) = true;
14283 tree bref
= build_nop (build_reference_type (btype
),
14284 current_class_ptr
);
14285 bref
= convert_from_reference (bref
);
14286 tree exprstmt
= build2 (MODIFY_EXPR
, btype
, bref
, clobber
);
14287 finish_decl_cleanup (NULL_TREE
, exprstmt
);
14290 /* And insert cleanups for our bases and members so that they
14291 will be properly destroyed if we throw. */
14292 push_base_cleanups ();
14296 /* At the end of every destructor we generate code to delete the object if
14297 necessary. Do that now. */
14300 finish_destructor_body (void)
14304 /* Any return from a destructor will end up here; that way all base
14305 and member cleanups will be run when the function returns. */
14306 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
14308 /* In a virtual destructor, we must call delete. */
14309 if (DECL_VIRTUAL_P (current_function_decl
))
14312 tree virtual_size
= cxx_sizeof (current_class_type
);
14316 At the point of definition of a virtual destructor (including
14317 an implicit definition), non-placement operator delete shall
14318 be looked up in the scope of the destructor's class and if
14319 found shall be accessible and unambiguous. */
14320 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
14322 /*global_p=*/false,
14323 /*placement=*/NULL_TREE
,
14324 /*alloc_fn=*/NULL_TREE
,
14325 tf_warning_or_error
);
14327 if_stmt
= begin_if_stmt ();
14328 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
14329 current_in_charge_parm
,
14332 finish_expr_stmt (exprstmt
);
14333 finish_then_clause (if_stmt
);
14334 finish_if_stmt (if_stmt
);
14337 if (targetm
.cxx
.cdtor_returns_this ())
14341 val
= DECL_ARGUMENTS (current_function_decl
);
14342 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
14343 DECL_RESULT (current_function_decl
), val
);
14344 /* Return the address of the object. */
14345 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
14346 add_stmt (exprstmt
);
14350 /* Do the necessary processing for the beginning of a function body, which
14351 in this case includes member-initializers, but not the catch clauses of
14352 a function-try-block. Currently, this means opening a binding level
14353 for the member-initializers (in a ctor), member cleanups (in a dtor),
14354 and capture proxies (in a lambda operator()). */
14357 begin_function_body (void)
14361 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
14364 if (processing_template_decl
)
14365 /* Do nothing now. */;
14367 /* Always keep the BLOCK node associated with the outermost pair of
14368 curly braces of a function. These are needed for correct
14369 operation of dwarfout.c. */
14370 keep_next_level (true);
14372 stmt
= begin_compound_stmt (BCS_FN_BODY
);
14374 if (processing_template_decl
)
14375 /* Do nothing now. */;
14376 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14377 begin_destructor_body ();
14382 /* Do the processing for the end of a function body. Currently, this means
14383 closing out the cleanups for fully-constructed bases and members, and in
14384 the case of the destructor, deleting the object if desired. Again, this
14385 is only meaningful for [cd]tors, since they are the only functions where
14386 there is a significant distinction between the main body and any
14387 function catch clauses. Handling, say, main() return semantics here
14388 would be wrong, as flowing off the end of a function catch clause for
14389 main() would also need to return 0. */
14392 finish_function_body (tree compstmt
)
14394 if (compstmt
== NULL_TREE
)
14397 /* Close the block. */
14398 finish_compound_stmt (compstmt
);
14400 if (processing_template_decl
)
14401 /* Do nothing now. */;
14402 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
14403 finish_constructor_body ();
14404 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14405 finish_destructor_body ();
14408 /* Given a function, returns the BLOCK corresponding to the outermost level
14409 of curly braces, skipping the artificial block created for constructor
14413 outer_curly_brace_block (tree fndecl
)
14415 tree block
= DECL_INITIAL (fndecl
);
14416 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14418 block
= BLOCK_SUBBLOCKS (block
);
14419 if (BLOCK_OUTER_CURLY_BRACE_P (block
))
14421 block
= BLOCK_SUBBLOCKS (block
);
14422 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block
));
14426 /* If FNDECL is a class's key method, add the class to the list of
14427 keyed classes that should be emitted. */
14430 record_key_method_defined (tree fndecl
)
14432 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
14433 && DECL_VIRTUAL_P (fndecl
)
14434 && !processing_template_decl
)
14436 tree fnclass
= DECL_CONTEXT (fndecl
);
14437 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
14438 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
14442 /* Subroutine of finish_function.
14443 Save the body of constexpr functions for possible
14444 future compile time evaluation. */
14447 maybe_save_function_definition (tree fun
)
14449 if (!processing_template_decl
14450 && DECL_DECLARED_CONSTEXPR_P (fun
)
14451 && !cp_function_chain
->invalid_constexpr
14452 && !DECL_CLONED_FUNCTION_P (fun
))
14453 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
14456 /* Finish up a function declaration and compile that function
14457 all the way to assembler language output. The free the storage
14458 for the function definition.
14460 FLAGS is a bitwise or of the following values:
14462 We just finished processing the body of an in-class inline
14463 function definition. (This processing will have taken place
14464 after the class definition is complete.) */
14467 finish_function (int flags
)
14469 tree fndecl
= current_function_decl
;
14470 tree fntype
, ctype
= NULL_TREE
;
14471 int inclass_inline
= (flags
& 2) != 0;
14473 /* When we get some parse errors, we can end up without a
14474 current_function_decl, so cope. */
14475 if (fndecl
== NULL_TREE
)
14476 return error_mark_node
;
14478 if (c_dialect_objc ())
14479 objc_finish_function ();
14481 gcc_assert (!defer_mark_used_calls
);
14482 defer_mark_used_calls
= true;
14484 record_key_method_defined (fndecl
);
14486 fntype
= TREE_TYPE (fndecl
);
14488 /* TREE_READONLY (fndecl) = 1;
14489 This caused &foo to be of type ptr-to-const-function
14490 which then got a warning when stored in a ptr-to-function variable. */
14492 gcc_assert (building_stmt_list_p ());
14493 /* The current function is being defined, so its DECL_INITIAL should
14494 be set, and unless there's a multiple definition, it should be
14495 error_mark_node. */
14496 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
14498 /* For a cloned function, we've already got all the code we need;
14499 there's no need to add any extra bits. */
14500 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14502 /* Make it so that `main' always returns 0 by default. */
14503 if (DECL_MAIN_P (current_function_decl
))
14504 finish_return_stmt (integer_zero_node
);
14506 if (use_eh_spec_block (current_function_decl
))
14507 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14508 (TREE_TYPE (current_function_decl
)),
14509 current_eh_spec_block
);
14512 /* If we're saving up tree structure, tie off the function now. */
14513 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
14515 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
14516 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
14518 finish_fname_decls ();
14520 /* If this function can't throw any exceptions, remember that. */
14521 if (!processing_template_decl
14522 && !cp_function_chain
->can_throw
14523 && !flag_non_call_exceptions
14524 && !decl_replaceable_p (fndecl
))
14525 TREE_NOTHROW (fndecl
) = 1;
14527 /* This must come after expand_function_end because cleanups might
14528 have declarations (from inline functions) that need to go into
14529 this function's blocks. */
14531 /* If the current binding level isn't the outermost binding level
14532 for this function, either there is a bug, or we have experienced
14533 syntax errors and the statement tree is malformed. */
14534 if (current_binding_level
->kind
!= sk_function_parms
)
14536 /* Make sure we have already experienced errors. */
14537 gcc_assert (errorcount
);
14539 /* Throw away the broken statement tree and extra binding
14541 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
14543 while (current_binding_level
->kind
!= sk_function_parms
)
14545 if (current_binding_level
->kind
== sk_class
)
14546 pop_nested_class ();
14548 poplevel (0, 0, 0);
14551 poplevel (1, 0, 1);
14553 /* Statements should always be full-expressions at the outermost set
14554 of curly braces for a function. */
14555 gcc_assert (stmts_are_full_exprs_p ());
14557 /* If there are no return statements in a function with auto return type,
14558 the return type is void. But if the declared type is something like
14559 auto*, this is an error. */
14560 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
14561 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
14563 if (!is_auto (current_function_auto_return_pattern
)
14564 && !current_function_returns_value
&& !current_function_returns_null
)
14566 error ("no return statements in function returning %qT",
14567 current_function_auto_return_pattern
);
14568 inform (input_location
, "only plain %<auto%> return type can be "
14569 "deduced to %<void%>");
14571 apply_deduced_return_type (fndecl
, void_type_node
);
14572 fntype
= TREE_TYPE (fndecl
);
14575 // If this is a concept, check that the definition is reasonable.
14576 if (DECL_DECLARED_CONCEPT_P (fndecl
))
14577 check_function_concept (fndecl
);
14579 /* Save constexpr function body before it gets munged by
14580 the NRV transformation. */
14581 maybe_save_function_definition (fndecl
);
14583 /* Invoke the pre-genericize plugin before we start munging things. */
14584 if (!processing_template_decl
)
14585 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14587 /* Perform delayed folding before NRV transformation. */
14588 if (!processing_template_decl
)
14589 cp_fold_function (fndecl
);
14591 /* Set up the named return value optimization, if we can. Candidate
14592 variables are selected in check_return_expr. */
14593 if (current_function_return_value
)
14595 tree r
= current_function_return_value
;
14598 if (r
!= error_mark_node
14599 /* This is only worth doing for fns that return in memory--and
14600 simpler, since we don't have to worry about promoted modes. */
14601 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
14602 /* Only allow this for variables declared in the outer scope of
14603 the function so we know that their lifetime always ends with a
14604 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14605 we were to do this optimization in tree-ssa. */
14606 && (outer
= outer_curly_brace_block (fndecl
))
14607 && chain_member (r
, BLOCK_VARS (outer
)))
14608 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
14610 current_function_return_value
= NULL_TREE
;
14613 /* Remember that we were in class scope. */
14614 if (current_class_name
)
14615 ctype
= current_class_type
;
14617 /* Must mark the RESULT_DECL as being in this function. */
14618 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14620 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14621 to the FUNCTION_DECL node itself. */
14622 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14624 /* Save away current state, if appropriate. */
14625 if (!processing_template_decl
)
14626 save_function_data (fndecl
);
14628 /* Complain if there's just no return statement. */
14629 if (warn_return_type
14630 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14631 && !dependent_type_p (TREE_TYPE (fntype
))
14632 && !current_function_returns_value
&& !current_function_returns_null
14633 /* Don't complain if we abort or throw. */
14634 && !current_function_returns_abnormally
14635 /* Don't complain if there's an infinite loop. */
14636 && !current_function_infinite_loop
14637 /* Don't complain if we are declared noreturn. */
14638 && !TREE_THIS_VOLATILE (fndecl
)
14639 && !DECL_NAME (DECL_RESULT (fndecl
))
14640 && !TREE_NO_WARNING (fndecl
)
14641 /* Structor return values (if any) are set by the compiler. */
14642 && !DECL_CONSTRUCTOR_P (fndecl
)
14643 && !DECL_DESTRUCTOR_P (fndecl
)
14644 && targetm
.warn_func_return (fndecl
))
14646 warning (OPT_Wreturn_type
,
14647 "no return statement in function returning non-void");
14648 TREE_NO_WARNING (fndecl
) = 1;
14651 /* Store the end of the function, so that we get good line number
14652 info for the epilogue. */
14653 cfun
->function_end_locus
= input_location
;
14655 /* Complain about parameters that are only set, but never otherwise used. */
14656 if (warn_unused_but_set_parameter
14657 && !processing_template_decl
14658 && errorcount
== unused_but_set_errorcount
14659 && !DECL_CLONED_FUNCTION_P (fndecl
))
14663 for (decl
= DECL_ARGUMENTS (fndecl
);
14665 decl
= DECL_CHAIN (decl
))
14666 if (TREE_USED (decl
)
14667 && TREE_CODE (decl
) == PARM_DECL
14668 && !DECL_READ_P (decl
)
14669 && DECL_NAME (decl
)
14670 && !DECL_ARTIFICIAL (decl
)
14671 && !TREE_NO_WARNING (decl
)
14672 && !DECL_IN_SYSTEM_HEADER (decl
)
14673 && TREE_TYPE (decl
) != error_mark_node
14674 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14675 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14676 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14677 warning_at (DECL_SOURCE_LOCATION (decl
),
14678 OPT_Wunused_but_set_parameter
,
14679 "parameter %qD set but not used", decl
);
14680 unused_but_set_errorcount
= errorcount
;
14683 /* Complain about locally defined typedefs that are not used in this
14685 maybe_warn_unused_local_typedefs ();
14687 /* Possibly warn about unused parameters. */
14688 if (warn_unused_parameter
14689 && !processing_template_decl
14690 && !DECL_CLONED_FUNCTION_P (fndecl
))
14691 do_warn_unused_parameter (fndecl
);
14693 /* Genericize before inlining. */
14694 if (!processing_template_decl
)
14696 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14697 cp_genericize (fndecl
);
14698 /* Clear out the bits we don't need. */
14699 f
->x_current_class_ptr
= NULL
;
14700 f
->x_current_class_ref
= NULL
;
14701 f
->x_eh_spec_block
= NULL
;
14702 f
->x_in_charge_parm
= NULL
;
14703 f
->x_vtt_parm
= NULL
;
14704 f
->x_return_value
= NULL
;
14705 f
->bindings
= NULL
;
14706 f
->extern_decl_map
= NULL
;
14707 f
->infinite_loops
= NULL
;
14709 /* Clear out the bits we don't need. */
14710 local_names
= NULL
;
14712 /* We're leaving the context of this function, so zap cfun. It's still in
14713 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14715 current_function_decl
= NULL
;
14717 /* If this is an in-class inline definition, we may have to pop the
14718 bindings for the template parameters that we added in
14719 maybe_begin_member_template_processing when start_function was
14721 if (inclass_inline
)
14722 maybe_end_member_template_processing ();
14724 /* Leave the scope of the class. */
14726 pop_nested_class ();
14731 current_function_decl
= NULL_TREE
;
14733 defer_mark_used_calls
= false;
14734 if (deferred_mark_used_calls
)
14739 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14741 vec_free (deferred_mark_used_calls
);
14744 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION
, fndecl
);
14748 /* Create the FUNCTION_DECL for a function definition.
14749 DECLSPECS and DECLARATOR are the parts of the declaration;
14750 they describe the return type and the name of the function,
14751 but twisted together in a fashion that parallels the syntax of C.
14753 This function creates a binding context for the function body
14754 as well as setting up the FUNCTION_DECL in current_function_decl.
14756 Returns a FUNCTION_DECL on success.
14758 If the DECLARATOR is not suitable for a function (it defines a datum
14759 instead), we return 0, which tells yyparse to report a parse error.
14761 May return void_type_node indicating that this method is actually
14762 a friend. See grokfield for more details.
14764 Came here with a `.pushlevel' .
14766 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14767 CHANGES TO CODE IN `grokfield'. */
14770 grokmethod (cp_decl_specifier_seq
*declspecs
,
14771 const cp_declarator
*declarator
, tree attrlist
)
14773 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14776 if (fndecl
== error_mark_node
)
14777 return error_mark_node
;
14779 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14781 error ("invalid member function declaration");
14782 return error_mark_node
;
14786 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14788 /* Pass friends other than inline friend functions back. */
14789 if (fndecl
== void_type_node
)
14792 if (DECL_IN_AGGR_P (fndecl
))
14794 if (DECL_CLASS_SCOPE_P (fndecl
))
14795 error ("%qD is already defined in class %qT", fndecl
,
14796 DECL_CONTEXT (fndecl
));
14797 return error_mark_node
;
14800 check_template_shadow (fndecl
);
14802 if (TREE_PUBLIC (fndecl
))
14803 DECL_COMDAT (fndecl
) = 1;
14804 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14805 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14807 /* We process method specializations in finish_struct_1. */
14808 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14810 fndecl
= push_template_decl (fndecl
);
14811 if (fndecl
== error_mark_node
)
14815 if (! DECL_FRIEND_P (fndecl
))
14817 if (DECL_CHAIN (fndecl
))
14819 fndecl
= copy_node (fndecl
);
14820 TREE_CHAIN (fndecl
) = NULL_TREE
;
14824 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14826 DECL_IN_AGGR_P (fndecl
) = 1;
14831 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14832 we can lay it out later, when and if its type becomes complete.
14834 Also handle constexpr variables where the initializer involves
14835 an unlowered PTRMEM_CST because the class isn't complete yet. */
14838 maybe_register_incomplete_var (tree var
)
14840 gcc_assert (VAR_P (var
));
14842 /* Keep track of variables with incomplete types. */
14843 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14844 && DECL_EXTERNAL (var
))
14846 tree inner_type
= TREE_TYPE (var
);
14848 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14849 inner_type
= TREE_TYPE (inner_type
);
14850 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14852 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14853 /* RTTI TD entries are created while defining the type_info. */
14854 || (TYPE_LANG_SPECIFIC (inner_type
)
14855 && TYPE_BEING_DEFINED (inner_type
)))
14857 incomplete_var iv
= {var
, inner_type
};
14858 vec_safe_push (incomplete_vars
, iv
);
14860 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
14861 && decl_constant_var_p (var
)
14862 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
14864 /* When the outermost open class is complete we can resolve any
14865 pointers-to-members. */
14866 tree context
= outermost_open_class ();
14867 incomplete_var iv
= {var
, context
};
14868 vec_safe_push (incomplete_vars
, iv
);
14873 /* Called when a class type (given by TYPE) is defined. If there are
14874 any existing VAR_DECLs whose type has been completed by this
14875 declaration, update them now. */
14878 complete_vars (tree type
)
14881 incomplete_var
*iv
;
14883 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14885 if (same_type_p (type
, iv
->incomplete_type
))
14887 tree var
= iv
->decl
;
14888 tree type
= TREE_TYPE (var
);
14890 if (TYPE_MAIN_VARIANT (strip_array_types (type
))
14891 == iv
->incomplete_type
)
14893 /* Complete the type of the variable. The VAR_DECL itself
14894 will be laid out in expand_expr. */
14895 complete_type (type
);
14896 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14899 /* Remove this entry from the list. */
14900 incomplete_vars
->unordered_remove (ix
);
14906 /* Check for pending declarations which may have abstract type. */
14907 complete_type_check_abstract (type
);
14910 /* If DECL is of a type which needs a cleanup, build and return an
14911 expression to perform that cleanup here. Return NULL_TREE if no
14912 cleanup need be done. */
14915 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14921 /* Assume no cleanup is required. */
14922 cleanup
= NULL_TREE
;
14924 if (error_operand_p (decl
))
14927 /* Handle "__attribute__((cleanup))". We run the cleanup function
14928 before the destructor since the destructor is what actually
14929 terminates the lifetime of the object. */
14930 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14937 /* Get the name specified by the user for the cleanup function. */
14938 id
= TREE_VALUE (TREE_VALUE (attr
));
14939 /* Look up the name to find the cleanup function to call. It is
14940 important to use lookup_name here because that is what is
14941 used in c-common.c:handle_cleanup_attribute when performing
14942 initial checks on the attribute. Note that those checks
14943 include ensuring that the function found is not an overloaded
14944 function, or an object with an overloaded call operator,
14945 etc.; we can rely on the fact that the function found is an
14946 ordinary FUNCTION_DECL. */
14947 fn
= lookup_name (id
);
14948 arg
= build_address (decl
);
14949 if (!mark_used (decl
, complain
) && !(complain
& tf_error
))
14950 return error_mark_node
;
14951 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14952 if (cleanup
== error_mark_node
)
14953 return error_mark_node
;
14955 /* Handle ordinary C++ destructors. */
14956 type
= TREE_TYPE (decl
);
14957 if (type_build_dtor_call (type
))
14959 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14963 if (TREE_CODE (type
) == ARRAY_TYPE
)
14966 addr
= build_address (decl
);
14968 call
= build_delete (TREE_TYPE (addr
), addr
,
14969 sfk_complete_destructor
, flags
, 0, complain
);
14970 if (call
== error_mark_node
)
14971 cleanup
= error_mark_node
;
14972 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14973 /* Discard the call. */;
14975 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14980 /* build_delete sets the location of the destructor call to the
14981 current location, even though the destructor is going to be
14982 called later, at the end of the current scope. This can lead to
14983 a "jumpy" behaviour for users of debuggers when they step around
14984 the end of the block. So let's unset the location of the
14985 destructor call instead. */
14986 protected_set_expr_location (cleanup
, UNKNOWN_LOCATION
);
14989 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
)))
14990 /* Treat objects with destructors as used; the destructor may do
14991 something substantive. */
14992 && !mark_used (decl
, complain
) && !(complain
& tf_error
))
14993 return error_mark_node
;
14999 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
15000 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
15001 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
15004 static_fn_type (tree memfntype
)
15009 if (TYPE_PTRMEMFUNC_P (memfntype
))
15010 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
15011 if (POINTER_TYPE_P (memfntype
)
15012 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
15013 memfntype
= TREE_TYPE (memfntype
);
15014 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
15016 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
15017 args
= TYPE_ARG_TYPES (memfntype
);
15018 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
15019 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
15020 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
15021 fntype
= (cp_build_type_attribute_variant
15022 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
15023 fntype
= (build_exception_variant
15024 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
15025 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
15026 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
15030 /* DECL was originally constructed as a non-static member function,
15031 but turned out to be static. Update it accordingly. */
15034 revert_static_member_fn (tree decl
)
15036 tree stype
= static_fn_type (decl
);
15037 cp_cv_quals quals
= type_memfn_quals (stype
);
15038 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
15040 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
15041 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
15043 TREE_TYPE (decl
) = stype
;
15045 if (DECL_ARGUMENTS (decl
))
15046 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
15047 DECL_STATIC_FUNCTION_P (decl
) = 1;
15050 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
15051 one of the language-independent trees. */
15053 enum cp_tree_node_structure_enum
15054 cp_tree_node_structure (union lang_tree_node
* t
)
15056 switch (TREE_CODE (&t
->generic
))
15058 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
15059 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
15060 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
15061 case OVERLOAD
: return TS_CP_OVERLOAD
;
15062 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
15063 case PTRMEM_CST
: return TS_CP_PTRMEM
;
15064 case BASELINK
: return TS_CP_BASELINK
;
15065 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
15066 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
15067 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
15068 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
15069 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
15070 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
15071 case CONSTRAINT_INFO
: return TS_CP_CONSTRAINT_INFO
;
15072 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
15073 default: return TS_CP_GENERIC
;
15077 /* Build the void_list_node (void_type_node having been created). */
15079 build_void_list_node (void)
15081 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
15086 cp_missing_noreturn_ok_p (tree decl
)
15088 /* A missing noreturn is ok for the `main' function. */
15089 return DECL_MAIN_P (decl
);
15092 /* Return the decl used to identify the COMDAT group into which DECL should
15096 cxx_comdat_group (tree decl
)
15098 /* Virtual tables, construction virtual tables, and virtual table
15099 tables all go in a single COMDAT group, named after the primary
15101 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
15102 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
15103 /* For all other DECLs, the COMDAT group is the mangled name of the
15104 declaration itself. */
15107 while (DECL_THUNK_P (decl
))
15109 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
15110 into the same section as the target function. In that case
15111 we must return target's name. */
15112 tree target
= THUNK_TARGET (decl
);
15113 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
15114 && DECL_SECTION_NAME (target
) != NULL
15115 && DECL_ONE_ONLY (target
))
15125 /* Returns the return type for FN as written by the user, which may include
15126 a placeholder for a deduced return type. */
15129 fndecl_declared_return_type (tree fn
)
15131 fn
= STRIP_TEMPLATE (fn
);
15132 if (FNDECL_USED_AUTO (fn
))
15134 struct language_function
*f
= NULL
;
15135 if (DECL_STRUCT_FUNCTION (fn
))
15136 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
15138 f
= DECL_SAVED_FUNCTION_DATA (fn
);
15139 return f
->x_auto_return_pattern
;
15141 return TREE_TYPE (TREE_TYPE (fn
));
15144 /* Returns true iff DECL was declared with an auto return type and it has
15145 not yet been deduced to a real type. */
15148 undeduced_auto_decl (tree decl
)
15150 if (cxx_dialect
< cxx14
)
15152 return type_uses_auto (TREE_TYPE (decl
));
15155 /* Complain if DECL has an undeduced return type. */
15158 require_deduced_type (tree decl
)
15160 if (undeduced_auto_decl (decl
))
15161 error ("use of %qD before deduction of %<auto%>", decl
);
15164 #include "gt-cp-decl.h"