1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2013 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"
34 #include "stringpool.h"
35 #include "stor-layout.h"
41 #include "tree-iterator.h"
42 #include "tree-inline.h"
49 #include "c-family/c-common.h"
50 #include "c-family/c-objc.h"
51 #include "c-family/c-pragma.h"
52 #include "c-family/c-target.h"
53 #include "c-family/c-ubsan.h"
54 #include "diagnostic.h"
58 #include "pointer-set.h"
59 #include "splay-tree.h"
64 /* Possible cases of bad specifiers type used by bad_specifiers. */
66 BSP_VAR
, /* variable */
67 BSP_PARM
, /* parameter */
72 static tree
grokparms (tree parmlist
, tree
*);
73 static const char *redeclaration_error_message (tree
, tree
);
75 static int decl_jump_unsafe (tree
);
76 static void require_complete_types_for_parms (tree
);
77 static int ambi_op_p (enum tree_code
);
78 static int unary_op_p (enum tree_code
);
79 static void push_local_name (tree
);
80 static tree
grok_reference_init (tree
, tree
, tree
, int);
81 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
83 static int check_static_variable_definition (tree
, tree
);
84 static void record_unknown_type (tree
, const char *);
85 static tree
builtin_function_1 (tree
, tree
, bool);
86 static int member_function_or_else (tree
, tree
, enum overload_flags
);
87 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
89 static void check_for_uninitialized_const_var (tree
);
90 static hashval_t
typename_hash (const void *);
91 static int typename_compare (const void *, const void *);
92 static tree
local_variable_p_walkfn (tree
*, int *, void *);
93 static tree
record_builtin_java_type (const char *, int);
94 static const char *tag_name (enum tag_types
);
95 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
96 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
97 static void maybe_deduce_size_from_array_init (tree
, tree
);
98 static void layout_var_decl (tree
);
99 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
100 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
101 static void save_function_data (tree
);
102 static void copy_type_enum (tree
, tree
);
103 static void check_function_type (tree
, tree
);
104 static void finish_constructor_body (void);
105 static void begin_destructor_body (void);
106 static void finish_destructor_body (void);
107 static void record_key_method_defined (tree
);
108 static tree
create_array_type_for_decl (tree
, tree
, tree
);
109 static tree
get_atexit_node (void);
110 static tree
get_dso_handle_node (void);
111 static tree
start_cleanup_fn (void);
112 static void end_cleanup_fn (void);
113 static tree
cp_make_fname_decl (location_t
, tree
, int);
114 static void initialize_predefined_identifiers (void);
115 static tree check_special_function_return_type
116 (special_function_kind
, tree
, tree
);
117 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
118 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
119 static void store_parm_decls (tree
);
120 static void initialize_local_var (tree
, tree
);
121 static void expand_static_init (tree
, tree
);
123 /* The following symbols are subsumed in the cp_global_trees array, and
124 listed here individually for documentation purposes.
127 tree wchar_decl_node;
129 tree vtable_entry_type;
130 tree delta_type_node;
131 tree __t_desc_type_node;
133 tree class_type_node;
134 tree unknown_type_node;
136 Array type `vtable_entry_type[]'
139 tree vtbl_ptr_type_node;
146 A FUNCTION_DECL which can call `abort'. Not necessarily the
147 one that the user will declare, but sufficient to be called
148 by routines that want to abort the program.
152 The FUNCTION_DECL for the default `::operator delete'.
154 tree global_delete_fndecl;
157 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
158 tree tinfo_var_id; */
160 tree cp_global_trees
[CPTI_MAX
];
162 /* Indicates that there is a type value in some namespace, although
163 that is not necessarily in scope at the moment. */
165 tree global_type_node
;
167 /* The node that holds the "name" of the global scope. */
168 tree global_scope_name
;
170 #define local_names cp_function_chain->x_local_names
172 /* A list of objects which have constructors or destructors
173 which reside in the global scope. The decl is stored in
174 the TREE_VALUE slot and the initializer is stored
175 in the TREE_PURPOSE slot. */
176 tree static_aggregates
;
178 /* Like static_aggregates, but for thread_local variables. */
183 /* A node for the integer constant 2. */
185 tree integer_two_node
;
187 /* Used only for jumps to as-yet undefined labels, since jumps to
188 defined labels can have their validity checked immediately. */
190 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
191 struct named_label_use_entry
*next
;
192 /* The binding level to which this entry is *currently* attached.
193 This is initially the binding level in which the goto appeared,
194 but is modified as scopes are closed. */
195 cp_binding_level
*binding_level
;
196 /* The head of the names list that was current when the goto appeared,
197 or the inner scope popped. These are the decls that will *not* be
198 skipped when jumping to the label. */
200 /* The location of the goto, for error reporting. */
201 location_t o_goto_locus
;
202 /* True if an OpenMP structured block scope has been closed since
203 the goto appeared. This means that the branch from the label will
204 illegally exit an OpenMP scope. */
208 /* A list of all LABEL_DECLs in the function that have names. Here so
209 we can clear out their names' definitions at the end of the
210 function, and so we can check the validity of jumps to these labels. */
212 struct GTY(()) named_label_entry
{
213 /* The decl itself. */
216 /* The binding level to which the label is *currently* attached.
217 This is initially set to the binding level in which the label
218 is defined, but is modified as scopes are closed. */
219 cp_binding_level
*binding_level
;
220 /* The head of the names list that was current when the label was
221 defined, or the inner scope popped. These are the decls that will
222 be skipped when jumping to the label. */
224 /* A vector of all decls from all binding levels that would be
225 crossed by a backward branch to the label. */
226 vec
<tree
, va_gc
> *bad_decls
;
228 /* A list of uses of the label, before the label is defined. */
229 struct named_label_use_entry
*uses
;
231 /* The following bits are set after the label is defined, and are
232 updated as scopes are popped. They indicate that a backward jump
233 to the label will illegally enter a scope of the given flavor. */
239 #define named_labels cp_function_chain->x_named_labels
241 /* The number of function bodies which we are currently processing.
242 (Zero if we are at namespace scope, one inside the body of a
243 function, two inside the body of a function in a local class, etc.) */
246 /* To avoid unwanted recursion, finish_function defers all mark_used calls
247 encountered during its execution until it finishes. */
248 bool defer_mark_used_calls
;
249 vec
<tree
, va_gc
> *deferred_mark_used_calls
;
251 /* States indicating how grokdeclarator() should handle declspecs marked
252 with __attribute__((deprecated)). An object declared as
253 __attribute__((deprecated)) suppresses warnings of uses of other
255 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
258 /* A list of VAR_DECLs whose type was incomplete at the time the
259 variable was declared. */
261 typedef struct GTY(()) incomplete_var_d
{
263 tree incomplete_type
;
267 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
269 /* Returns the kind of template specialization we are currently
270 processing, given that it's declaration contained N_CLASS_SCOPES
271 explicit scope qualifications. */
274 current_tmpl_spec_kind (int n_class_scopes
)
276 int n_template_parm_scopes
= 0;
277 int seen_specialization_p
= 0;
278 int innermost_specialization_p
= 0;
281 /* Scan through the template parameter scopes. */
282 for (b
= current_binding_level
;
283 b
->kind
== sk_template_parms
;
286 /* If we see a specialization scope inside a parameter scope,
287 then something is wrong. That corresponds to a declaration
290 template <class T> template <> ...
292 which is always invalid since [temp.expl.spec] forbids the
293 specialization of a class member template if the enclosing
294 class templates are not explicitly specialized as well. */
295 if (b
->explicit_spec_p
)
297 if (n_template_parm_scopes
== 0)
298 innermost_specialization_p
= 1;
300 seen_specialization_p
= 1;
302 else if (seen_specialization_p
== 1)
303 return tsk_invalid_member_spec
;
305 ++n_template_parm_scopes
;
308 /* Handle explicit instantiations. */
309 if (processing_explicit_instantiation
)
311 if (n_template_parm_scopes
!= 0)
312 /* We've seen a template parameter list during an explicit
313 instantiation. For example:
315 template <class T> template void f(int);
317 This is erroneous. */
318 return tsk_invalid_expl_inst
;
320 return tsk_expl_inst
;
323 if (n_template_parm_scopes
< n_class_scopes
)
324 /* We've not seen enough template headers to match all the
325 specialized classes present. For example:
327 template <class T> void R<T>::S<T>::f(int);
329 This is invalid; there needs to be one set of template
330 parameters for each class. */
331 return tsk_insufficient_parms
;
332 else if (n_template_parm_scopes
== n_class_scopes
)
333 /* We're processing a non-template declaration (even though it may
334 be a member of a template class.) For example:
336 template <class T> void S<T>::f(int);
338 The `class T' matches the `S<T>', leaving no template headers
339 corresponding to the `f'. */
341 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
342 /* We've got too many template headers. For example:
344 template <> template <class T> void f (T);
346 There need to be more enclosing classes. */
347 return tsk_excessive_parms
;
349 /* This must be a template. It's of the form:
351 template <class T> template <class U> void S<T>::f(U);
353 This is a specialization if the innermost level was a
354 specialization; otherwise it's just a definition of the
356 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
359 /* Exit the current scope. */
367 /* When a label goes out of scope, check to see if that label was used
368 in a valid manner, and issue any appropriate warnings or errors. */
371 pop_label (tree label
, tree old_value
)
373 if (!processing_template_decl
)
375 if (DECL_INITIAL (label
) == NULL_TREE
)
379 error ("label %q+D used but not defined", label
);
380 location
= input_location
;
381 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
382 /* Avoid crashing later. */
383 define_label (location
, DECL_NAME (label
));
386 warn_for_unused_label (label
);
389 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
392 /* At the end of a function, all labels declared within the function
393 go out of scope. BLOCK is the top-level block for the
397 pop_labels_1 (void **slot
, void *data
)
399 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
400 tree block
= (tree
) data
;
402 pop_label (ent
->label_decl
, NULL_TREE
);
404 /* Put the labels into the "variables" of the top-level block,
405 so debugger can see them. */
406 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
407 BLOCK_VARS (block
) = ent
->label_decl
;
409 htab_clear_slot (named_labels
, slot
);
415 pop_labels (tree block
)
419 htab_traverse (named_labels
, pop_labels_1
, block
);
424 /* At the end of a block with local labels, restore the outer definition. */
427 pop_local_label (tree label
, tree old_value
)
429 struct named_label_entry dummy
;
432 pop_label (label
, old_value
);
434 dummy
.label_decl
= label
;
435 slot
= htab_find_slot (named_labels
, &dummy
, NO_INSERT
);
436 htab_clear_slot (named_labels
, slot
);
439 /* The following two routines are used to interface to Objective-C++.
440 The binding level is purposely treated as an opaque type. */
443 objc_get_current_scope (void)
445 return current_binding_level
;
448 /* The following routine is used by the NeXT-style SJLJ exceptions;
449 variables get marked 'volatile' so as to not be clobbered by
450 _setjmp()/_longjmp() calls. All variables in the current scope,
451 as well as parent scopes up to (but not including) ENCLOSING_BLK
452 shall be thusly marked. */
455 objc_mark_locals_volatile (void *enclosing_blk
)
457 cp_binding_level
*scope
;
459 for (scope
= current_binding_level
;
460 scope
&& scope
!= enclosing_blk
;
461 scope
= scope
->level_chain
)
465 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
466 objc_volatilize_decl (decl
);
468 /* Do not climb up past the current function. */
469 if (scope
->kind
== sk_function_parms
)
474 /* Update data for defined and undefined labels when leaving a scope. */
477 poplevel_named_label_1 (void **slot
, void *data
)
479 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
480 cp_binding_level
*bl
= (cp_binding_level
*) data
;
481 cp_binding_level
*obl
= bl
->level_chain
;
483 if (ent
->binding_level
== bl
)
487 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
488 TREE_LISTs representing OVERLOADs, so be careful. */
489 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
491 : TREE_CHAIN (decl
)))
492 if (decl_jump_unsafe (decl
))
493 vec_safe_push (ent
->bad_decls
, decl
);
495 ent
->binding_level
= obl
;
496 ent
->names_in_scope
= obl
->names
;
500 ent
->in_try_scope
= true;
503 ent
->in_catch_scope
= true;
506 ent
->in_omp_scope
= true;
514 struct named_label_use_entry
*use
;
516 for (use
= ent
->uses
; use
; use
= use
->next
)
517 if (use
->binding_level
== bl
)
519 use
->binding_level
= obl
;
520 use
->names_in_scope
= obl
->names
;
521 if (bl
->kind
== sk_omp
)
522 use
->in_omp_scope
= true;
529 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
530 when errors were reported, except for -Werror-unused-but-set-*. */
531 static int unused_but_set_errorcount
;
533 /* Exit a binding level.
534 Pop the level off, and restore the state of the identifier-decl mappings
535 that were in effect when this level was entered.
537 If KEEP == 1, this level had explicit declarations, so
538 and create a "block" (a BLOCK node) for the level
539 to record its declarations and subblocks for symbol table output.
541 If FUNCTIONBODY is nonzero, this level is the body of a function,
542 so create a block as if KEEP were set and also clear out all
545 If REVERSE is nonzero, reverse the order of decls before putting
546 them into the BLOCK. */
549 poplevel (int keep
, int reverse
, int functionbody
)
552 /* The chain of decls was accumulated in reverse order.
553 Put it into forward order, just for cleanliness. */
558 int leaving_for_scope
;
561 cp_label_binding
*label_bind
;
563 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
568 gcc_assert (current_binding_level
->kind
!= sk_class
);
570 if (current_binding_level
->kind
== sk_cleanup
)
572 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
574 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
576 /* We used to use KEEP == 2 to indicate that the new block should go
577 at the beginning of the list of blocks at this binding level,
578 rather than the end. This hack is no longer used. */
579 gcc_assert (keep
== 0 || keep
== 1);
581 if (current_binding_level
->keep
)
584 /* Any uses of undefined labels, and any defined labels, now operate
585 under constraints of next binding contour. */
586 if (cfun
&& !functionbody
&& named_labels
)
587 htab_traverse (named_labels
, poplevel_named_label_1
,
588 current_binding_level
);
590 /* Get the decls in the order they were written.
591 Usually current_binding_level->names is in reverse order.
592 But parameter decls were previously put in forward order. */
595 current_binding_level
->names
596 = decls
= nreverse (current_binding_level
->names
);
598 decls
= current_binding_level
->names
;
600 /* If there were any declarations or structure tags in that level,
601 or if this level is a function body,
602 create a BLOCK to record them for the life of this function. */
604 if (keep
== 1 || functionbody
)
605 block
= make_node (BLOCK
);
606 if (block
!= NULL_TREE
)
608 BLOCK_VARS (block
) = decls
;
609 BLOCK_SUBBLOCKS (block
) = subblocks
;
612 /* In each subblock, record that this is its superior. */
614 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
615 BLOCK_SUPERCONTEXT (link
) = block
;
617 /* We still support the old for-scope rules, whereby the variables
618 in a for-init statement were in scope after the for-statement
619 ended. We only use the new rules if flag_new_for_scope is
622 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
624 /* Before we remove the declarations first check for unused variables. */
625 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
626 && !processing_template_decl
)
627 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
629 /* There are cases where D itself is a TREE_LIST. See in
630 push_local_binding where the list of decls returned by
631 getdecls is built. */
632 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
633 // See through references for improved -Wunused-variable (PR 38958).
634 tree type
= non_reference (TREE_TYPE (decl
));
636 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
637 && ! DECL_IN_SYSTEM_HEADER (decl
)
638 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
639 && type
!= error_mark_node
640 && (!CLASS_TYPE_P (type
)
641 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
642 || lookup_attribute ("warn_unused",
643 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
645 if (! TREE_USED (decl
))
646 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
647 else if (DECL_CONTEXT (decl
) == current_function_decl
648 // For -Wunused-but-set-variable leave references alone.
649 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
650 && errorcount
== unused_but_set_errorcount
)
652 warning (OPT_Wunused_but_set_variable
,
653 "variable %q+D set but not used", decl
);
654 unused_but_set_errorcount
= errorcount
;
659 /* Remove declarations for all the DECLs in this level. */
660 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
662 if (leaving_for_scope
&& VAR_P (link
)
663 /* It's hard to make this ARM compatibility hack play nicely with
664 lambdas, and it really isn't necessary in C++11 mode. */
665 && cxx_dialect
< cxx11
668 tree name
= DECL_NAME (link
);
672 ob
= outer_binding (name
,
673 IDENTIFIER_BINDING (name
),
676 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
678 ns_binding
= NULL_TREE
;
680 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
681 /* We have something like:
686 and we are leaving the `for' scope. There's no reason to
687 keep the binding of the inner `i' in this case. */
688 pop_binding (name
, link
);
689 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
690 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
691 /* Here, we have something like:
699 We must pop the for-scope binding so we know what's a
700 type and what isn't. */
701 pop_binding (name
, link
);
704 /* Mark this VAR_DECL as dead so that we can tell we left it
705 there only for backward compatibility. */
706 DECL_DEAD_FOR_LOCAL (link
) = 1;
708 /* Keep track of what should have happened when we
709 popped the binding. */
712 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
713 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
716 /* Add it to the list of dead variables in the next
717 outermost binding to that we can remove these when we
718 leave that binding. */
720 current_binding_level
->level_chain
->dead_vars_from_for
,
723 /* Although we don't pop the cxx_binding, we do clear
724 its SCOPE since the scope is going away now. */
725 IDENTIFIER_BINDING (name
)->scope
726 = current_binding_level
->level_chain
;
733 /* Remove the binding. */
736 if (TREE_CODE (decl
) == TREE_LIST
)
737 decl
= TREE_VALUE (decl
);
740 if (TREE_CODE (name
) == OVERLOAD
)
741 name
= OVL_FUNCTION (name
);
743 gcc_assert (DECL_P (name
));
744 pop_binding (DECL_NAME (name
), decl
);
748 /* Remove declarations for any `for' variables from inner scopes
749 that we kept around. */
750 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
752 pop_binding (DECL_NAME (decl
), decl
);
754 /* Restore the IDENTIFIER_TYPE_VALUEs. */
755 for (link
= current_binding_level
->type_shadowed
;
756 link
; link
= TREE_CHAIN (link
))
757 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
759 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
760 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
762 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
764 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
765 list if a `using' declaration put them there. The debugging
766 back ends won't understand OVERLOAD, so we remove them here.
767 Because the BLOCK_VARS are (temporarily) shared with
768 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
769 popped all the bindings. */
774 for (d
= &BLOCK_VARS (block
); *d
; )
776 if (TREE_CODE (*d
) == TREE_LIST
)
777 *d
= TREE_CHAIN (*d
);
779 d
= &DECL_CHAIN (*d
);
783 /* If the level being exited is the top level of a function,
784 check over all the labels. */
787 /* Since this is the top level block of a function, the vars are
788 the function's parameters. Don't leave them in the BLOCK
789 because they are found in the FUNCTION_DECL instead. */
790 BLOCK_VARS (block
) = 0;
794 kind
= current_binding_level
->kind
;
795 if (kind
== sk_cleanup
)
799 /* If this is a temporary binding created for a cleanup, then we'll
800 have pushed a statement list level. Pop that, create a new
801 BIND_EXPR for the block, and insert it into the stream. */
802 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
803 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
810 /* The current function is being defined, so its DECL_INITIAL
811 should be error_mark_node. */
812 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
813 DECL_INITIAL (current_function_decl
) = block
;
816 current_binding_level
->blocks
817 = block_chainon (current_binding_level
->blocks
, block
);
819 /* If we did not make a block for the level just exited,
820 any blocks made for inner levels
821 (since they cannot be recorded as subblocks in that level)
822 must be carried forward so they will later become subblocks
823 of something else. */
825 current_binding_level
->blocks
826 = block_chainon (current_binding_level
->blocks
, subblocks
);
828 /* Each and every BLOCK node created here in `poplevel' is important
829 (e.g. for proper debugging information) so if we created one
830 earlier, mark it as "used". */
832 TREE_USED (block
) = 1;
834 /* All temporary bindings created for cleanups are popped silently. */
835 if (kind
== sk_cleanup
)
838 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
842 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
843 itself, calling F for each. The DATA is passed to F as well. */
846 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
849 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
851 result
|= (*f
) (name_space
, data
);
853 for (; current
; current
= DECL_CHAIN (current
))
854 result
|= walk_namespaces_r (current
, f
, data
);
859 /* Walk all the namespaces, calling F for each. The DATA is passed to
863 walk_namespaces (walk_namespaces_fn f
, void* data
)
865 return walk_namespaces_r (global_namespace
, f
, data
);
868 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
869 DATA is non-NULL, this is the last time we will call
870 wrapup_global_declarations for this NAMESPACE. */
873 wrapup_globals_for_namespace (tree name_space
, void* data
)
875 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
876 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
877 tree
*vec
= statics
->address ();
878 int len
= statics
->length ();
879 int last_time
= (data
!= 0);
883 check_global_declarations (vec
, len
);
884 emit_debug_global_declarations (vec
, len
);
888 /* Write out any globals that need to be output. */
889 return wrapup_global_declarations (vec
, len
);
893 /* In C++, you don't have to write `struct S' to refer to `S'; you
894 can just use `S'. We accomplish this by creating a TYPE_DECL as
895 if the user had written `typedef struct S S'. Create and return
896 the TYPE_DECL for TYPE. */
899 create_implicit_typedef (tree name
, tree type
)
903 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
904 DECL_ARTIFICIAL (decl
) = 1;
905 /* There are other implicit type declarations, like the one *within*
906 a class that allows you to write `S::S'. We must distinguish
908 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
909 TYPE_NAME (type
) = decl
;
910 TYPE_STUB_DECL (type
) = decl
;
915 /* Remember a local name for name-mangling purposes. */
918 push_local_name (tree decl
)
923 timevar_start (TV_NAME_LOOKUP
);
925 name
= DECL_NAME (decl
);
927 nelts
= vec_safe_length (local_names
);
928 for (i
= 0; i
< nelts
; i
++)
930 t
= (*local_names
)[i
];
931 if (DECL_NAME (t
) == name
)
933 if (!DECL_LANG_SPECIFIC (decl
))
934 retrofit_lang_decl (decl
);
935 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
936 if (DECL_DISCRIMINATOR_SET_P (t
))
937 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
939 DECL_DISCRIMINATOR (decl
) = 1;
941 (*local_names
)[i
] = decl
;
942 timevar_stop (TV_NAME_LOOKUP
);
947 vec_safe_push (local_names
, decl
);
948 timevar_stop (TV_NAME_LOOKUP
);
951 /* Subroutine of duplicate_decls: return truthvalue of whether
952 or not types of these decls match.
954 For C++, we must compare the parameter list so that `int' can match
955 `int&' in a parameter position, but `int&' is not confused with
959 decls_match (tree newdecl
, tree olddecl
)
963 if (newdecl
== olddecl
)
966 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
967 /* If the two DECLs are not even the same kind of thing, we're not
968 interested in their types. */
971 gcc_assert (DECL_P (newdecl
));
973 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
975 tree f1
= TREE_TYPE (newdecl
);
976 tree f2
= TREE_TYPE (olddecl
);
977 tree p1
= TYPE_ARG_TYPES (f1
);
978 tree p2
= TYPE_ARG_TYPES (f2
);
981 /* Specializations of different templates are different functions
982 even if they have the same type. */
983 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
984 ? DECL_TI_TEMPLATE (newdecl
)
986 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
987 ? DECL_TI_TEMPLATE (olddecl
)
992 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
993 && ! (DECL_EXTERN_C_P (newdecl
)
994 && DECL_EXTERN_C_P (olddecl
)))
997 /* A new declaration doesn't match a built-in one unless it
998 is also extern "C". */
999 if (DECL_IS_BUILTIN (olddecl
)
1000 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1003 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1006 /* A declaration with deduced return type should use its pre-deduction
1007 type for declaration matching. */
1008 r2
= fndecl_declared_return_type (olddecl
);
1010 if (same_type_p (TREE_TYPE (f1
), r2
))
1012 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1013 && (DECL_BUILT_IN (olddecl
)
1014 #ifndef NO_IMPLICIT_EXTERN_C
1015 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1016 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1020 types_match
= self_promoting_args_p (p1
);
1021 if (p1
== void_list_node
)
1022 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1024 #ifndef NO_IMPLICIT_EXTERN_C
1025 else if (!prototype_p (f1
)
1026 && (DECL_EXTERN_C_P (olddecl
)
1027 && DECL_IN_SYSTEM_HEADER (olddecl
)
1028 && !DECL_CLASS_SCOPE_P (olddecl
))
1029 && (DECL_EXTERN_C_P (newdecl
)
1030 && DECL_IN_SYSTEM_HEADER (newdecl
)
1031 && !DECL_CLASS_SCOPE_P (newdecl
)))
1033 types_match
= self_promoting_args_p (p2
);
1034 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1040 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1041 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1042 || comp_type_attributes (TREE_TYPE (newdecl
),
1043 TREE_TYPE (olddecl
)) != 0);
1048 /* The decls dont match if they correspond to two different versions
1049 of the same function. Disallow extern "C" functions to be
1050 versions for now. */
1052 && !DECL_EXTERN_C_P (newdecl
)
1053 && !DECL_EXTERN_C_P (olddecl
)
1054 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1056 /* Mark functions as versions if necessary. Modify the mangled decl
1057 name if necessary. */
1058 if (DECL_FUNCTION_VERSIONED (newdecl
)
1059 && DECL_FUNCTION_VERSIONED (olddecl
))
1061 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1063 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1064 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1065 mangle_decl (newdecl
);
1067 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1069 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1070 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1071 mangle_decl (olddecl
);
1073 record_function_versions (olddecl
, newdecl
);
1077 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1079 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1080 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1083 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1084 DECL_TEMPLATE_PARMS (olddecl
)))
1087 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1088 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1089 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1091 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1092 DECL_TEMPLATE_RESULT (newdecl
));
1096 /* Need to check scope for variable declaration (VAR_DECL).
1097 For typedef (TYPE_DECL), scope is ignored. */
1099 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1101 Two declarations for an object with C language linkage
1102 with the same name (ignoring the namespace that qualify
1103 it) that appear in different namespace scopes refer to
1105 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1108 if (TREE_TYPE (newdecl
) == error_mark_node
)
1109 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1110 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1111 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1112 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1115 types_match
= comptypes (TREE_TYPE (newdecl
),
1116 TREE_TYPE (olddecl
),
1117 COMPARE_REDECLARATION
);
1123 /* If NEWDECL is `static' and an `extern' was seen previously,
1124 warn about it. OLDDECL is the previous declaration.
1126 Note that this does not apply to the C++ case of declaring
1127 a variable `extern const' and then later `const'.
1129 Don't complain about built-in functions, since they are beyond
1130 the user's control. */
1133 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1135 if (TREE_CODE (newdecl
) == TYPE_DECL
1136 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1137 || TREE_CODE (newdecl
) == CONST_DECL
1138 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1141 /* Don't get confused by static member functions; that's a different
1143 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1144 && DECL_STATIC_FUNCTION_P (newdecl
))
1147 /* If the old declaration was `static', or the new one isn't, then
1148 everything is OK. */
1149 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1152 /* It's OK to declare a builtin function as `static'. */
1153 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1154 && DECL_ARTIFICIAL (olddecl
))
1157 if (permerror (input_location
,
1158 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1159 inform (input_location
, "previous declaration of %q+D", olddecl
);
1162 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1163 function templates. If their exception specifications do not
1164 match, issue a diagnostic. */
1167 check_redeclaration_exception_specification (tree new_decl
,
1172 tree new_exceptions
;
1173 tree old_exceptions
;
1175 new_type
= TREE_TYPE (new_decl
);
1176 new_exceptions
= TYPE_RAISES_EXCEPTIONS (new_type
);
1177 old_type
= TREE_TYPE (old_decl
);
1178 old_exceptions
= TYPE_RAISES_EXCEPTIONS (old_type
);
1182 If any declaration of a function has an exception-specification,
1183 all declarations, including the definition and an explicit
1184 specialization, of that function shall have an
1185 exception-specification with the same set of type-ids. */
1186 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1187 && ! DECL_IS_BUILTIN (old_decl
)
1189 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1191 error ("declaration of %qF has a different exception specifier",
1193 error ("from previous declaration %q+F", old_decl
);
1197 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1198 Otherwise issue diagnostics. */
1201 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1203 old_decl
= STRIP_TEMPLATE (old_decl
);
1204 new_decl
= STRIP_TEMPLATE (new_decl
);
1205 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1206 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1208 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1209 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1211 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1213 if (DECL_BUILT_IN (old_decl
))
1215 /* Hide a built-in declaration. */
1216 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1217 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1220 /* 7.1.5 [dcl.constexpr]
1221 Note: An explicit specialization can differ from the template
1222 declaration with respect to the constexpr specifier. */
1223 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1224 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1227 error ("redeclaration %qD differs in %<constexpr%>", new_decl
);
1228 error ("from previous declaration %q+D", old_decl
);
1234 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1235 && lookup_attribute ("gnu_inline", \
1236 DECL_ATTRIBUTES (fn)))
1238 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1239 If the redeclaration is invalid, a diagnostic is issued, and the
1240 error_mark_node is returned. Otherwise, OLDDECL is returned.
1242 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1245 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1248 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1250 unsigned olddecl_uid
= DECL_UID (olddecl
);
1251 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1252 int new_defines_function
= 0;
1253 tree new_template_info
;
1255 if (newdecl
== olddecl
)
1258 types_match
= decls_match (newdecl
, olddecl
);
1260 /* If either the type of the new decl or the type of the old decl is an
1261 error_mark_node, then that implies that we have already issued an
1262 error (earlier) for some bogus type specification, and in that case,
1263 it is rather pointless to harass the user with yet more error message
1264 about the same declaration, so just pretend the types match here. */
1265 if (TREE_TYPE (newdecl
) == error_mark_node
1266 || TREE_TYPE (olddecl
) == error_mark_node
)
1267 return error_mark_node
;
1269 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1270 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1272 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1273 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1274 && check_raw_literal_operator (olddecl
))
1275 error ("literal operator template %q+D conflicts with"
1276 " raw literal operator %qD", newdecl
, olddecl
);
1277 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1278 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1279 && check_raw_literal_operator (newdecl
))
1280 error ("raw literal operator %q+D conflicts with"
1281 " literal operator template %qD", newdecl
, olddecl
);
1284 if (DECL_P (olddecl
)
1285 && TREE_CODE (newdecl
) == FUNCTION_DECL
1286 && TREE_CODE (olddecl
) == FUNCTION_DECL
1287 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1289 if (DECL_DECLARED_INLINE_P (newdecl
)
1290 && DECL_UNINLINABLE (newdecl
)
1291 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1292 /* Already warned elsewhere. */;
1293 else if (DECL_DECLARED_INLINE_P (olddecl
)
1294 && DECL_UNINLINABLE (olddecl
)
1295 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1296 /* Already warned. */;
1297 else if (DECL_DECLARED_INLINE_P (newdecl
)
1298 && DECL_UNINLINABLE (olddecl
)
1299 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1301 if (warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1303 inform (DECL_SOURCE_LOCATION (olddecl
),
1304 "previous declaration of %qD with attribute noinline",
1307 else if (DECL_DECLARED_INLINE_P (olddecl
)
1308 && DECL_UNINLINABLE (newdecl
)
1309 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1311 if (warning (OPT_Wattributes
, "function %q+D redeclared with "
1312 "attribute noinline", newdecl
))
1313 inform (DECL_SOURCE_LOCATION (olddecl
),
1314 "previous declaration of %qD was inline",
1319 /* Check for redeclaration and other discrepancies. */
1320 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1321 && DECL_ARTIFICIAL (olddecl
))
1323 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1324 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1326 /* Avoid warnings redeclaring built-ins which have not been
1327 explicitly declared. */
1328 if (DECL_ANTICIPATED (olddecl
))
1331 /* If you declare a built-in or predefined function name as static,
1332 the old definition is overridden, but optionally warn this was a
1333 bad choice of name. */
1334 if (! TREE_PUBLIC (newdecl
))
1336 warning (OPT_Wshadow
,
1337 DECL_BUILT_IN (olddecl
)
1338 ? G_("shadowing built-in function %q#D")
1339 : G_("shadowing library function %q#D"), olddecl
);
1340 /* Discard the old built-in function. */
1343 /* If the built-in is not ansi, then programs can override
1344 it even globally without an error. */
1345 else if (! DECL_BUILT_IN (olddecl
))
1346 warning (0, "library function %q#D redeclared as non-function %q#D",
1349 error ("declaration of %q#D conflicts with built-in "
1350 "declaration %q#D", newdecl
, olddecl
);
1353 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1355 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1356 error_at (DECL_SOURCE_LOCATION (newdecl
),
1357 "redeclaration of %<pragma omp declare reduction%>");
1358 inform (DECL_SOURCE_LOCATION (olddecl
),
1359 "previous %<pragma omp declare reduction%> declaration");
1360 return error_mark_node
;
1362 else if (!types_match
)
1364 /* Avoid warnings redeclaring built-ins which have not been
1365 explicitly declared. */
1366 if (DECL_ANTICIPATED (olddecl
))
1368 /* Deal with fileptr_type_node. FILE type is not known
1369 at the time we create the builtins. */
1372 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1373 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1375 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1378 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1380 tree t
= TREE_VALUE (t1
);
1383 && TYPE_NAME (TREE_TYPE (t
))
1384 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1385 == get_identifier ("FILE")
1386 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1388 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1390 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1391 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1392 types_match
= decls_match (newdecl
, olddecl
);
1394 return duplicate_decls (newdecl
, olddecl
,
1396 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1399 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1402 else if ((DECL_EXTERN_C_P (newdecl
)
1403 && DECL_EXTERN_C_P (olddecl
))
1404 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1405 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1407 /* A near match; override the builtin. */
1409 if (TREE_PUBLIC (newdecl
))
1410 warning (0, "new declaration %q#D ambiguates built-in "
1411 "declaration %q#D", newdecl
, olddecl
);
1413 warning (OPT_Wshadow
,
1414 DECL_BUILT_IN (olddecl
)
1415 ? G_("shadowing built-in function %q#D")
1416 : G_("shadowing library function %q#D"), olddecl
);
1419 /* Discard the old built-in function. */
1422 /* Replace the old RTL to avoid problems with inlining. */
1423 COPY_DECL_RTL (newdecl
, olddecl
);
1425 /* Even if the types match, prefer the new declarations type for
1426 built-ins which have not been explicitly declared, for
1427 exception lists, etc... */
1428 else if (DECL_IS_BUILTIN (olddecl
))
1430 tree type
= TREE_TYPE (newdecl
);
1431 tree attribs
= (*targetm
.merge_type_attributes
)
1432 (TREE_TYPE (olddecl
), type
);
1434 type
= cp_build_type_attribute_variant (type
, attribs
);
1435 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1438 /* If a function is explicitly declared "throw ()", propagate that to
1439 the corresponding builtin. */
1440 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1441 && DECL_ANTICIPATED (olddecl
)
1442 && TREE_NOTHROW (newdecl
)
1443 && !TREE_NOTHROW (olddecl
))
1445 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1446 tree tmpdecl
= builtin_decl_explicit (fncode
);
1447 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1448 TREE_NOTHROW (tmpdecl
) = 1;
1451 /* Whether or not the builtin can throw exceptions has no
1452 bearing on this declarator. */
1453 TREE_NOTHROW (olddecl
) = 0;
1455 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1457 /* If a builtin function is redeclared as `static', merge
1458 the declarations, but make the original one static. */
1459 DECL_THIS_STATIC (olddecl
) = 1;
1460 TREE_PUBLIC (olddecl
) = 0;
1462 /* Make the old declaration consistent with the new one so
1463 that all remnants of the builtin-ness of this function
1464 will be banished. */
1465 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1466 COPY_DECL_RTL (newdecl
, olddecl
);
1469 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1471 /* C++ Standard, 3.3, clause 4:
1472 "[Note: a namespace name or a class template name must be unique
1473 in its declarative region (7.3.2, clause 14). ]" */
1474 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1475 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1476 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1477 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1478 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1479 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1481 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1482 && TREE_CODE (newdecl
) != TYPE_DECL
)
1483 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1484 && TREE_CODE (olddecl
) != TYPE_DECL
))
1486 /* We do nothing special here, because C++ does such nasty
1487 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1488 get shadowed, and know that if we need to find a TYPE_DECL
1489 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1490 slot of the identifier. */
1494 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1495 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1496 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1497 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1501 error ("%q#D redeclared as different kind of symbol", newdecl
);
1502 if (TREE_CODE (olddecl
) == TREE_LIST
)
1503 olddecl
= TREE_VALUE (olddecl
);
1504 inform (DECL_SOURCE_LOCATION (olddecl
),
1505 "previous declaration %q#D", olddecl
);
1507 return error_mark_node
;
1509 else if (!types_match
)
1511 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1512 /* These are certainly not duplicate declarations; they're
1513 from different scopes. */
1516 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1518 /* The name of a class template may not be declared to refer to
1519 any other template, class, function, object, namespace, value,
1520 or type in the same scope. */
1521 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1522 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1524 error ("conflicting declaration of template %q#D", newdecl
);
1525 inform (DECL_SOURCE_LOCATION (olddecl
),
1526 "previous declaration %q#D", olddecl
);
1527 return error_mark_node
;
1529 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1530 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1531 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1532 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1533 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1534 DECL_TEMPLATE_PARMS (olddecl
))
1535 /* Template functions can be disambiguated by
1537 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1538 TREE_TYPE (TREE_TYPE (olddecl
))))
1540 error ("ambiguating new declaration %q#D", newdecl
);
1541 inform (DECL_SOURCE_LOCATION (olddecl
),
1542 "old declaration %q#D", olddecl
);
1546 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1548 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1550 error ("conflicting declaration of C function %q#D",
1552 inform (DECL_SOURCE_LOCATION (olddecl
),
1553 "previous declaration %q#D", olddecl
);
1556 /* For function versions, params and types match, but they
1557 are not ambiguous. */
1558 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1559 && !DECL_FUNCTION_VERSIONED (olddecl
))
1560 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1561 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1563 error ("ambiguating new declaration of %q#D", newdecl
);
1564 inform (DECL_SOURCE_LOCATION (olddecl
),
1565 "old declaration %q#D", olddecl
);
1566 return error_mark_node
;
1573 error ("conflicting declaration %q#D", newdecl
);
1574 inform (DECL_SOURCE_LOCATION (olddecl
),
1575 "previous declaration as %q#D", olddecl
);
1576 return error_mark_node
;
1579 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1580 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1581 && (!DECL_TEMPLATE_INFO (newdecl
)
1582 || (DECL_TI_TEMPLATE (newdecl
)
1583 != DECL_TI_TEMPLATE (olddecl
))))
1584 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1585 && (!DECL_TEMPLATE_INFO (olddecl
)
1586 || (DECL_TI_TEMPLATE (olddecl
)
1587 != DECL_TI_TEMPLATE (newdecl
))))))
1588 /* It's OK to have a template specialization and a non-template
1589 with the same type, or to have specializations of two
1590 different templates with the same type. Note that if one is a
1591 specialization, and the other is an instantiation of the same
1592 template, that we do not exit at this point. That situation
1593 can occur if we instantiate a template class, and then
1594 specialize one of its methods. This situation is valid, but
1595 the declarations must be merged in the usual way. */
1597 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1598 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1599 && !DECL_USE_TEMPLATE (newdecl
))
1600 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1601 && !DECL_USE_TEMPLATE (olddecl
))))
1602 /* One of the declarations is a template instantiation, and the
1603 other is not a template at all. That's OK. */
1605 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1607 /* In [namespace.alias] we have:
1609 In a declarative region, a namespace-alias-definition can be
1610 used to redefine a namespace-alias declared in that declarative
1611 region to refer only to the namespace to which it already
1614 Therefore, if we encounter a second alias directive for the same
1615 alias, we can just ignore the second directive. */
1616 if (DECL_NAMESPACE_ALIAS (newdecl
)
1617 && (DECL_NAMESPACE_ALIAS (newdecl
)
1618 == DECL_NAMESPACE_ALIAS (olddecl
)))
1620 /* [namespace.alias]
1622 A namespace-name or namespace-alias shall not be declared as
1623 the name of any other entity in the same declarative region.
1624 A namespace-name defined at global scope shall not be
1625 declared as the name of any other entity in any global scope
1627 error ("conflicting declaration of namespace %qD", newdecl
);
1628 inform (DECL_SOURCE_LOCATION (olddecl
),
1629 "previous declaration of namespace %qD here", olddecl
);
1630 return error_mark_node
;
1634 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1637 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1638 if (DECL_NAME (olddecl
) != NULL_TREE
)
1639 inform (input_location
,
1640 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1641 ? G_("%q+#D previously defined here")
1642 : G_("%q+#D previously declared here"), olddecl
);
1643 return error_mark_node
;
1645 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1646 && DECL_INITIAL (olddecl
) != NULL_TREE
1647 && !prototype_p (TREE_TYPE (olddecl
))
1648 && prototype_p (TREE_TYPE (newdecl
)))
1650 /* Prototype decl follows defn w/o prototype. */
1651 warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1652 "prototype specified for %q#D", newdecl
);
1653 inform (DECL_SOURCE_LOCATION (olddecl
),
1654 "previous non-prototype definition here");
1656 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1657 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1660 If two declarations of the same function or object
1661 specify different linkage-specifications ..., the program
1662 is ill-formed.... Except for functions with C++ linkage,
1663 a function declaration without a linkage specification
1664 shall not precede the first linkage specification for
1665 that function. A function can be declared without a
1666 linkage specification after an explicit linkage
1667 specification has been seen; the linkage explicitly
1668 specified in the earlier declaration is not affected by
1669 such a function declaration.
1671 DR 563 raises the question why the restrictions on
1672 functions should not also apply to objects. Older
1673 versions of G++ silently ignore the linkage-specification
1681 which is clearly wrong. Therefore, we now treat objects
1683 if (current_lang_depth () == 0)
1685 /* There is no explicit linkage-specification, so we use
1686 the linkage from the previous declaration. */
1687 if (!DECL_LANG_SPECIFIC (newdecl
))
1688 retrofit_lang_decl (newdecl
);
1689 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1693 error ("conflicting declaration of %q#D with %qL linkage",
1694 newdecl
, DECL_LANGUAGE (newdecl
));
1695 inform (DECL_SOURCE_LOCATION (olddecl
),
1696 "previous declaration with %qL linkage",
1697 DECL_LANGUAGE (olddecl
));
1701 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1703 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1705 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1706 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1709 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1710 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1712 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
1713 && CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (newdecl
)))
1716 Default arguments for a member function of a class template
1717 shall be specified on the initial declaration of the member
1718 function within the class template. */
1719 for (; t2
&& t2
!= void_list_node
; t2
= TREE_CHAIN (t2
))
1720 if (TREE_PURPOSE (t2
))
1722 permerror (input_location
,
1723 "redeclaration of %q#D may not have default "
1724 "arguments", newdecl
);
1730 for (; t1
&& t1
!= void_list_node
;
1731 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1732 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1734 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1737 if (permerror (input_location
,
1738 "default argument given for parameter "
1739 "%d of %q#D", i
, newdecl
))
1740 permerror (DECL_SOURCE_LOCATION (olddecl
),
1741 "previous specification in %q#D here",
1746 error ("default argument given for parameter %d "
1747 "of %q#D", i
, newdecl
);
1748 inform (DECL_SOURCE_LOCATION (olddecl
),
1749 "previous specification in %q#D here",
1757 /* Do not merge an implicit typedef with an explicit one. In:
1761 typedef class A A __attribute__ ((foo));
1763 the attribute should apply only to the typedef. */
1764 if (TREE_CODE (olddecl
) == TYPE_DECL
1765 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1766 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1769 /* If new decl is `static' and an `extern' was seen previously,
1771 warn_extern_redeclared_static (newdecl
, olddecl
);
1773 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1774 return error_mark_node
;
1776 /* We have committed to returning 1 at this point. */
1777 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1779 /* Now that functions must hold information normally held
1780 by field decls, there is extra work to do so that
1781 declaration information does not get destroyed during
1783 if (DECL_VINDEX (olddecl
))
1784 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1785 if (DECL_CONTEXT (olddecl
))
1786 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1787 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1788 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1789 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1790 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1791 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1792 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1793 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1794 SET_OVERLOADED_OPERATOR_CODE
1795 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1796 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1798 /* Optionally warn about more than one declaration for the same
1799 name, but don't warn about a function declaration followed by a
1801 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1802 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1803 /* Don't warn about extern decl followed by definition. */
1804 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1805 /* Don't warn about friends, let add_friend take care of it. */
1806 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1807 /* Don't warn about declaration followed by specialization. */
1808 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1809 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1811 if (warning (OPT_Wredundant_decls
,
1812 "redundant redeclaration of %qD in same scope",
1814 inform (DECL_SOURCE_LOCATION (olddecl
),
1815 "previous declaration of %qD", olddecl
);
1818 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1819 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1821 if (DECL_DELETED_FN (newdecl
))
1823 error ("deleted definition of %qD", newdecl
);
1824 inform (DECL_SOURCE_LOCATION (olddecl
),
1825 "previous declaration of %qD", olddecl
);
1827 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1831 /* Deal with C++: must preserve virtual function table size. */
1832 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1834 tree newtype
= TREE_TYPE (newdecl
);
1835 tree oldtype
= TREE_TYPE (olddecl
);
1837 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1838 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1839 CLASSTYPE_FRIEND_CLASSES (newtype
)
1840 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1842 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1845 /* Copy all the DECL_... slots specified in the new decl
1846 except for any that we copy here from the old type. */
1847 DECL_ATTRIBUTES (newdecl
)
1848 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1850 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1854 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1855 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1856 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1857 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1858 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1859 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1861 DECL_ATTRIBUTES (old_result
)
1862 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1864 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1866 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1867 && DECL_INITIAL (new_result
))
1869 if (DECL_INITIAL (old_result
))
1870 DECL_UNINLINABLE (old_result
) = 1;
1872 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1873 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1874 DECL_NOT_REALLY_EXTERN (old_result
)
1875 = DECL_NOT_REALLY_EXTERN (new_result
);
1876 DECL_INTERFACE_KNOWN (old_result
)
1877 = DECL_INTERFACE_KNOWN (new_result
);
1878 DECL_DECLARED_INLINE_P (old_result
)
1879 = DECL_DECLARED_INLINE_P (new_result
);
1880 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1881 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1886 DECL_DECLARED_INLINE_P (old_result
)
1887 |= DECL_DECLARED_INLINE_P (new_result
);
1888 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1889 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1890 check_redeclaration_exception_specification (newdecl
, olddecl
);
1894 /* If the new declaration is a definition, update the file and
1895 line information on the declaration, and also make
1896 the old declaration the same definition. */
1897 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1899 DECL_SOURCE_LOCATION (olddecl
)
1900 = DECL_SOURCE_LOCATION (old_result
)
1901 = DECL_SOURCE_LOCATION (newdecl
);
1902 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1903 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1906 DECL_ARGUMENTS (old_result
)
1907 = DECL_ARGUMENTS (new_result
);
1908 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1909 parm
= DECL_CHAIN (parm
))
1910 DECL_CONTEXT (parm
) = old_result
;
1919 /* Automatically handles default parameters. */
1920 tree oldtype
= TREE_TYPE (olddecl
);
1923 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1924 maybe_instantiate_noexcept (olddecl
);
1926 /* Merge the data types specified in the two decls. */
1927 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1929 /* If merge_types produces a non-typedef type, just use the old type. */
1930 if (TREE_CODE (newdecl
) == TYPE_DECL
1931 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1934 if (VAR_P (newdecl
))
1936 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1937 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1938 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1939 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1940 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1941 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1943 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1944 if (DECL_LANG_SPECIFIC (olddecl
)
1945 && CP_DECL_THREADPRIVATE_P (olddecl
))
1947 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1948 if (!DECL_LANG_SPECIFIC (newdecl
))
1949 retrofit_lang_decl (newdecl
);
1951 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1952 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1956 /* Do this after calling `merge_types' so that default
1957 parameters don't confuse us. */
1958 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1959 check_redeclaration_exception_specification (newdecl
, olddecl
);
1960 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1962 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1963 check_default_args (newdecl
);
1965 /* Lay the type out, unless already done. */
1966 if (! same_type_p (newtype
, oldtype
)
1967 && TREE_TYPE (newdecl
) != error_mark_node
1968 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1969 layout_type (TREE_TYPE (newdecl
));
1971 if ((VAR_P (newdecl
)
1972 || TREE_CODE (newdecl
) == PARM_DECL
1973 || TREE_CODE (newdecl
) == RESULT_DECL
1974 || TREE_CODE (newdecl
) == FIELD_DECL
1975 || TREE_CODE (newdecl
) == TYPE_DECL
)
1976 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1977 layout_decl (newdecl
, 0);
1979 /* Merge the type qualifiers. */
1980 if (TREE_READONLY (newdecl
))
1981 TREE_READONLY (olddecl
) = 1;
1982 if (TREE_THIS_VOLATILE (newdecl
))
1983 TREE_THIS_VOLATILE (olddecl
) = 1;
1984 if (TREE_NOTHROW (newdecl
))
1985 TREE_NOTHROW (olddecl
) = 1;
1987 /* Merge deprecatedness. */
1988 if (TREE_DEPRECATED (newdecl
))
1989 TREE_DEPRECATED (olddecl
) = 1;
1991 /* Preserve function specific target and optimization options */
1992 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1994 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
1995 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
1996 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
1997 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
1999 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2000 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2001 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2002 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2005 /* Merge the initialization information. */
2006 if (DECL_INITIAL (newdecl
) == NULL_TREE
2007 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2009 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2010 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2011 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2013 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2014 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2018 /* Merge the section attribute.
2019 We want to issue an error if the sections conflict but that must be
2020 done later in decl_attributes since we are called before attributes
2022 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2023 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2025 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2027 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2028 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2029 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2030 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2031 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2032 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2033 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2034 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2035 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2036 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2037 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2038 /* Keep the old RTL. */
2039 COPY_DECL_RTL (olddecl
, newdecl
);
2041 else if (VAR_P (newdecl
)
2042 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2044 /* Keep the old RTL. We cannot keep the old RTL if the old
2045 declaration was for an incomplete object and the new
2046 declaration is not since many attributes of the RTL will
2048 COPY_DECL_RTL (olddecl
, newdecl
);
2051 /* If cannot merge, then use the new type and qualifiers,
2052 and don't preserve the old rtl. */
2055 /* Clean out any memory we had of the old declaration. */
2056 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2058 TREE_VALUE (oldstatic
) = error_mark_node
;
2060 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2061 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2062 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2063 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2066 /* Merge the storage class information. */
2067 merge_weak (newdecl
, olddecl
);
2069 if (DECL_ONE_ONLY (olddecl
))
2070 DECL_COMDAT_GROUP (newdecl
) = DECL_COMDAT_GROUP (olddecl
);
2072 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2073 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2074 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2075 if (! DECL_EXTERNAL (olddecl
))
2076 DECL_EXTERNAL (newdecl
) = 0;
2078 new_template_info
= NULL_TREE
;
2079 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2081 bool new_redefines_gnu_inline
= false;
2083 if (new_defines_function
2084 && ((DECL_INTERFACE_KNOWN (olddecl
)
2085 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2086 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2087 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2088 == FUNCTION_DECL
))))
2092 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2093 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2095 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2098 if (!new_redefines_gnu_inline
)
2100 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2101 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2102 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2104 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2105 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2106 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2108 /* If the OLDDECL is an instantiation and/or specialization,
2109 then the NEWDECL must be too. But, it may not yet be marked
2110 as such if the caller has created NEWDECL, but has not yet
2111 figured out that it is a redeclaration. */
2112 if (!DECL_USE_TEMPLATE (newdecl
))
2113 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2115 /* Don't really know how much of the language-specific
2116 values we should copy from old to new. */
2117 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2118 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2119 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2120 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2122 if (LANG_DECL_HAS_MIN (newdecl
))
2124 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2125 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2126 if (DECL_TEMPLATE_INFO (newdecl
))
2127 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2128 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2130 /* Only functions have these fields. */
2131 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2133 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2134 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2135 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2136 && DECL_HIDDEN_FRIEND_P (olddecl
)
2137 && newdecl_is_friend
);
2138 DECL_BEFRIENDING_CLASSES (newdecl
)
2139 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2140 DECL_BEFRIENDING_CLASSES (olddecl
));
2141 /* DECL_THUNKS is only valid for virtual functions,
2142 otherwise it is a DECL_FRIEND_CONTEXT. */
2143 if (DECL_VIRTUAL_P (newdecl
))
2144 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2146 /* Only variables have this field. */
2147 else if (VAR_P (newdecl
)
2148 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2149 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2152 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2156 /* Merge parameter attributes. */
2157 tree oldarg
, newarg
;
2158 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2159 newarg
= DECL_ARGUMENTS(newdecl
);
2161 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2162 DECL_ATTRIBUTES (newarg
)
2163 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2164 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2167 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2168 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2170 /* If newdecl is not a specialization, then it is not a
2171 template-related function at all. And that means that we
2172 should have exited above, returning 0. */
2173 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2175 if (DECL_ODR_USED (olddecl
))
2176 /* From [temp.expl.spec]:
2178 If a template, a member template or the member of a class
2179 template is explicitly specialized then that
2180 specialization shall be declared before the first use of
2181 that specialization that would cause an implicit
2182 instantiation to take place, in every translation unit in
2183 which such a use occurs. */
2184 error ("explicit specialization of %qD after first use",
2187 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2189 /* Don't propagate visibility from the template to the
2190 specialization here. We'll do that in determine_visibility if
2192 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2194 /* [temp.expl.spec/14] We don't inline explicit specialization
2195 just because the primary template says so. */
2197 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2198 the always_inline attribute. */
2199 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2200 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2202 if (DECL_DECLARED_INLINE_P (newdecl
))
2203 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2205 DECL_ATTRIBUTES (newdecl
)
2206 = remove_attribute ("always_inline",
2207 DECL_ATTRIBUTES (newdecl
));
2210 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2212 /* Never inline re-defined extern inline functions.
2213 FIXME: this could be better handled by keeping both
2214 function as separate declarations. */
2215 DECL_UNINLINABLE (newdecl
) = 1;
2219 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2220 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2222 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2224 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2225 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2227 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2228 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2229 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2230 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2233 /* Preserve abstractness on cloned [cd]tors. */
2234 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
2236 /* Update newdecl's parms to point at olddecl. */
2237 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2238 parm
= DECL_CHAIN (parm
))
2239 DECL_CONTEXT (parm
) = olddecl
;
2243 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2244 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2245 COPY_DECL_RTL (newdecl
, olddecl
);
2247 if (! types_match
|| new_defines_function
)
2249 /* These need to be copied so that the names are available.
2250 Note that if the types do match, we'll preserve inline
2251 info and other bits, but if not, we won't. */
2252 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2253 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2255 /* If redeclaring a builtin function, it stays built in
2256 if newdecl is a gnu_inline definition, or if newdecl is just
2258 if (DECL_BUILT_IN (olddecl
)
2259 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2261 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2262 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2263 /* If we're keeping the built-in definition, keep the rtl,
2264 regardless of declaration matches. */
2265 COPY_DECL_RTL (olddecl
, newdecl
);
2266 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2268 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2271 /* If a compatible prototype of these builtin functions
2272 is seen, assume the runtime implements it with the
2273 expected semantics. */
2274 case BUILT_IN_STPCPY
:
2275 if (builtin_decl_explicit_p (fncode
))
2276 set_builtin_decl_implicit_p (fncode
, true);
2283 if (new_defines_function
)
2284 /* If defining a function declared with other language
2285 linkage, use the previously declared language linkage. */
2286 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2287 else if (types_match
)
2289 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2290 /* Don't clear out the arguments if we're just redeclaring a
2292 if (DECL_ARGUMENTS (olddecl
))
2293 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2296 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2297 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2299 /* Now preserve various other info from the definition. */
2300 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2301 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2302 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2303 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2305 /* Warn about conflicting visibility specifications. */
2306 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2307 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2308 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2310 warning_at (input_location
, OPT_Wattributes
,
2311 "%q+D: visibility attribute ignored because it", newdecl
);
2312 warning_at (DECL_SOURCE_LOCATION (olddecl
), OPT_Wattributes
,
2313 "conflicts with previous declaration here");
2315 /* Choose the declaration which specified visibility. */
2316 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2318 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2319 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2321 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2322 so keep this behavior. */
2323 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2325 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2326 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2328 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2329 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2331 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2332 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2334 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2335 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2336 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2338 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2339 with that from NEWDECL below. */
2340 if (DECL_LANG_SPECIFIC (olddecl
))
2342 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2343 != DECL_LANG_SPECIFIC (newdecl
));
2344 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2347 /* Merge the USED information. */
2348 if (TREE_USED (olddecl
))
2349 TREE_USED (newdecl
) = 1;
2350 else if (TREE_USED (newdecl
))
2351 TREE_USED (olddecl
) = 1;
2352 if (VAR_P (newdecl
))
2354 if (DECL_READ_P (olddecl
))
2355 DECL_READ_P (newdecl
) = 1;
2356 else if (DECL_READ_P (newdecl
))
2357 DECL_READ_P (olddecl
) = 1;
2359 if (DECL_PRESERVE_P (olddecl
))
2360 DECL_PRESERVE_P (newdecl
) = 1;
2361 else if (DECL_PRESERVE_P (newdecl
))
2362 DECL_PRESERVE_P (olddecl
) = 1;
2364 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2365 to olddecl and deleted. */
2366 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2367 && DECL_FUNCTION_VERSIONED (olddecl
))
2369 /* Set the flag for newdecl so that it gets copied to olddecl. */
2370 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2371 /* newdecl will be purged after copying to olddecl and is no longer
2373 delete_function_version (newdecl
);
2376 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2380 function_size
= sizeof (struct tree_decl_common
);
2382 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2383 (char *) newdecl
+ sizeof (struct tree_common
),
2384 function_size
- sizeof (struct tree_common
));
2386 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2387 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2388 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2389 if (new_template_info
)
2390 /* If newdecl is a template instantiation, it is possible that
2391 the following sequence of events has occurred:
2393 o A friend function was declared in a class template. The
2394 class template was instantiated.
2396 o The instantiation of the friend declaration was
2397 recorded on the instantiation list, and is newdecl.
2399 o Later, however, instantiate_class_template called pushdecl
2400 on the newdecl to perform name injection. But, pushdecl in
2401 turn called duplicate_decls when it discovered that another
2402 declaration of a global function with the same name already
2405 o Here, in duplicate_decls, we decided to clobber newdecl.
2407 If we're going to do that, we'd better make sure that
2408 olddecl, and not newdecl, is on the list of
2409 instantiations so that if we try to do the instantiation
2410 again we won't get the clobbered declaration. */
2411 reregister_specialization (newdecl
,
2417 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2418 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2419 (char *) newdecl
+ sizeof (struct tree_common
),
2420 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2421 switch (TREE_CODE (olddecl
))
2431 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2432 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2433 size
- sizeof (struct tree_decl_common
)
2434 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2438 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2439 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2440 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2441 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2445 DECL_UID (olddecl
) = olddecl_uid
;
2447 DECL_FRIEND_P (olddecl
) = 1;
2450 DECL_ANTICIPATED (olddecl
) = 1;
2451 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2454 /* NEWDECL contains the merged attribute lists.
2455 Update OLDDECL to be the same. */
2456 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2458 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2459 so that encode_section_info has a chance to look at the new decl
2460 flags and attributes. */
2461 if (DECL_RTL_SET_P (olddecl
)
2462 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2464 && TREE_STATIC (olddecl
))))
2465 make_decl_rtl (olddecl
);
2467 /* The NEWDECL will no longer be needed. Because every out-of-class
2468 declaration of a member results in a call to duplicate_decls,
2469 freeing these nodes represents in a significant savings. */
2475 /* Return zero if the declaration NEWDECL is valid
2476 when the declaration OLDDECL (assumed to be for the same name)
2477 has already been seen.
2478 Otherwise return an error message format string with a %s
2479 where the identifier should go. */
2482 redeclaration_error_message (tree newdecl
, tree olddecl
)
2484 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2486 /* Because C++ can put things into name space for free,
2487 constructs like "typedef struct foo { ... } foo"
2488 would look like an erroneous redeclaration. */
2489 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2492 return G_("redefinition of %q#D");
2494 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2496 /* If this is a pure function, its olddecl will actually be
2497 the original initialization to `0' (which we force to call
2498 abort()). Don't complain about redefinition in this case. */
2499 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2500 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2503 /* If both functions come from different namespaces, this is not
2504 a redeclaration - this is a conflict with a used function. */
2505 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2506 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2507 && ! decls_match (olddecl
, newdecl
))
2508 return G_("%qD conflicts with used function");
2510 /* We'll complain about linkage mismatches in
2511 warn_extern_redeclared_static. */
2513 /* Defining the same name twice is no good. */
2514 if (DECL_INITIAL (olddecl
) != NULL_TREE
2515 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2517 if (DECL_NAME (olddecl
) == NULL_TREE
)
2518 return G_("%q#D not declared in class");
2519 else if (!GNU_INLINE_P (olddecl
)
2520 || GNU_INLINE_P (newdecl
))
2521 return G_("redefinition of %q#D");
2524 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2526 bool olda
= GNU_INLINE_P (olddecl
);
2527 bool newa
= GNU_INLINE_P (newdecl
);
2532 return G_("%q+D redeclared inline with "
2533 "%<gnu_inline%> attribute");
2535 return G_("%q+D redeclared inline without "
2536 "%<gnu_inline%> attribute");
2540 check_abi_tag_redeclaration
2541 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2542 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2546 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2550 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2552 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2553 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2554 return G_("redefinition of %q#D");
2558 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2559 || (DECL_TEMPLATE_RESULT (newdecl
)
2560 == DECL_TEMPLATE_RESULT (olddecl
)))
2563 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2564 if (DECL_TEMPLATE_INFO (nt
))
2565 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2566 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2567 if (DECL_TEMPLATE_INFO (ot
))
2568 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2569 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2570 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2571 return G_("redefinition of %q#D");
2573 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2575 bool olda
= GNU_INLINE_P (ot
);
2576 bool newa
= GNU_INLINE_P (nt
);
2581 return G_("%q+D redeclared inline with "
2582 "%<gnu_inline%> attribute");
2584 return G_("%q+D redeclared inline without "
2585 "%<gnu_inline%> attribute");
2589 /* Core issue #226 (C++0x):
2591 If a friend function template declaration specifies a
2592 default template-argument, that declaration shall be a
2593 definition and shall be the only declaration of the
2594 function template in the translation unit. */
2595 if ((cxx_dialect
!= cxx98
)
2596 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2597 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2598 /*is_primary=*/true,
2599 /*is_partial=*/false,
2600 /*is_friend_decl=*/2))
2601 return G_("redeclaration of friend %q#D "
2602 "may not have default template arguments");
2606 else if (VAR_P (newdecl
)
2607 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2608 && (! DECL_LANG_SPECIFIC (olddecl
)
2609 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2610 || DECL_THREAD_LOCAL_P (newdecl
)))
2612 /* Only variables can be thread-local, and all declarations must
2613 agree on this property. */
2614 if (DECL_THREAD_LOCAL_P (newdecl
))
2615 return G_("thread-local declaration of %q#D follows "
2616 "non-thread-local declaration");
2618 return G_("non-thread-local declaration of %q#D follows "
2619 "thread-local declaration");
2621 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2623 /* The objects have been declared at namespace scope. If either
2624 is a member of an anonymous union, then this is an invalid
2625 redeclaration. For example:
2631 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2632 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2633 return G_("redeclaration of %q#D");
2634 /* If at least one declaration is a reference, there is no
2635 conflict. For example:
2641 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2643 /* Reject two definitions. */
2644 return G_("redefinition of %q#D");
2648 /* Objects declared with block scope: */
2649 /* Reject two definitions, and reject a definition
2650 together with an external reference. */
2651 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2652 return G_("redeclaration of %q#D");
2657 /* Hash and equality functions for the named_label table. */
2660 named_label_entry_hash (const void *data
)
2662 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2663 return DECL_UID (ent
->label_decl
);
2667 named_label_entry_eq (const void *a
, const void *b
)
2669 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2670 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2671 return ent_a
->label_decl
== ent_b
->label_decl
;
2674 /* Create a new label, named ID. */
2677 make_label_decl (tree id
, int local_p
)
2679 struct named_label_entry
*ent
;
2683 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2685 DECL_CONTEXT (decl
) = current_function_decl
;
2686 DECL_MODE (decl
) = VOIDmode
;
2687 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2689 /* Say where one reference is to the label, for the sake of the
2690 error if it is not defined. */
2691 DECL_SOURCE_LOCATION (decl
) = input_location
;
2693 /* Record the fact that this identifier is bound to this label. */
2694 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2696 /* Create the label htab for the function on demand. */
2698 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2699 named_label_entry_eq
, NULL
);
2701 /* Record this label on the list of labels used in this function.
2702 We do this before calling make_label_decl so that we get the
2703 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2704 ent
= ggc_alloc_cleared_named_label_entry ();
2705 ent
->label_decl
= decl
;
2707 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2708 gcc_assert (*slot
== NULL
);
2714 /* Look for a label named ID in the current function. If one cannot
2715 be found, create one. (We keep track of used, but undefined,
2716 labels, and complain about them at the end of a function.) */
2719 lookup_label_1 (tree id
)
2723 /* You can't use labels at global scope. */
2724 if (current_function_decl
== NULL_TREE
)
2726 error ("label %qE referenced outside of any function", id
);
2730 /* See if we've already got this label. */
2731 decl
= IDENTIFIER_LABEL_VALUE (id
);
2732 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2735 decl
= make_label_decl (id
, /*local_p=*/0);
2739 /* Wrapper for lookup_label_1. */
2742 lookup_label (tree id
)
2745 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2746 ret
= lookup_label_1 (id
);
2747 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2751 /* Declare a local label named ID. */
2754 declare_local_label (tree id
)
2757 cp_label_binding bind
;
2759 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2760 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2761 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2763 decl
= make_label_decl (id
, /*local_p=*/1);
2765 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2770 /* Returns nonzero if it is ill-formed to jump past the declaration of
2771 DECL. Returns 2 if it's also a real problem. */
2774 decl_jump_unsafe (tree decl
)
2776 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2777 with automatic storage duration is not in scope to a point where it is
2778 in scope is ill-formed unless the variable has scalar type, class type
2779 with a trivial default constructor and a trivial destructor, a
2780 cv-qualified version of one of these types, or an array of one of the
2781 preceding types and is declared without an initializer (8.5). */
2782 tree type
= TREE_TYPE (decl
);
2784 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2785 || type
== error_mark_node
)
2788 type
= strip_array_types (type
);
2790 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2793 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
2799 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2802 identify_goto (tree decl
, const location_t
*locus
)
2805 permerror (input_location
, "jump to label %qD", decl
);
2807 permerror (input_location
, "jump to case label");
2809 permerror (*locus
, " from here");
2812 /* Check that a single previously seen jump to a newly defined label
2813 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2814 the jump context; NAMES are the names in scope in LEVEL at the jump
2815 context; LOCUS is the source position of the jump or 0. Returns
2816 true if all is well. */
2819 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2820 bool exited_omp
, const location_t
*locus
)
2822 cp_binding_level
*b
;
2823 bool identified
= false, saw_eh
= false, saw_omp
= false;
2827 identify_goto (decl
, locus
);
2828 error (" exits OpenMP structured block");
2829 identified
= saw_omp
= true;
2832 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2834 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2836 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2837 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2838 : TREE_CHAIN (new_decls
)))
2840 int problem
= decl_jump_unsafe (new_decls
);
2846 identify_goto (decl
, locus
);
2850 error (" crosses initialization of %q+#D", new_decls
);
2852 permerror (input_location
, " enters scope of %q+#D which has "
2853 "non-trivial destructor", new_decls
);
2858 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2862 identify_goto (decl
, locus
);
2865 if (b
->kind
== sk_try
)
2866 error (" enters try block");
2868 error (" enters catch block");
2871 if (b
->kind
== sk_omp
&& !saw_omp
)
2875 identify_goto (decl
, locus
);
2878 error (" enters OpenMP structured block");
2887 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2889 check_previous_goto_1 (decl
, use
->binding_level
,
2890 use
->names_in_scope
, use
->in_omp_scope
,
2891 &use
->o_goto_locus
);
2895 check_switch_goto (cp_binding_level
* level
)
2897 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2900 /* Check that a new jump to a label DECL is OK. Called by
2901 finish_goto_stmt. */
2904 check_goto (tree decl
)
2906 struct named_label_entry
*ent
, dummy
;
2907 bool saw_catch
= false, identified
= false;
2911 /* We can't know where a computed goto is jumping.
2912 So we assume that it's OK. */
2913 if (TREE_CODE (decl
) != LABEL_DECL
)
2916 /* We didn't record any information about this label when we created it,
2917 and there's not much point since it's trivial to analyze as a return. */
2918 if (decl
== cdtor_label
)
2921 dummy
.label_decl
= decl
;
2922 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2923 gcc_assert (ent
!= NULL
);
2925 /* If the label hasn't been defined yet, defer checking. */
2926 if (! DECL_INITIAL (decl
))
2928 struct named_label_use_entry
*new_use
;
2930 /* Don't bother creating another use if the last goto had the
2931 same data, and will therefore create the same set of errors. */
2933 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2936 new_use
= ggc_alloc_named_label_use_entry ();
2937 new_use
->binding_level
= current_binding_level
;
2938 new_use
->names_in_scope
= current_binding_level
->names
;
2939 new_use
->o_goto_locus
= input_location
;
2940 new_use
->in_omp_scope
= false;
2942 new_use
->next
= ent
->uses
;
2943 ent
->uses
= new_use
;
2947 if (ent
->in_try_scope
|| ent
->in_catch_scope
2948 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
2950 permerror (input_location
, "jump to label %q+D", decl
);
2951 permerror (input_location
, " from here");
2955 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
2957 int u
= decl_jump_unsafe (bad
);
2959 if (u
> 1 && DECL_ARTIFICIAL (bad
))
2961 /* Can't skip init of __exception_info. */
2962 error_at (DECL_SOURCE_LOCATION (bad
), " enters catch block");
2966 error (" skips initialization of %q+#D", bad
);
2968 permerror (input_location
, " enters scope of %q+#D which has "
2969 "non-trivial destructor", bad
);
2972 if (ent
->in_try_scope
)
2973 error (" enters try block");
2974 else if (ent
->in_catch_scope
&& !saw_catch
)
2975 error (" enters catch block");
2977 if (ent
->in_omp_scope
)
2978 error (" enters OpenMP structured block");
2979 else if (flag_openmp
)
2981 cp_binding_level
*b
;
2982 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2984 if (b
== ent
->binding_level
)
2986 if (b
->kind
== sk_omp
)
2990 permerror (input_location
, "jump to label %q+D", decl
);
2991 permerror (input_location
, " from here");
2994 error (" exits OpenMP structured block");
3001 /* Check that a return is ok wrt OpenMP structured blocks.
3002 Called by finish_return_stmt. Returns true if all is well. */
3005 check_omp_return (void)
3007 cp_binding_level
*b
;
3008 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3009 if (b
->kind
== sk_omp
)
3011 error ("invalid exit from OpenMP structured block");
3014 else if (b
->kind
== sk_function_parms
)
3019 /* Define a label, specifying the location in the source file.
3020 Return the LABEL_DECL node for the label. */
3023 define_label_1 (location_t location
, tree name
)
3025 struct named_label_entry
*ent
, dummy
;
3026 cp_binding_level
*p
;
3029 decl
= lookup_label (name
);
3031 dummy
.label_decl
= decl
;
3032 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
3033 gcc_assert (ent
!= NULL
);
3035 /* After labels, make any new cleanups in the function go into their
3036 own new (temporary) binding contour. */
3037 for (p
= current_binding_level
;
3038 p
->kind
!= sk_function_parms
;
3040 p
->more_cleanups_ok
= 0;
3042 if (name
== get_identifier ("wchar_t"))
3043 permerror (input_location
, "label named wchar_t");
3045 if (DECL_INITIAL (decl
) != NULL_TREE
)
3047 error ("duplicate label %qD", decl
);
3048 return error_mark_node
;
3052 struct named_label_use_entry
*use
;
3054 /* Mark label as having been defined. */
3055 DECL_INITIAL (decl
) = error_mark_node
;
3056 /* Say where in the source. */
3057 DECL_SOURCE_LOCATION (decl
) = location
;
3059 ent
->binding_level
= current_binding_level
;
3060 ent
->names_in_scope
= current_binding_level
->names
;
3062 for (use
= ent
->uses
; use
; use
= use
->next
)
3063 check_previous_goto (decl
, use
);
3070 /* Wrapper for define_label_1. */
3073 define_label (location_t location
, tree name
)
3076 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3077 ret
= define_label_1 (location
, name
);
3078 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3085 cp_binding_level
*level
;
3086 struct cp_switch
*next
;
3087 /* The SWITCH_STMT being built. */
3089 /* A splay-tree mapping the low element of a case range to the high
3090 element, or NULL_TREE if there is no high element. Used to
3091 determine whether or not a new case label duplicates an old case
3092 label. We need a tree, rather than simply a hash table, because
3093 of the GNU case range extension. */
3097 /* A stack of the currently active switch statements. The innermost
3098 switch statement is on the top of the stack. There is no need to
3099 mark the stack for garbage collection because it is only active
3100 during the processing of the body of a function, and we never
3101 collect at that point. */
3103 static struct cp_switch
*switch_stack
;
3105 /* Called right after a switch-statement condition is parsed.
3106 SWITCH_STMT is the switch statement being parsed. */
3109 push_switch (tree switch_stmt
)
3111 struct cp_switch
*p
= XNEW (struct cp_switch
);
3112 p
->level
= current_binding_level
;
3113 p
->next
= switch_stack
;
3114 p
->switch_stmt
= switch_stmt
;
3115 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3122 struct cp_switch
*cs
= switch_stack
;
3123 location_t switch_location
;
3125 /* Emit warnings as needed. */
3126 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3127 if (!processing_template_decl
)
3128 c_do_switch_warnings (cs
->cases
, switch_location
,
3129 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3130 SWITCH_STMT_COND (cs
->switch_stmt
));
3132 splay_tree_delete (cs
->cases
);
3133 switch_stack
= switch_stack
->next
;
3137 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3138 condition. Note that if TYPE and VALUE are already integral we don't
3139 really do the conversion because the language-independent
3140 warning/optimization code will work better that way. */
3143 case_conversion (tree type
, tree value
)
3145 if (value
== NULL_TREE
)
3148 if (cxx_dialect
>= cxx11
3149 && (SCOPED_ENUM_P (type
)
3150 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3152 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3153 type
= type_promotes_to (type
);
3154 value
= (perform_implicit_conversion_flags
3155 (type
, value
, tf_warning_or_error
,
3156 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3158 return cxx_constant_value (value
);
3161 /* Note that we've seen a definition of a case label, and complain if this
3162 is a bad place for one. */
3165 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3168 cp_binding_level
*p
;
3171 if (processing_template_decl
)
3175 /* For templates, just add the case label; we'll do semantic
3176 analysis at instantiation-time. */
3177 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3178 return add_stmt (build_case_label (low_value
, high_value
, label
));
3181 /* Find the condition on which this switch statement depends. */
3182 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3183 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3184 cond
= TREE_VALUE (cond
);
3186 if (!check_switch_goto (switch_stack
->level
))
3187 return error_mark_node
;
3189 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3191 low_value
= case_conversion (type
, low_value
);
3192 high_value
= case_conversion (type
, high_value
);
3194 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3195 low_value
, high_value
);
3197 /* After labels, make any new cleanups in the function go into their
3198 own new (temporary) binding contour. */
3199 for (p
= current_binding_level
;
3200 p
->kind
!= sk_function_parms
;
3202 p
->more_cleanups_ok
= 0;
3207 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3210 typename_hash (const void* k
)
3213 const_tree
const t
= (const_tree
) k
;
3215 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3216 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
3221 typedef struct typename_info
{
3229 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3230 really of type `typename_info*' */
3233 typename_compare (const void * k1
, const void * k2
)
3235 const_tree
const t1
= (const_tree
) k1
;
3236 const typename_info
*const t2
= (const typename_info
*) k2
;
3238 return (DECL_NAME (TYPE_NAME (t1
)) == t2
->name
3239 && TYPE_CONTEXT (t1
) == t2
->scope
3240 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3241 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3242 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3245 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3246 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3248 Returns the new TYPENAME_TYPE. */
3250 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
3253 build_typename_type (tree context
, tree name
, tree fullname
,
3254 enum tag_types tag_type
)
3262 if (typename_htab
== NULL
)
3263 typename_htab
= htab_create_ggc (61, &typename_hash
,
3264 &typename_compare
, NULL
);
3266 ti
.scope
= FROB_CONTEXT (context
);
3268 ti
.template_id
= fullname
;
3269 ti
.enum_p
= tag_type
== enum_type
;
3270 ti
.class_p
= (tag_type
== class_type
3271 || tag_type
== record_type
3272 || tag_type
== union_type
);
3273 hash
= (htab_hash_pointer (ti
.scope
)
3274 ^ htab_hash_pointer (ti
.name
));
3276 /* See if we already have this type. */
3277 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
3282 /* Build the TYPENAME_TYPE. */
3283 t
= cxx_make_type (TYPENAME_TYPE
);
3284 TYPE_CONTEXT (t
) = ti
.scope
;
3285 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3286 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3287 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3289 /* Build the corresponding TYPE_DECL. */
3290 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3291 TYPE_NAME (TREE_TYPE (d
)) = d
;
3292 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3293 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3294 DECL_ARTIFICIAL (d
) = 1;
3296 /* Store it in the hash table. */
3299 /* TYPENAME_TYPEs must always be compared structurally, because
3300 they may or may not resolve down to another type depending on
3301 the currently open classes. */
3302 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3308 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3309 provided to name the type. Returns an appropriate type, unless an
3310 error occurs, in which case error_mark_node is returned. If we
3311 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3312 return that, rather than the _TYPE it corresponds to, in other
3313 cases we look through the type decl. If TF_ERROR is set, complain
3314 about errors, otherwise be quiet. */
3317 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3318 tsubst_flags_t complain
)
3324 if (name
== error_mark_node
3325 || context
== NULL_TREE
3326 || context
== error_mark_node
)
3327 return error_mark_node
;
3331 if (!(TYPE_LANG_SPECIFIC (name
)
3332 && (CLASSTYPE_IS_TEMPLATE (name
)
3333 || CLASSTYPE_USE_TEMPLATE (name
))))
3334 name
= TYPE_IDENTIFIER (name
);
3336 /* Create a TEMPLATE_ID_EXPR for the type. */
3337 name
= build_nt (TEMPLATE_ID_EXPR
,
3338 CLASSTYPE_TI_TEMPLATE (name
),
3339 CLASSTYPE_TI_ARGS (name
));
3341 else if (TREE_CODE (name
) == TYPE_DECL
)
3342 name
= DECL_NAME (name
);
3346 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3348 name
= TREE_OPERAND (name
, 0);
3349 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3350 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3351 else if (TREE_CODE (name
) == OVERLOAD
)
3353 if (complain
& tf_error
)
3354 error ("%qD is not a type", name
);
3355 return error_mark_node
;
3358 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3360 if (complain
& tf_error
)
3361 error ("%qD used without template parameters", name
);
3362 return error_mark_node
;
3364 gcc_assert (identifier_p (name
));
3365 gcc_assert (TYPE_P (context
));
3367 if (!MAYBE_CLASS_TYPE_P (context
))
3369 if (complain
& tf_error
)
3370 error ("%q#T is not a class", context
);
3371 return error_mark_node
;
3374 /* When the CONTEXT is a dependent type, NAME could refer to a
3375 dependent base class of CONTEXT. But look inside it anyway
3376 if CONTEXT is a currently open scope, in case it refers to a
3377 member of the current instantiation or a non-dependent base;
3378 lookup will stop when we hit a dependent base. */
3379 if (!dependent_scope_p (context
))
3380 /* We should only set WANT_TYPE when we're a nested typename type.
3381 Then we can give better diagnostics if we find a non-type. */
3382 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3386 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3387 return build_typename_type (context
, name
, fullname
, tag_type
);
3389 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3393 if (complain
& tf_error
)
3394 error (want_template
? G_("no class template named %q#T in %q#T")
3395 : G_("no type named %q#T in %q#T"), name
, context
);
3396 return error_mark_node
;
3399 /* Pull out the template from an injected-class-name (or multiple). */
3401 t
= maybe_get_template_decl_from_type_decl (t
);
3403 if (TREE_CODE (t
) == TREE_LIST
)
3405 if (complain
& tf_error
)
3407 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3408 print_candidates (t
);
3410 return error_mark_node
;
3413 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3415 if (complain
& tf_error
)
3416 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3418 return error_mark_node
;
3420 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3422 if (complain
& tf_error
)
3423 error ("%<typename %T::%D%> names %q#T, which is not a type",
3425 return error_mark_node
;
3428 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3429 return error_mark_node
;
3431 /* If we are currently parsing a template and if T is a typedef accessed
3432 through CONTEXT then we need to remember and check access of T at
3433 template instantiation time. */
3434 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3437 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3439 /*entering_scope=*/0,
3440 tf_warning_or_error
| tf_user
);
3442 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3445 maybe_record_typedef_use (t
);
3450 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3451 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3452 in which case error_mark_node is returned.
3454 If PARM_LIST is non-NULL, also make sure that the template parameter
3455 list of TEMPLATE_DECL matches.
3457 If COMPLAIN zero, don't complain about any errors that occur. */
3460 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3461 tsubst_flags_t complain
)
3467 name
= TYPE_IDENTIFIER (name
);
3468 else if (DECL_P (name
))
3469 name
= DECL_NAME (name
);
3470 gcc_assert (identifier_p (name
));
3472 if (!dependent_type_p (context
)
3473 || currently_open_class (context
))
3475 tree tmpl
= NULL_TREE
;
3477 if (MAYBE_CLASS_TYPE_P (context
))
3478 tmpl
= lookup_field (context
, name
, 0, false);
3480 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3481 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3483 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3485 if (complain
& tf_error
)
3486 error ("no class template named %q#T in %q#T", name
, context
);
3487 return error_mark_node
;
3491 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3493 if (complain
& tf_error
)
3495 error ("template parameters do not match template");
3496 error ("%q+D declared here", tmpl
);
3498 return error_mark_node
;
3501 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3503 return error_mark_node
;
3508 /* Build the UNBOUND_CLASS_TEMPLATE. */
3509 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3510 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3511 TREE_TYPE (t
) = NULL_TREE
;
3512 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3514 /* Build the corresponding TEMPLATE_DECL. */
3515 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3516 TYPE_NAME (TREE_TYPE (d
)) = d
;
3517 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3518 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3519 DECL_ARTIFICIAL (d
) = 1;
3520 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3527 /* Push the declarations of builtin types into the namespace.
3528 RID_INDEX is the index of the builtin type in the array
3529 RID_POINTERS. NAME is the name used when looking up the builtin
3530 type. TYPE is the _TYPE node for the builtin type. */
3533 record_builtin_type (enum rid rid_index
,
3537 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3538 tree tdecl
= NULL_TREE
;
3540 if ((int) rid_index
< (int) RID_MAX
)
3541 rname
= ridpointers
[(int) rid_index
];
3543 tname
= get_identifier (name
);
3545 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3546 eliminated. Built-in types should not be looked up name; their
3547 names are keywords that the parser can recognize. However, there
3548 is code in c-common.c that uses identifier_global_value to look
3549 up built-in types by name. */
3552 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3553 DECL_ARTIFICIAL (tdecl
) = 1;
3554 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3560 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3561 DECL_ARTIFICIAL (tdecl
) = 1;
3563 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3566 if (!TYPE_NAME (type
))
3567 TYPE_NAME (type
) = tdecl
;
3570 debug_hooks
->type_decl (tdecl
, 0);
3573 /* Record one of the standard Java types.
3574 * Declare it as having the given NAME.
3575 * If SIZE > 0, it is the size of one of the integral types;
3576 * otherwise it is the negative of the size of one of the other types. */
3579 record_builtin_java_type (const char* name
, int size
)
3584 type
= build_nonstandard_integer_type (size
, 0);
3585 type
= build_distinct_type_copy (type
);
3587 else if (size
> -32)
3590 /* "__java_char" or ""__java_boolean". */
3591 type
= build_nonstandard_integer_type (-size
, 1);
3592 type
= build_distinct_type_copy (type
);
3593 /* Get the signed type cached and attached to the unsigned type,
3594 so it doesn't get garbage-collected at "random" times,
3595 causing potential codegen differences out of different UIDs
3596 and different alias set numbers. */
3597 stype
= build_nonstandard_integer_type (-size
, 0);
3598 stype
= build_distinct_type_copy (stype
);
3599 TREE_CHAIN (type
) = stype
;
3600 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3603 { /* "__java_float" or ""__java_double". */
3604 type
= make_node (REAL_TYPE
);
3605 TYPE_PRECISION (type
) = - size
;
3608 record_builtin_type (RID_MAX
, name
, type
);
3609 decl
= TYPE_NAME (type
);
3611 /* Suppress generate debug symbol entries for these types,
3612 since for normal C++ they are just clutter.
3613 However, push_lang_context undoes this if extern "Java" is seen. */
3614 DECL_IGNORED_P (decl
) = 1;
3616 TYPE_FOR_JAVA (type
) = 1;
3620 /* Push a type into the namespace so that the back ends ignore it. */
3623 record_unknown_type (tree type
, const char* name
)
3625 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3626 TYPE_DECL
, get_identifier (name
), type
));
3627 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3628 DECL_IGNORED_P (decl
) = 1;
3629 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3630 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3631 TYPE_ALIGN (type
) = 1;
3632 TYPE_USER_ALIGN (type
) = 0;
3633 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3636 /* A string for which we should create an IDENTIFIER_NODE at
3639 typedef struct predefined_identifier
3641 /* The name of the identifier. */
3642 const char *const name
;
3643 /* The place where the IDENTIFIER_NODE should be stored. */
3645 /* Nonzero if this is the name of a constructor or destructor. */
3646 const int ctor_or_dtor_p
;
3647 } predefined_identifier
;
3649 /* Create all the predefined identifiers. */
3652 initialize_predefined_identifiers (void)
3654 const predefined_identifier
*pid
;
3656 /* A table of identifiers to create at startup. */
3657 static const predefined_identifier predefined_identifiers
[] = {
3658 { "C++", &lang_name_cplusplus
, 0 },
3659 { "C", &lang_name_c
, 0 },
3660 { "Java", &lang_name_java
, 0 },
3661 /* Some of these names have a trailing space so that it is
3662 impossible for them to conflict with names written by users. */
3663 { "__ct ", &ctor_identifier
, 1 },
3664 { "__base_ctor ", &base_ctor_identifier
, 1 },
3665 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3666 { "__dt ", &dtor_identifier
, 1 },
3667 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3668 { "__base_dtor ", &base_dtor_identifier
, 1 },
3669 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3670 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3671 { "nelts", &nelts_identifier
, 0 },
3672 { THIS_NAME
, &this_identifier
, 0 },
3673 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3674 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3675 { "_vptr", &vptr_identifier
, 0 },
3676 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3677 { "::", &global_scope_name
, 0 },
3678 { "std", &std_identifier
, 0 },
3682 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3684 *pid
->node
= get_identifier (pid
->name
);
3685 if (pid
->ctor_or_dtor_p
)
3686 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3690 /* Create the predefined scalar types of C,
3691 and some nodes representing standard constants (0, 1, (void *)0).
3692 Initialize the global binding level.
3693 Make definitions for built-in primitive functions. */
3696 cxx_init_decl_processing (void)
3699 tree void_ftype_ptr
;
3701 /* Create all the identifiers we need. */
3702 initialize_predefined_identifiers ();
3704 /* Create the global variables. */
3705 push_to_top_level ();
3707 current_function_decl
= NULL_TREE
;
3708 current_binding_level
= NULL
;
3709 /* Enter the global namespace. */
3710 gcc_assert (global_namespace
== NULL_TREE
);
3711 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3713 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3714 TREE_PUBLIC (global_namespace
) = 1;
3715 begin_scope (sk_namespace
, global_namespace
);
3717 if (flag_visibility_ms_compat
)
3718 default_visibility
= VISIBILITY_HIDDEN
;
3721 current_lang_name
= lang_name_c
;
3723 /* Create the `std' namespace. */
3724 push_namespace (std_identifier
);
3725 std_node
= current_namespace
;
3728 c_common_nodes_and_builtins ();
3730 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3731 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3732 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3733 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3734 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3735 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3736 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3737 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3739 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3741 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3742 truthvalue_type_node
= boolean_type_node
;
3743 truthvalue_false_node
= boolean_false_node
;
3744 truthvalue_true_node
= boolean_true_node
;
3746 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3747 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3748 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3751 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3754 delta_type_node
= ptrdiff_type_node
;
3755 vtable_index_type
= ptrdiff_type_node
;
3757 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3758 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3759 void_ftype_ptr
= build_function_type_list (void_type_node
,
3760 ptr_type_node
, NULL_TREE
);
3762 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3764 /* C++ extensions */
3766 unknown_type_node
= make_node (LANG_TYPE
);
3767 record_unknown_type (unknown_type_node
, "unknown type");
3769 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3770 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3772 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3774 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3775 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3777 init_list_type_node
= make_node (LANG_TYPE
);
3778 record_unknown_type (init_list_type_node
, "init list");
3781 /* Make sure we get a unique function type, so we can give
3782 its pointer type a name. (This wins for gdb.) */
3783 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3784 TREE_TYPE (vfunc_type
) = integer_type_node
;
3785 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3786 layout_type (vfunc_type
);
3788 vtable_entry_type
= build_pointer_type (vfunc_type
);
3790 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3793 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3794 layout_type (vtbl_type_node
);
3795 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3796 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3797 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3798 layout_type (vtbl_ptr_type_node
);
3799 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3801 push_namespace (get_identifier ("__cxxabiv1"));
3802 abi_node
= current_namespace
;
3805 global_type_node
= make_node (LANG_TYPE
);
3806 record_unknown_type (global_type_node
, "global type");
3809 current_lang_name
= lang_name_cplusplus
;
3812 tree newattrs
, extvisattr
;
3813 tree newtype
, deltype
;
3814 tree ptr_ftype_sizetype
;
3818 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3819 if (cxx_dialect
== cxx98
)
3822 tree bad_alloc_type_node
;
3823 tree bad_alloc_decl
;
3825 push_namespace (std_identifier
);
3826 bad_alloc_id
= get_identifier ("bad_alloc");
3827 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3828 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3830 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3831 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3835 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3838 new_eh_spec
= noexcept_false_spec
;
3840 /* Ensure attribs.c is initialized. */
3842 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3844 newattrs
= tree_cons (get_identifier ("alloc_size"),
3845 build_tree_list (NULL_TREE
, integer_one_node
),
3847 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3848 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3849 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3850 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3851 DECL_IS_OPERATOR_NEW (push_cp_library_fn (NEW_EXPR
, newtype
, 0)) = 1;
3852 DECL_IS_OPERATOR_NEW (push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0)) = 1;
3853 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3854 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3856 nullptr_type_node
= make_node (NULLPTR_TYPE
);
3857 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
3858 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
3859 TYPE_UNSIGNED (nullptr_type_node
) = 1;
3860 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
3861 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
3862 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
3863 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
3867 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
3868 ECF_NORETURN
| ECF_NOTHROW
);
3870 /* Perform other language dependent initializations. */
3871 init_class_processing ();
3872 init_rtti_processing ();
3873 init_template_processing ();
3875 if (flag_exceptions
)
3876 init_exception_processing ();
3878 if (! supports_one_only ())
3881 make_fname_decl
= cp_make_fname_decl
;
3882 start_fname_decls ();
3884 /* Show we use EH for cleanups. */
3885 if (flag_exceptions
)
3886 using_eh_for_cleanups ();
3889 /* Generate an initializer for a function naming variable from
3890 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3891 filled in with the type of the init. */
3894 cp_fname_init (const char* name
, tree
*type_p
)
3896 tree domain
= NULL_TREE
;
3898 tree init
= NULL_TREE
;
3903 length
= strlen (name
);
3904 domain
= build_index_type (size_int (length
));
3905 init
= build_string (length
+ 1, name
);
3908 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3909 type
= build_cplus_array_type (type
, domain
);
3914 TREE_TYPE (init
) = type
;
3916 init
= error_mark_node
;
3921 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3922 the decl, LOC is the location to give the decl, NAME is the
3923 initialization string and TYPE_DEP indicates whether NAME depended
3924 on the type of the function. We make use of that to detect
3925 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3926 at the point of first use, so we mustn't push the decl now. */
3929 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3931 const char *const name
= (type_dep
&& processing_template_decl
3932 ? NULL
: fname_as_string (type_dep
));
3934 tree init
= cp_fname_init (name
, &type
);
3935 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3938 free (CONST_CAST (char *, name
));
3940 /* As we're using pushdecl_with_scope, we must set the context. */
3941 DECL_CONTEXT (decl
) = current_function_decl
;
3943 TREE_STATIC (decl
) = 1;
3944 TREE_READONLY (decl
) = 1;
3945 DECL_ARTIFICIAL (decl
) = 1;
3947 TREE_USED (decl
) = 1;
3949 if (current_function_decl
)
3951 cp_binding_level
*b
= current_binding_level
;
3952 if (b
->kind
== sk_function_parms
)
3953 return error_mark_node
;
3954 while (b
->level_chain
->kind
!= sk_function_parms
)
3956 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3957 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3958 LOOKUP_ONLYCONVERTING
);
3962 DECL_THIS_STATIC (decl
) = true;
3963 pushdecl_top_level_and_finish (decl
, init
);
3970 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3972 tree id
= DECL_NAME (decl
);
3973 const char *name
= IDENTIFIER_POINTER (id
);
3975 retrofit_lang_decl (decl
);
3977 DECL_ARTIFICIAL (decl
) = 1;
3978 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3979 SET_DECL_LANGUAGE (decl
, lang_c
);
3980 /* Runtime library routines are, by definition, available in an
3981 external shared object. */
3982 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3983 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3985 DECL_CONTEXT (decl
) = context
;
3988 pushdecl_top_level (decl
);
3992 /* A function in the user's namespace should have an explicit
3993 declaration before it is used. Mark the built-in function as
3994 anticipated but not actually declared. */
3995 if (name
[0] != '_' || name
[1] != '_')
3996 DECL_ANTICIPATED (decl
) = 1;
3997 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
3999 size_t len
= strlen (name
);
4001 /* Treat __*_chk fortification functions as anticipated as well,
4002 unless they are __builtin_*. */
4003 if (len
> strlen ("___chk")
4004 && memcmp (name
+ len
- strlen ("_chk"),
4005 "_chk", strlen ("_chk") + 1) == 0)
4006 DECL_ANTICIPATED (decl
) = 1;
4013 cxx_builtin_function (tree decl
)
4015 tree id
= DECL_NAME (decl
);
4016 const char *name
= IDENTIFIER_POINTER (id
);
4017 /* All builtins that don't begin with an '_' should additionally
4018 go in the 'std' namespace. */
4021 tree decl2
= copy_node(decl
);
4022 push_namespace (std_identifier
);
4023 builtin_function_1 (decl2
, std_node
, false);
4027 return builtin_function_1 (decl
, NULL_TREE
, false);
4030 /* Like cxx_builtin_function, but guarantee the function is added to the global
4031 scope. This is to allow function specific options to add new machine
4032 dependent builtins when the target ISA changes via attribute((target(...)))
4033 which saves space on program startup if the program does not use non-generic
4037 cxx_builtin_function_ext_scope (tree decl
)
4040 tree id
= DECL_NAME (decl
);
4041 const char *name
= IDENTIFIER_POINTER (id
);
4042 /* All builtins that don't begin with an '_' should additionally
4043 go in the 'std' namespace. */
4046 tree decl2
= copy_node(decl
);
4047 push_namespace (std_identifier
);
4048 builtin_function_1 (decl2
, std_node
, true);
4052 return builtin_function_1 (decl
, NULL_TREE
, true);
4055 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4056 function. Not called directly. */
4059 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4062 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4063 DECL_EXTERNAL (fn
) = 1;
4064 TREE_PUBLIC (fn
) = 1;
4065 DECL_ARTIFICIAL (fn
) = 1;
4066 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4067 SET_DECL_LANGUAGE (fn
, lang_c
);
4068 /* Runtime library routines are, by definition, available in an
4069 external shared object. */
4070 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4071 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4072 set_call_expr_flags (fn
, ecf_flags
);
4076 /* Returns the _DECL for a library function with C++ linkage. */
4079 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4082 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4083 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4084 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4088 /* Like build_library_fn, but takes a C string instead of an
4092 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4094 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4097 /* Like build_cp_library_fn, but takes a C string instead of an
4101 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4103 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4107 /* Like build_library_fn, but also pushes the function so that we will
4108 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4109 may throw exceptions listed in RAISES. */
4112 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4117 type
= build_exception_variant (type
, raises
);
4119 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4120 pushdecl_top_level (fn
);
4124 /* Like build_cp_library_fn, but also pushes the function so that it
4125 will be found by normal lookup. */
4128 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4131 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4136 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4140 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4144 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4146 tree type
= build_function_type (void_type_node
, parmtypes
);
4147 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4150 /* Like push_library_fn, but also note that this function throws
4151 and does not return. Used for __throw_foo and the like. */
4154 push_throw_library_fn (tree name
, tree type
)
4156 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4160 /* When we call finish_struct for an anonymous union, we create
4161 default copy constructors and such. But, an anonymous union
4162 shouldn't have such things; this function undoes the damage to the
4163 anonymous union type T.
4165 (The reason that we create the synthesized methods is that we don't
4166 distinguish `union { int i; }' from `typedef union { int i; } U'.
4167 The first is an anonymous union; the second is just an ordinary
4171 fixup_anonymous_aggr (tree t
)
4175 /* Wipe out memory of synthesized methods. */
4176 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4177 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4178 TYPE_HAS_COPY_CTOR (t
) = 0;
4179 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4180 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4181 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4183 /* Splice the implicitly generated functions out of the TYPE_METHODS
4185 q
= &TYPE_METHODS (t
);
4188 if (DECL_ARTIFICIAL (*q
))
4189 *q
= TREE_CHAIN (*q
);
4191 q
= &DECL_CHAIN (*q
);
4194 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4195 if (TYPE_METHODS (t
))
4197 tree decl
= TYPE_MAIN_DECL (t
);
4199 if (TREE_CODE (t
) != UNION_TYPE
)
4200 error_at (DECL_SOURCE_LOCATION (decl
),
4201 "an anonymous struct cannot have function members");
4203 error_at (DECL_SOURCE_LOCATION (decl
),
4204 "an anonymous union cannot have function members");
4207 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4208 assignment operators (because they cannot have these methods themselves).
4209 For anonymous unions this is already checked because they are not allowed
4210 in any union, otherwise we have to check it. */
4211 if (TREE_CODE (t
) != UNION_TYPE
)
4215 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4216 if (TREE_CODE (field
) == FIELD_DECL
)
4218 type
= TREE_TYPE (field
);
4219 if (CLASS_TYPE_P (type
))
4221 if (TYPE_NEEDS_CONSTRUCTING (type
))
4222 error ("member %q+#D with constructor not allowed "
4223 "in anonymous aggregate", field
);
4224 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4225 error ("member %q+#D with destructor not allowed "
4226 "in anonymous aggregate", field
);
4227 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4228 error ("member %q+#D with copy assignment operator "
4229 "not allowed in anonymous aggregate", field
);
4235 /* Warn for an attribute located at LOCATION that appertains to the
4236 class type CLASS_TYPE that has not been properly placed after its
4237 class-key, in it class-specifier. */
4240 warn_misplaced_attr_for_class_type (source_location location
,
4243 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4245 warning_at (location
, OPT_Wattributes
,
4246 "attribute ignored in declaration "
4247 "of %q#T", class_type
);
4249 "attribute for %q#T must follow the %qs keyword",
4250 class_type
, class_key_or_enum_as_string (class_type
));
4253 /* Make sure that a declaration with no declarator is well-formed, i.e.
4254 just declares a tagged type or anonymous union.
4256 Returns the type declared; or NULL_TREE if none. */
4259 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4260 bool explicit_type_instantiation_p
)
4262 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4263 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4264 /* If a class, struct, or enum type is declared by the DECLSPECS
4265 (i.e, if a class-specifier, enum-specifier, or non-typename
4266 elaborated-type-specifier appears in the DECLSPECS),
4267 DECLARED_TYPE is set to the corresponding type. */
4268 tree declared_type
= NULL_TREE
;
4269 bool error_p
= false;
4271 if (declspecs
->multiple_types_p
)
4272 error ("multiple types in one declaration");
4273 else if (declspecs
->redefined_builtin_type
)
4275 if (!in_system_header_at (input_location
))
4276 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4277 "redeclaration of C++ built-in type %qT",
4278 declspecs
->redefined_builtin_type
);
4283 && TYPE_P (declspecs
->type
)
4284 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4285 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4286 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4287 declared_type
= declspecs
->type
;
4288 else if (declspecs
->type
== error_mark_node
)
4290 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4291 permerror (input_location
, "declaration does not declare anything");
4292 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4294 error ("%<auto%> can only be specified for variables "
4295 "or function declarations");
4296 return error_mark_node
;
4298 /* Check for an anonymous union. */
4299 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4300 && TYPE_ANONYMOUS_P (declared_type
))
4302 /* 7/3 In a simple-declaration, the optional init-declarator-list
4303 can be omitted only when declaring a class (clause 9) or
4304 enumeration (7.2), that is, when the decl-specifier-seq contains
4305 either a class-specifier, an elaborated-type-specifier with
4306 a class-key (9.1), or an enum-specifier. In these cases and
4307 whenever a class-specifier or enum-specifier is present in the
4308 decl-specifier-seq, the identifiers in these specifiers are among
4309 the names being declared by the declaration (as class-name,
4310 enum-names, or enumerators, depending on the syntax). In such
4311 cases, and except for the declaration of an unnamed bit-field (9.6),
4312 the decl-specifier-seq shall introduce one or more names into the
4313 program, or shall redeclare a name introduced by a previous
4314 declaration. [Example:
4315 enum { }; // ill-formed
4316 typedef class { }; // ill-formed
4320 error ("missing type-name in typedef-declaration");
4323 /* Anonymous unions are objects, so they can have specifiers. */;
4324 SET_ANON_AGGR_TYPE_P (declared_type
);
4326 if (TREE_CODE (declared_type
) != UNION_TYPE
4327 && !in_system_header_at (input_location
))
4328 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4333 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4334 || decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4335 error ("%qs can only be specified for functions",
4336 decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4337 ? "inline" : "virtual");
4339 && (!current_class_type
4340 || current_scope () != current_class_type
))
4341 error ("%<friend%> can only be specified inside a class");
4342 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4343 error ("%<explicit%> can only be specified for constructors");
4344 else if (declspecs
->storage_class
)
4345 error ("a storage class can only be specified for objects "
4347 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
)
4348 || decl_spec_seq_has_spec_p (declspecs
, ds_volatile
)
4349 || decl_spec_seq_has_spec_p (declspecs
, ds_restrict
)
4350 || decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4351 error ("qualifiers can only be specified for objects "
4353 else if (saw_typedef
)
4354 warning (0, "%<typedef%> was ignored in this declaration");
4355 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4356 error ("%<constexpr%> cannot be used for type declarations");
4359 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4362 if (!CLASS_TYPE_P (declared_type
)
4363 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4364 /* For a non-template class, use the name location. */
4365 loc
= location_of (declared_type
);
4367 /* For a template class (an explicit instantiation), use the
4368 current location. */
4369 loc
= input_location
;
4371 if (explicit_type_instantiation_p
)
4372 /* [dcl.attr.grammar]/4:
4374 No attribute-specifier-seq shall appertain to an explicit
4377 warning_at (loc
, OPT_Wattributes
,
4378 "attribute ignored in explicit instantiation %q#T",
4381 "no attribute can be applied to "
4382 "an explicit instantiation");
4385 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4388 return declared_type
;
4391 /* Called when a declaration is seen that contains no names to declare.
4392 If its type is a reference to a structure, union or enum inherited
4393 from a containing scope, shadow that tag name for the current scope
4394 with a forward reference.
4395 If its type defines a new named structure or union
4396 or defines an enum, it is valid but we need not do anything here.
4397 Otherwise, it is an error.
4399 C++: may have to grok the declspecs to learn about static,
4400 complain for anonymous unions.
4402 Returns the TYPE declared -- or NULL_TREE if none. */
4405 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4407 tree t
= check_tag_decl (declspecs
,
4408 /*explicit_type_instantiation_p=*/false);
4413 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4416 /* This is where the variables in an anonymous union are
4417 declared. An anonymous union declaration looks like:
4419 because there is no declarator after the union, the parser
4420 sends that declaration here. */
4421 if (ANON_AGGR_TYPE_P (t
))
4423 fixup_anonymous_aggr (t
);
4425 if (TYPE_FIELDS (t
))
4427 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4428 declspecs
, NORMAL
, 0, NULL
);
4429 finish_anon_union (decl
);
4436 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4439 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4440 const cp_declarator
*declarator
,
4441 bool is_template_arg
)
4445 enum decl_context context
4446 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4447 attrs
= type_specifiers
->attributes
;
4448 type_specifiers
->attributes
= NULL_TREE
;
4449 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4450 if (attrs
&& type
!= error_mark_node
)
4452 if (CLASS_TYPE_P (type
))
4453 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4454 "outside of definition", type
);
4455 else if (MAYBE_CLASS_TYPE_P (type
))
4456 /* A template type parameter or other dependent type. */
4457 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4458 "type %qT without an associated declaration", type
);
4460 cplus_decl_attributes (&type
, attrs
, 0);
4465 /* Process a DECLARATOR for a function-scope variable declaration,
4466 namespace-scope variable declaration, or function declaration.
4467 (Function definitions go through start_function; class member
4468 declarations appearing in the body of the class go through
4469 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4470 If an error occurs, the error_mark_node is returned instead.
4472 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4473 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4474 for an explicitly defaulted function, or SD_DELETED for an explicitly
4475 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4476 implicitly initialized via a default constructor. ATTRIBUTES and
4477 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4479 The scope represented by the context of the returned DECL is pushed
4480 (if it is not the global namespace) and is assigned to
4481 *PUSHED_SCOPE_P. The caller is then responsible for calling
4482 pop_scope on *PUSHED_SCOPE_P if it is set. */
4485 start_decl (const cp_declarator
*declarator
,
4486 cp_decl_specifier_seq
*declspecs
,
4489 tree prefix_attributes
,
4490 tree
*pushed_scope_p
)
4498 *pushed_scope_p
= NULL_TREE
;
4500 /* An object declared as __attribute__((deprecated)) suppresses
4501 warnings of uses of other deprecated items. */
4502 if (lookup_attribute ("deprecated", attributes
))
4503 deprecated_state
= DEPRECATED_SUPPRESS
;
4505 attributes
= chainon (attributes
, prefix_attributes
);
4507 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4510 deprecated_state
= DEPRECATED_NORMAL
;
4512 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4513 || decl
== error_mark_node
)
4514 return error_mark_node
;
4516 context
= CP_DECL_CONTEXT (decl
);
4517 if (context
!= global_namespace
)
4518 *pushed_scope_p
= push_scope (context
);
4521 /* Is it valid for this decl to have an initializer at all?
4522 If not, set INITIALIZED to zero, which will indirectly
4523 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4524 switch (TREE_CODE (decl
))
4527 error ("typedef %qD is initialized (use decltype instead)", decl
);
4528 return error_mark_node
;
4531 if (initialized
== SD_DELETED
)
4532 /* We'll handle the rest of the semantics later, but we need to
4533 set this now so it's visible to duplicate_decls. */
4534 DECL_DELETED_FN (decl
) = 1;
4543 if (! toplevel_bindings_p ()
4544 && DECL_EXTERNAL (decl
))
4545 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4547 DECL_EXTERNAL (decl
) = 0;
4548 if (toplevel_bindings_p ())
4549 TREE_STATIC (decl
) = 1;
4551 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4553 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4554 record_key_method_defined (decl
);
4556 /* If this is a typedef that names the class for linkage purposes
4557 (7.1.3p8), apply any attributes directly to the type. */
4558 if (TREE_CODE (decl
) == TYPE_DECL
4559 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4560 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4561 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4565 /* Set attributes here so if duplicate decl, will have proper attributes. */
4566 cplus_decl_attributes (&decl
, attributes
, flags
);
4568 /* Dllimported symbols cannot be defined. Static data members (which
4569 can be initialized in-class and dllimported) go through grokfield,
4570 not here, so we don't need to exclude those decls when checking for
4572 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4574 error ("definition of %q#D is marked %<dllimport%>", decl
);
4575 DECL_DLLIMPORT_P (decl
) = 0;
4578 /* If #pragma weak was used, mark the decl weak now. */
4579 if (!processing_template_decl
)
4580 maybe_apply_pragma_weak (decl
);
4582 if (TREE_CODE (decl
) == FUNCTION_DECL
4583 && DECL_DECLARED_INLINE_P (decl
)
4584 && DECL_UNINLINABLE (decl
)
4585 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4586 warning (0, "inline function %q+D given attribute noinline", decl
);
4588 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4592 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4593 if (field
== NULL_TREE
|| !VAR_P (field
))
4594 error ("%q#D is not a static member of %q#T", decl
, context
);
4597 if (DECL_CONTEXT (field
) != context
)
4599 if (!same_type_p (DECL_CONTEXT (field
), context
))
4600 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4601 "to be defined as %<%T::%D%>",
4602 DECL_CONTEXT (field
), DECL_NAME (decl
),
4603 context
, DECL_NAME (decl
));
4604 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4606 /* Static data member are tricky; an in-class initialization
4607 still doesn't provide a definition, so the in-class
4608 declaration will have DECL_EXTERNAL set, but will have an
4609 initialization. Thus, duplicate_decls won't warn
4610 about this situation, and so we check here. */
4611 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4612 error ("duplicate initialization of %qD", decl
);
4613 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4615 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4616 && !DECL_DECLARED_CONSTEXPR_P (field
))
4617 error ("%qD declared %<constexpr%> outside its class", field
);
4622 tree field
= check_classfn (context
, decl
,
4623 (processing_template_decl
4624 > template_class_depth (context
))
4625 ? current_template_parms
4627 if (field
&& field
!= error_mark_node
4628 && duplicate_decls (decl
, field
,
4629 /*newdecl_is_friend=*/false))
4633 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4634 DECL_IN_AGGR_P (decl
) = 0;
4635 /* Do not mark DECL as an explicit specialization if it was not
4636 already marked as an instantiation; a declaration should
4637 never be marked as a specialization unless we know what
4638 template is being specialized. */
4639 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4641 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4643 /* [temp.expl.spec] An explicit specialization of a static data
4644 member of a template is a definition if the declaration
4645 includes an initializer; otherwise, it is a declaration.
4647 We check for processing_specialization so this only applies
4648 to the new specialization syntax. */
4649 if (!initialized
&& processing_specialization
)
4650 DECL_EXTERNAL (decl
) = 1;
4653 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4654 /* Aliases are definitions. */
4656 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4660 was_public
= TREE_PUBLIC (decl
);
4662 /* Enter this declaration into the symbol table. */
4663 decl
= maybe_push_decl (decl
);
4665 if (processing_template_decl
)
4666 decl
= push_template_decl (decl
);
4667 if (decl
== error_mark_node
)
4668 return error_mark_node
;
4671 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4672 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4674 /* This is a const variable with implicit 'static'. Set
4675 DECL_THIS_STATIC so we can tell it from variables that are
4676 !TREE_PUBLIC because of the anonymous namespace. */
4677 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4678 DECL_THIS_STATIC (decl
) = 1;
4681 if (!processing_template_decl
&& VAR_P (decl
))
4682 start_decl_1 (decl
, initialized
);
4687 /* Process the declaration of a variable DECL. INITIALIZED is true
4688 iff DECL is explicitly initialized. (INITIALIZED is false if the
4689 variable is initialized via an implicitly-called constructor.)
4690 This function must be called for ordinary variables (including, for
4691 example, implicit instantiations of templates), but must not be
4692 called for template declarations. */
4695 start_decl_1 (tree decl
, bool initialized
)
4699 bool aggregate_definition_p
;
4701 gcc_assert (!processing_template_decl
);
4703 if (error_operand_p (decl
))
4706 gcc_assert (VAR_P (decl
));
4708 type
= TREE_TYPE (decl
);
4709 complete_p
= COMPLETE_TYPE_P (type
);
4710 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4712 /* If an explicit initializer is present, or if this is a definition
4713 of an aggregate, then we need a complete type at this point.
4714 (Scalars are always complete types, so there is nothing to
4715 check.) This code just sets COMPLETE_P; errors (if necessary)
4716 are issued below. */
4717 if ((initialized
|| aggregate_definition_p
)
4719 && COMPLETE_TYPE_P (complete_type (type
)))
4722 /* We will not yet have set TREE_READONLY on DECL if the type
4723 was "const", but incomplete, before this point. But, now, we
4724 have a complete type, so we can try again. */
4725 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4729 /* Is it valid for this decl to have an initializer at all? */
4731 /* Don't allow initializations for incomplete types except for
4732 arrays which might be completed by the initialization. */
4734 ; /* A complete type is ok. */
4735 else if (type_uses_auto (type
))
4736 ; /* An auto type is ok. */
4737 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4739 error ("variable %q#D has initializer but incomplete type", decl
);
4740 type
= TREE_TYPE (decl
) = error_mark_node
;
4742 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4744 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4745 error ("elements of array %q#D have incomplete type", decl
);
4746 /* else we already gave an error in start_decl. */
4749 else if (aggregate_definition_p
&& !complete_p
)
4751 if (type_uses_auto (type
))
4752 error ("declaration of %q#D has no initializer", decl
);
4754 error ("aggregate %q#D has incomplete type and cannot be defined",
4756 /* Change the type so that assemble_variable will give
4757 DECL an rtl we can live with: (mem (const_int 0)). */
4758 type
= TREE_TYPE (decl
) = error_mark_node
;
4761 /* Create a new scope to hold this declaration if necessary.
4762 Whether or not a new scope is necessary cannot be determined
4763 until after the type has been completed; if the type is a
4764 specialization of a class template it is not until after
4765 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4766 will be set correctly. */
4767 maybe_push_cleanup_level (type
);
4770 /* Handle initialization of references. DECL, TYPE, and INIT have the
4771 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4772 but will be set to a new CLEANUP_STMT if a temporary is created
4773 that must be destroyed subsequently.
4775 Returns an initializer expression to use to initialize DECL, or
4776 NULL if the initialization can be performed statically.
4778 Quotes on semantics can be found in ARM 8.4.3. */
4781 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4783 if (init
== NULL_TREE
)
4785 if ((DECL_LANG_SPECIFIC (decl
) == 0
4786 || DECL_IN_AGGR_P (decl
) == 0)
4787 && ! DECL_THIS_EXTERN (decl
))
4788 error ("%qD declared as reference but not initialized", decl
);
4792 if (TREE_CODE (init
) == TREE_LIST
)
4793 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4794 tf_warning_or_error
);
4796 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4797 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4798 /* Note: default conversion is only called in very special cases. */
4799 init
= decay_conversion (init
, tf_warning_or_error
);
4801 /* Convert INIT to the reference type TYPE. This may involve the
4802 creation of a temporary, whose lifetime must be the same as that
4803 of the reference. If so, a DECL_EXPR for the temporary will be
4804 added just after the DECL_EXPR for DECL. That's why we don't set
4805 DECL_INITIAL for local references (instead assigning to them
4806 explicitly); we need to allow the temporary to be initialized
4808 return initialize_reference (type
, init
, flags
,
4809 tf_warning_or_error
);
4812 /* Designated initializers in arrays are not supported in GNU C++.
4813 The parser cannot detect this error since it does not know whether
4814 a given brace-enclosed initializer is for a class type or for an
4815 array. This function checks that CE does not use a designated
4816 initializer. If it does, an error is issued. Returns true if CE
4817 is valid, i.e., does not have a designated initializer. */
4820 check_array_designated_initializer (constructor_elt
*ce
,
4821 unsigned HOST_WIDE_INT index
)
4823 /* Designated initializers for array elements are not supported. */
4826 /* The parser only allows identifiers as designated
4828 if (ce
->index
== error_mark_node
)
4830 error ("name used in a GNU-style designated "
4831 "initializer for an array");
4834 else if (identifier_p (ce
->index
))
4836 error ("name %qD used in a GNU-style designated "
4837 "initializer for an array", ce
->index
);
4841 ce
->index
= cxx_constant_value (ce
->index
);
4843 if (TREE_CODE (ce
->index
) == INTEGER_CST
)
4845 /* A C99 designator is OK if it matches the current index. */
4846 if (TREE_INT_CST_LOW (ce
->index
) == index
)
4849 sorry ("non-trivial designated initializers not supported");
4860 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4861 array until we finish parsing the initializer. If that's the
4862 situation we're in, update DECL accordingly. */
4865 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4867 tree type
= TREE_TYPE (decl
);
4869 if (TREE_CODE (type
) == ARRAY_TYPE
4870 && TYPE_DOMAIN (type
) == NULL_TREE
4871 && TREE_CODE (decl
) != TYPE_DECL
)
4873 /* do_default is really a C-ism to deal with tentative definitions.
4874 But let's leave it here to ease the eventual merge. */
4875 int do_default
= !DECL_EXTERNAL (decl
);
4876 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4879 /* Check that there are no designated initializers in INIT, as
4880 those are not supported in GNU C++, and as the middle-end
4881 will crash if presented with a non-numeric designated
4883 if (initializer
&& TREE_CODE (initializer
) == CONSTRUCTOR
)
4885 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
4886 constructor_elt
*ce
;
4888 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
4889 if (!check_array_designated_initializer (ce
, i
))
4895 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4899 error ("initializer fails to determine size of %qD", decl
);
4901 else if (failure
== 2)
4905 error ("array size missing in %qD", decl
);
4907 /* If a `static' var's size isn't known, make it extern as
4908 well as static, so it does not get allocated. If it's not
4909 `static', then don't mark it extern; finish_incomplete_decl
4910 will give it a default size and it will get allocated. */
4911 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4912 DECL_EXTERNAL (decl
) = 1;
4914 else if (failure
== 3)
4916 error ("zero-size array %qD", decl
);
4920 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4922 relayout_decl (decl
);
4926 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4927 any appropriate error messages regarding the layout. */
4930 layout_var_decl (tree decl
)
4934 type
= TREE_TYPE (decl
);
4935 if (type
== error_mark_node
)
4938 /* If we haven't already laid out this declaration, do so now.
4939 Note that we must not call complete type for an external object
4940 because it's type might involve templates that we are not
4941 supposed to instantiate yet. (And it's perfectly valid to say
4942 `extern X x' for some incomplete type `X'.) */
4943 if (!DECL_EXTERNAL (decl
))
4944 complete_type (type
);
4945 if (!DECL_SIZE (decl
)
4946 && TREE_TYPE (decl
) != error_mark_node
4947 && (COMPLETE_TYPE_P (type
)
4948 || (TREE_CODE (type
) == ARRAY_TYPE
4949 && !TYPE_DOMAIN (type
)
4950 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4951 layout_decl (decl
, 0);
4953 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4955 /* An automatic variable with an incomplete type: that is an error.
4956 Don't talk about array types here, since we took care of that
4957 message in grokdeclarator. */
4958 error ("storage size of %qD isn%'t known", decl
);
4959 TREE_TYPE (decl
) = error_mark_node
;
4962 /* Keep this code around in case we later want to control debug info
4963 based on whether a type is "used". (jason 1999-11-11) */
4965 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4966 /* Let debugger know it should output info for this type. */
4967 note_debug_info_needed (ttype
);
4969 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4970 note_debug_info_needed (DECL_CONTEXT (decl
));
4973 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4974 && DECL_SIZE (decl
) != NULL_TREE
4975 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4977 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4978 constant_expression_warning (DECL_SIZE (decl
));
4981 error ("storage size of %qD isn%'t constant", decl
);
4982 TREE_TYPE (decl
) = error_mark_node
;
4987 /* If a local static variable is declared in an inline function, or if
4988 we have a weak definition, we must endeavor to create only one
4989 instance of the variable at link-time. */
4992 maybe_commonize_var (tree decl
)
4994 /* Static data in a function with comdat linkage also has comdat
4996 if (TREE_STATIC (decl
)
4997 /* Don't mess with __FUNCTION__. */
4998 && ! DECL_ARTIFICIAL (decl
)
4999 && DECL_FUNCTION_SCOPE_P (decl
)
5000 && vague_linkage_p (DECL_CONTEXT (decl
)))
5004 /* With weak symbols, we simply make the variable COMDAT;
5005 that will cause copies in multiple translations units to
5007 comdat_linkage (decl
);
5011 if (DECL_INITIAL (decl
) == NULL_TREE
5012 || DECL_INITIAL (decl
) == error_mark_node
)
5014 /* Without weak symbols, we can use COMMON to merge
5015 uninitialized variables. */
5016 TREE_PUBLIC (decl
) = 1;
5017 DECL_COMMON (decl
) = 1;
5021 /* While for initialized variables, we must use internal
5022 linkage -- which means that multiple copies will not
5024 TREE_PUBLIC (decl
) = 0;
5025 DECL_COMMON (decl
) = 0;
5026 warning_at (input_location
, 0,
5027 "sorry: semantics of inline function static "
5028 "data %q+#D are wrong (you%'ll wind up "
5029 "with multiple copies)", decl
);
5030 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5031 " you can work around this by removing "
5036 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
5037 /* Set it up again; we might have set DECL_INITIAL since the last
5039 comdat_linkage (decl
);
5042 /* Issue an error message if DECL is an uninitialized const variable. */
5045 check_for_uninitialized_const_var (tree decl
)
5047 tree type
= strip_array_types (TREE_TYPE (decl
));
5049 /* ``Unless explicitly declared extern, a const object does not have
5050 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5053 && TREE_CODE (type
) != REFERENCE_TYPE
5054 && CP_TYPE_CONST_P (type
)
5055 && !DECL_INITIAL (decl
))
5057 tree field
= default_init_uninitialized_part (type
);
5061 permerror (DECL_SOURCE_LOCATION (decl
),
5062 "uninitialized const %qD", decl
);
5064 if (CLASS_TYPE_P (type
))
5066 tree defaulted_ctor
;
5068 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5069 "%q#T has no user-provided default constructor", type
);
5070 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5072 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5073 "constructor is not user-provided because it is "
5074 "explicitly defaulted in the class body");
5075 inform (0, "and the implicitly-defined constructor does not "
5076 "initialize %q+#D", field
);
5081 /* Structure holding the current initializer being processed by reshape_init.
5082 CUR is a pointer to the current element being processed, END is a pointer
5083 after the last element present in the initializer. */
5084 typedef struct reshape_iterator_t
5086 constructor_elt
*cur
;
5087 constructor_elt
*end
;
5090 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5092 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5093 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5094 initialized. If there are no more such fields, the return value
5098 next_initializable_field (tree field
)
5101 && (TREE_CODE (field
) != FIELD_DECL
5102 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5103 || DECL_ARTIFICIAL (field
)))
5104 field
= DECL_CHAIN (field
);
5109 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5110 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5111 INTEGER_CST representing the size of the array minus one (the maximum index),
5112 or NULL_TREE if the array was declared without specifying the size. D is
5113 the iterator within the constructor. */
5116 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5117 tsubst_flags_t complain
)
5120 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5121 unsigned HOST_WIDE_INT max_index_cst
= 0;
5122 unsigned HOST_WIDE_INT index
;
5124 /* The initializer for an array is always a CONSTRUCTOR. */
5125 new_init
= build_constructor (init_list_type_node
, NULL
);
5129 /* Minus 1 is used for zero sized arrays. */
5130 if (integer_all_onesp (max_index
))
5133 if (tree_fits_uhwi_p (max_index
))
5134 max_index_cst
= tree_to_uhwi (max_index
);
5135 /* sizetype is sign extended, not zero extended. */
5137 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5140 /* Loop until there are no more initializers. */
5142 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5146 constructor_elt
*old_cur
= d
->cur
;
5148 check_array_designated_initializer (d
->cur
, index
);
5149 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5151 if (elt_init
== error_mark_node
)
5152 return error_mark_node
;
5153 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5154 size_int (index
), elt_init
);
5155 if (!TREE_CONSTANT (elt_init
))
5156 TREE_CONSTANT (new_init
) = false;
5158 /* This can happen with an invalid initializer (c++/54501). */
5159 if (d
->cur
== old_cur
&& !sized_array_p
)
5166 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5167 Parameters are the same of reshape_init_r. */
5170 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5172 tree max_index
= NULL_TREE
;
5174 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5176 if (TYPE_DOMAIN (type
))
5177 max_index
= array_type_nelts (type
);
5179 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5182 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5183 Parameters are the same of reshape_init_r. */
5186 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5188 tree max_index
= NULL_TREE
;
5190 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
5192 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5194 tree value
= d
->cur
->value
;
5195 if (!same_type_p (TREE_TYPE (value
), type
))
5197 if (complain
& tf_error
)
5198 error ("invalid type %qT as initializer for a vector of type %qT",
5199 TREE_TYPE (d
->cur
->value
), type
);
5200 value
= error_mark_node
;
5206 /* For a vector, we initialize it as an array of the appropriate size. */
5207 if (TREE_CODE (type
) == VECTOR_TYPE
)
5208 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5210 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5213 /* Subroutine of reshape_init_r, processes the initializers for classes
5214 or union. Parameters are the same of reshape_init_r. */
5217 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5218 tsubst_flags_t complain
)
5223 gcc_assert (CLASS_TYPE_P (type
));
5225 /* The initializer for a class is always a CONSTRUCTOR. */
5226 new_init
= build_constructor (init_list_type_node
, NULL
);
5227 field
= next_initializable_field (TYPE_FIELDS (type
));
5233 An initializer for an aggregate member that is an
5234 empty class shall have the form of an empty
5235 initializer-list {}. */
5236 if (!first_initializer_p
)
5238 if (complain
& tf_error
)
5239 error ("initializer for %qT must be brace-enclosed", type
);
5240 return error_mark_node
;
5245 /* Loop through the initializable fields, gathering initializers. */
5246 while (d
->cur
!= d
->end
)
5249 constructor_elt
*old_cur
= d
->cur
;
5251 /* Handle designated initializers, as an extension. */
5254 if (d
->cur
->index
== error_mark_node
)
5255 return error_mark_node
;
5257 if (TREE_CODE (d
->cur
->index
) == INTEGER_CST
)
5259 if (complain
& tf_error
)
5260 error ("%<[%E] =%> used in a GNU-style designated initializer"
5261 " for class %qT", d
->cur
->index
, type
);
5262 return error_mark_node
;
5265 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5266 /* We already reshaped this. */
5267 gcc_assert (d
->cur
->index
== field
);
5269 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5271 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5273 if (complain
& tf_error
)
5274 error ("%qT has no non-static data member named %qD", type
,
5276 return error_mark_node
;
5280 /* If we processed all the member of the class, we are done. */
5284 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5285 /*first_initializer_p=*/false, complain
);
5286 if (field_init
== error_mark_node
)
5287 return error_mark_node
;
5289 if (d
->cur
== old_cur
&& d
->cur
->index
)
5291 /* This can happen with an invalid initializer for a flexible
5292 array member (c++/54441). */
5293 if (complain
& tf_error
)
5294 error ("invalid initializer for %q#D", field
);
5295 return error_mark_node
;
5298 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5302 When a union is initialized with a brace-enclosed
5303 initializer, the braces shall only contain an
5304 initializer for the first member of the union. */
5305 if (TREE_CODE (type
) == UNION_TYPE
)
5308 field
= next_initializable_field (DECL_CHAIN (field
));
5314 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5315 designators are not valid; either complain or return true to indicate
5316 that reshape_init_r should return error_mark_node. */
5319 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5323 if (complain
& tf_error
)
5324 error ("C99 designator %qE outside aggregate initializer",
5332 /* Subroutine of reshape_init, which processes a single initializer (part of
5333 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5334 iterator within the CONSTRUCTOR which points to the initializer to process.
5335 FIRST_INITIALIZER_P is true if this is the first initializer of the
5336 outermost CONSTRUCTOR node. */
5339 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5340 tsubst_flags_t complain
)
5342 tree init
= d
->cur
->value
;
5344 if (error_operand_p (init
))
5345 return error_mark_node
;
5347 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5348 && has_designator_problem (d
, complain
))
5349 return error_mark_node
;
5351 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5353 /* A complex type can be initialized from one or two initializers,
5354 but braces are not elided. */
5356 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5358 if (CONSTRUCTOR_NELTS (init
) > 2)
5360 if (complain
& tf_error
)
5361 error ("too many initializers for %qT", type
);
5363 return error_mark_node
;
5366 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5368 vec
<constructor_elt
, va_gc
> *v
= 0;
5369 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5370 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5371 if (has_designator_problem (d
, complain
))
5372 return error_mark_node
;
5374 init
= build_constructor (init_list_type_node
, v
);
5379 /* A non-aggregate type is always initialized with a single
5381 if (!CP_AGGREGATE_TYPE_P (type
))
5383 /* It is invalid to initialize a non-aggregate type with a
5384 brace-enclosed initializer before C++0x.
5385 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5386 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5387 a CONSTRUCTOR (with a record type). */
5388 if (TREE_CODE (init
) == CONSTRUCTOR
5389 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5391 if (SCALAR_TYPE_P (type
))
5393 if (complain
& tf_error
)
5394 error ("braces around scalar initializer for type %qT", type
);
5395 init
= error_mark_node
;
5398 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5407 All implicit type conversions (clause _conv_) are considered when
5408 initializing the aggregate member with an initializer from an
5409 initializer-list. If the initializer can initialize a member,
5410 the member is initialized. Otherwise, if the member is itself a
5411 non-empty subaggregate, brace elision is assumed and the
5412 initializer is considered for the initialization of the first
5413 member of the subaggregate. */
5414 if (TREE_CODE (init
) != CONSTRUCTOR
5415 /* But don't try this for the first initializer, since that would be
5416 looking through the outermost braces; A a2 = { a1 }; is not a
5417 valid aggregate initialization. */
5418 && !first_initializer_p
5419 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5420 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5427 /* [dcl.init.string]
5429 A char array (whether plain char, signed char, or unsigned char)
5430 can be initialized by a string-literal (optionally enclosed in
5431 braces); a wchar_t array can be initialized by a wide
5432 string-literal (optionally enclosed in braces). */
5433 if (TREE_CODE (type
) == ARRAY_TYPE
5434 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5436 tree str_init
= init
;
5438 /* Strip one level of braces if and only if they enclose a single
5439 element (as allowed by [dcl.init.string]). */
5440 if (!first_initializer_p
5441 && TREE_CODE (str_init
) == CONSTRUCTOR
5442 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5444 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5447 /* If it's a string literal, then it's the initializer for the array
5448 as a whole. Otherwise, continue with normal initialization for
5449 array types (one value per array element). */
5450 if (TREE_CODE (str_init
) == STRING_CST
)
5452 if (has_designator_problem (d
, complain
))
5453 return error_mark_node
;
5459 /* The following cases are about aggregates. If we are not within a full
5460 initializer already, and there is not a CONSTRUCTOR, it means that there
5461 is a missing set of braces (that is, we are processing the case for
5462 which reshape_init exists). */
5463 if (!first_initializer_p
)
5465 if (TREE_CODE (init
) == CONSTRUCTOR
)
5467 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5468 /* There is no need to reshape pointer-to-member function
5469 initializers, as they are always constructed correctly
5470 by the front end. */
5472 else if (COMPOUND_LITERAL_P (init
))
5473 /* For a nested compound literal, there is no need to reshape since
5474 brace elision is not allowed. Even if we decided to allow it,
5475 we should add a call to reshape_init in finish_compound_literal,
5476 before calling digest_init, so changing this code would still
5477 not be necessary. */
5478 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5482 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5483 return reshape_init (type
, init
, complain
);
5487 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5491 /* Dispatch to specialized routines. */
5492 if (CLASS_TYPE_P (type
))
5493 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5494 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5495 return reshape_init_array (type
, d
, complain
);
5496 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5497 return reshape_init_vector (type
, d
, complain
);
5502 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5503 brace-enclosed aggregate initializer.
5505 INIT is the CONSTRUCTOR containing the list of initializers describing
5506 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5507 It may not presently match the shape of the TYPE; for example:
5509 struct S { int a; int b; };
5510 struct S a[] = { 1, 2, 3, 4 };
5512 Here INIT will hold a vector of four elements, rather than a
5513 vector of two elements, each itself a vector of two elements. This
5514 routine transforms INIT from the former form into the latter. The
5515 revised CONSTRUCTOR node is returned. */
5518 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5520 vec
<constructor_elt
, va_gc
> *v
;
5524 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5526 v
= CONSTRUCTOR_ELTS (init
);
5528 /* An empty constructor does not need reshaping, and it is always a valid
5530 if (vec_safe_is_empty (v
))
5533 /* Recurse on this CONSTRUCTOR. */
5535 d
.end
= d
.cur
+ v
->length ();
5537 new_init
= reshape_init_r (type
, &d
, true, complain
);
5538 if (new_init
== error_mark_node
)
5539 return error_mark_node
;
5541 /* Make sure all the element of the constructor were used. Otherwise,
5542 issue an error about exceeding initializers. */
5545 if (complain
& tf_error
)
5546 error ("too many initializers for %qT", type
);
5548 return error_mark_node
;
5554 /* Verify array initializer. Returns true if errors have been reported. */
5557 check_array_initializer (tree decl
, tree type
, tree init
)
5559 tree element_type
= TREE_TYPE (type
);
5561 /* The array type itself need not be complete, because the
5562 initializer may tell us how many elements are in the array.
5563 But, the elements of the array must be complete. */
5564 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5567 error ("elements of array %q#D have incomplete type", decl
);
5569 error ("elements of array %q#T have incomplete type", type
);
5572 /* A compound literal can't have variable size. */
5574 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5575 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5577 error ("variable-sized compound literal");
5583 /* Subroutine of check_initializer; args are passed down from that function.
5584 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5587 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5590 gcc_assert (stmts_are_full_exprs_p ());
5591 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5594 /* Verify INIT (the initializer for DECL), and record the
5595 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5596 grok_reference_init.
5598 If the return value is non-NULL, it is an expression that must be
5599 evaluated dynamically to initialize DECL. */
5602 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5604 tree type
= TREE_TYPE (decl
);
5605 tree init_code
= NULL
;
5606 tree extra_init
= NULL_TREE
;
5609 /* Things that are going to be initialized need to have complete
5611 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5613 if (DECL_HAS_VALUE_EXPR_P (decl
))
5615 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5616 it doesn't have storage to be initialized. */
5617 gcc_assert (init
== NULL_TREE
);
5621 if (type
== error_mark_node
)
5622 /* We will have already complained. */
5625 if (TREE_CODE (type
) == ARRAY_TYPE
)
5627 if (check_array_initializer (decl
, type
, init
))
5630 else if (!COMPLETE_TYPE_P (type
))
5632 error ("%q#D has incomplete type", decl
);
5633 TREE_TYPE (decl
) = error_mark_node
;
5637 /* There is no way to make a variable-sized class type in GNU C++. */
5638 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5640 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5642 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5643 if (SCALAR_TYPE_P (type
))
5647 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5648 init
= build_zero_init (type
, NULL_TREE
, false);
5650 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5652 error ("scalar object %qD requires one element in initializer",
5654 TREE_TYPE (decl
) = error_mark_node
;
5660 if (TREE_CODE (decl
) == CONST_DECL
)
5662 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5664 DECL_INITIAL (decl
) = init
;
5666 gcc_assert (init
!= NULL_TREE
);
5669 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5671 else if (init
|| type_build_ctor_call (type
)
5672 || TREE_CODE (type
) == REFERENCE_TYPE
)
5674 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5676 init
= grok_reference_init (decl
, type
, init
, flags
);
5677 flags
|= LOOKUP_ALREADY_DIGESTED
;
5680 check_for_uninitialized_const_var (decl
);
5681 /* Do not reshape constructors of vectors (they don't need to be
5683 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5685 if (is_std_init_list (type
))
5687 init
= perform_implicit_conversion (type
, init
,
5688 tf_warning_or_error
);
5689 flags
|= LOOKUP_ALREADY_DIGESTED
;
5691 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5693 /* Don't reshape if the class has constructors. */
5694 if (cxx_dialect
== cxx98
)
5695 error ("in C++98 %qD must be initialized by constructor, "
5699 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5701 error ("opaque vector types cannot be initialized");
5702 init
= error_mark_node
;
5706 init
= reshape_init (type
, init
, tf_warning_or_error
);
5707 if (SCALAR_TYPE_P (type
))
5708 check_narrowing (type
, init
);
5712 /* If DECL has an array type without a specific bound, deduce the
5713 array size from the initializer. */
5714 maybe_deduce_size_from_array_init (decl
, init
);
5715 type
= TREE_TYPE (decl
);
5716 if (type
== error_mark_node
)
5719 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5720 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5721 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5722 && CP_AGGREGATE_TYPE_P (type
)
5723 && (CLASS_TYPE_P (type
)
5724 || !TYPE_NEEDS_CONSTRUCTING (type
)
5725 || type_has_extended_temps (type
))))
5727 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5729 /* A constructor call is a non-trivial initializer even if
5730 it isn't explicitly written. */
5731 if (TREE_SIDE_EFFECTS (init_code
))
5732 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5734 /* If this is a constexpr initializer, expand_default_init will
5735 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5736 case, pull the initializer back out and pass it down into
5737 store_init_value. */
5738 while (TREE_CODE (init_code
) == EXPR_STMT
5739 || TREE_CODE (init_code
) == CONVERT_EXPR
)
5740 init_code
= TREE_OPERAND (init_code
, 0);
5741 if (TREE_CODE (init_code
) == INIT_EXPR
)
5743 init
= TREE_OPERAND (init_code
, 1);
5744 init_code
= NULL_TREE
;
5745 /* Don't call digest_init; it's unnecessary and will complain
5746 about aggregate initialization of non-aggregate classes. */
5747 flags
|= LOOKUP_ALREADY_DIGESTED
;
5749 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
5751 /* Declared constexpr, but no suitable initializer; massage
5752 init appropriately so we can pass it into store_init_value
5754 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5755 init
= finish_compound_literal (type
, init
,
5756 tf_warning_or_error
);
5757 else if (CLASS_TYPE_P (type
)
5758 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
5760 init
= build_functional_cast (type
, init
, tf_none
);
5761 if (TREE_CODE (init
) == TARGET_EXPR
)
5762 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
5764 init_code
= NULL_TREE
;
5770 if (init
&& TREE_CODE (init
) != TREE_VEC
)
5772 /* In aggregate initialization of a variable, each element
5773 initialization is a full-expression because there is no
5774 enclosing expression. */
5775 gcc_assert (stmts_are_full_exprs_p ());
5777 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
5779 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5780 && DECL_INITIAL (decl
)
5781 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5782 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5783 warning (0, "array %qD initialized by parenthesized string literal %qE",
5784 decl
, DECL_INITIAL (decl
));
5790 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
5791 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
5792 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
5793 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
5796 check_for_uninitialized_const_var (decl
);
5799 if (init
&& init
!= error_mark_node
)
5800 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5803 init_code
= add_stmt_to_compound (extra_init
, init_code
);
5805 if (init_code
&& DECL_IN_AGGR_P (decl
))
5807 static int explained
= 0;
5809 if (cxx_dialect
< cxx11
)
5810 error ("initializer invalid for static member with constructor");
5812 error ("non-constant in-class initialization invalid for static "
5813 "member %qD", decl
);
5816 error ("(an out of class initialization is required)");
5824 /* If DECL is not a local variable, give it RTL. */
5827 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5829 int toplev
= toplevel_bindings_p ();
5831 const char *filename
;
5833 /* Set the DECL_ASSEMBLER_NAME for the object. */
5836 /* The `register' keyword, when used together with an
5837 asm-specification, indicates that the variable should be
5838 placed in a particular register. */
5839 if (VAR_P (decl
) && DECL_REGISTER (decl
))
5841 set_user_assembler_name (decl
, asmspec
);
5842 DECL_HARD_REGISTER (decl
) = 1;
5846 if (TREE_CODE (decl
) == FUNCTION_DECL
5847 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5848 set_builtin_user_assembler_name (decl
, asmspec
);
5849 set_user_assembler_name (decl
, asmspec
);
5853 /* Handle non-variables up front. */
5856 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5860 /* If we see a class member here, it should be a static data
5862 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5864 gcc_assert (TREE_STATIC (decl
));
5865 /* An in-class declaration of a static data member should be
5866 external; it is only a declaration, and not a definition. */
5867 if (init
== NULL_TREE
)
5868 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5871 /* We don't create any RTL for local variables. */
5872 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5875 /* We defer emission of local statics until the corresponding
5876 DECL_EXPR is expanded. */
5877 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5879 /* We try to defer namespace-scope static constants so that they are
5880 not emitted into the object file unnecessarily. */
5881 filename
= LOCATION_FILE (input_location
);
5882 if (!DECL_VIRTUAL_P (decl
)
5883 && TREE_READONLY (decl
)
5884 && DECL_INITIAL (decl
) != NULL_TREE
5885 && DECL_INITIAL (decl
) != error_mark_node
5887 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5889 && !TREE_PUBLIC (decl
))
5891 /* Fool with the linkage of static consts according to #pragma
5893 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5894 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5896 TREE_PUBLIC (decl
) = 1;
5897 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5902 /* Likewise for template instantiations. */
5903 else if (DECL_LANG_SPECIFIC (decl
)
5904 && DECL_IMPLICIT_INSTANTIATION (decl
))
5907 /* If we're not deferring, go ahead and assemble the variable. */
5909 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5912 /* walk_tree helper for wrap_temporary_cleanups, below. */
5915 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5917 /* Stop at types or full-expression boundaries. */
5918 if (TYPE_P (*stmt_p
)
5919 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
5925 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5927 tree guard
= (tree
)data
;
5928 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5930 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5931 /* Tell honor_protect_cleanup_actions to handle this as a separate
5933 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5935 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5941 /* We're initializing a local variable which has a cleanup GUARD. If there
5942 are any temporaries used in the initializer INIT of this variable, we
5943 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5944 variable will be cleaned up properly if one of them throws.
5946 Unfortunately, there's no way to express this properly in terms of
5947 nesting, as the regions for the temporaries overlap the region for the
5948 variable itself; if there are two temporaries, the variable needs to be
5949 the first thing destroyed if either of them throws. However, we only
5950 want to run the variable's cleanup if it actually got constructed. So
5951 we need to guard the temporary cleanups with the variable's cleanup if
5952 they are run on the normal path, but not if they are run on the
5953 exceptional path. We implement this by telling
5954 honor_protect_cleanup_actions to strip the variable cleanup from the
5955 exceptional path. */
5958 wrap_temporary_cleanups (tree init
, tree guard
)
5960 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5963 /* Generate code to initialize DECL (a local variable). */
5966 initialize_local_var (tree decl
, tree init
)
5968 tree type
= TREE_TYPE (decl
);
5972 gcc_assert (VAR_P (decl
)
5973 || TREE_CODE (decl
) == RESULT_DECL
);
5974 gcc_assert (!TREE_STATIC (decl
));
5976 if (DECL_SIZE (decl
) == NULL_TREE
)
5978 /* If we used it already as memory, it must stay in memory. */
5979 DECL_INITIAL (decl
) = NULL_TREE
;
5980 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5984 if (type
== error_mark_node
)
5987 /* Compute and store the initial value. */
5988 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5989 if (TREE_USED (type
))
5990 DECL_READ_P (decl
) = 1;
5992 /* Generate a cleanup, if necessary. */
5993 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
5995 /* Perform the initialization. */
5998 if (TREE_CODE (init
) == INIT_EXPR
5999 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init
, 1)))
6001 /* Stick simple initializers in DECL_INITIAL so that
6002 -Wno-init-self works (c++/34772). */
6003 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6004 DECL_INITIAL (decl
) = TREE_OPERAND (init
, 1);
6008 int saved_stmts_are_full_exprs_p
;
6010 /* If we're only initializing a single object, guard the
6011 destructors of any temporaries used in its initializer with
6012 its destructor. This isn't right for arrays because each
6013 element initialization is a full-expression. */
6014 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6015 wrap_temporary_cleanups (init
, cleanup
);
6017 gcc_assert (building_stmt_list_p ());
6018 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6019 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6020 finish_expr_stmt (init
);
6021 current_stmt_tree ()->stmts_are_full_exprs_p
=
6022 saved_stmts_are_full_exprs_p
;
6026 /* Set this to 0 so we can tell whether an aggregate which was
6027 initialized was ever used. Don't do this if it has a
6028 destructor, so we don't complain about the 'resource
6029 allocation is initialization' idiom. Now set
6030 attribute((unused)) on types so decls of that type will be
6031 marked used. (see TREE_USED, above.) */
6032 if (TYPE_NEEDS_CONSTRUCTING (type
)
6034 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6035 && DECL_NAME (decl
))
6036 TREE_USED (decl
) = 0;
6037 else if (already_used
)
6038 TREE_USED (decl
) = 1;
6041 finish_decl_cleanup (decl
, cleanup
);
6044 /* DECL is a VAR_DECL for a compiler-generated variable with static
6045 storage duration (like a virtual table) whose initializer is a
6046 compile-time constant. Initialize the variable and provide it to the
6050 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6053 gcc_assert (DECL_ARTIFICIAL (decl
));
6054 init
= build_constructor (TREE_TYPE (decl
), v
);
6055 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6056 DECL_INITIAL (decl
) = init
;
6057 DECL_INITIALIZED_P (decl
) = 1;
6058 determine_visibility (decl
);
6059 layout_var_decl (decl
);
6060 maybe_commonize_var (decl
);
6061 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6064 /* INIT is the initializer for a variable, as represented by the
6065 parser. Returns true iff INIT is type-dependent. */
6068 type_dependent_init_p (tree init
)
6070 if (TREE_CODE (init
) == TREE_LIST
)
6071 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6072 return any_type_dependent_elements_p (init
);
6073 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6074 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6076 vec
<constructor_elt
, va_gc
> *elts
;
6080 elts
= CONSTRUCTOR_ELTS (init
);
6081 nelts
= vec_safe_length (elts
);
6082 for (i
= 0; i
< nelts
; ++i
)
6083 if (type_dependent_init_p ((*elts
)[i
].value
))
6087 /* It must be a simple expression, e.g., int i = 3; */
6088 return type_dependent_expression_p (init
);
6093 /* INIT is the initializer for a variable, as represented by the
6094 parser. Returns true iff INIT is value-dependent. */
6097 value_dependent_init_p (tree init
)
6099 if (TREE_CODE (init
) == TREE_LIST
)
6100 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6101 return any_value_dependent_elements_p (init
);
6102 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6103 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6105 vec
<constructor_elt
, va_gc
> *elts
;
6109 elts
= CONSTRUCTOR_ELTS (init
);
6110 nelts
= vec_safe_length (elts
);
6111 for (i
= 0; i
< nelts
; ++i
)
6112 if (value_dependent_init_p ((*elts
)[i
].value
))
6116 /* It must be a simple expression, e.g., int i = 3; */
6117 return value_dependent_expression_p (init
);
6122 /* Finish processing of a declaration;
6123 install its line number and initial value.
6124 If the length of an array type is not known before,
6125 it must be determined now, from the initial value, or it is an error.
6127 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6128 true, then INIT is an integral constant expression.
6130 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6131 if the (init) syntax was used. */
6134 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6135 tree asmspec_tree
, int flags
)
6138 vec
<tree
, va_gc
> *cleanups
= NULL
;
6139 const char *asmspec
= NULL
;
6140 int was_readonly
= 0;
6141 bool var_definition_p
= false;
6144 if (decl
== error_mark_node
)
6149 error ("assignment (not initialization) in declaration");
6153 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6154 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6155 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6157 type
= TREE_TYPE (decl
);
6158 if (type
== error_mark_node
)
6161 /* If a name was specified, get the string. */
6162 if (at_namespace_scope_p ())
6163 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6164 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6165 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6167 if (current_class_type
6168 && CP_DECL_CONTEXT (decl
) == current_class_type
6169 && TYPE_BEING_DEFINED (current_class_type
)
6170 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6171 && (DECL_INITIAL (decl
) || init
))
6172 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6174 if (TREE_CODE (decl
) != FUNCTION_DECL
6175 && (auto_node
= type_uses_auto (type
)))
6178 if (init
== NULL_TREE
)
6180 if (DECL_LANG_SPECIFIC (decl
)
6181 && DECL_TEMPLATE_INSTANTIATION (decl
)
6182 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6184 /* init is null because we're deferring instantiating the
6185 initializer until we need it. Well, we need it now. */
6186 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6190 error ("declaration of %q#D has no initializer", decl
);
6191 TREE_TYPE (decl
) = error_mark_node
;
6195 if (TREE_CODE (d_init
) == TREE_LIST
)
6196 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6197 tf_warning_or_error
);
6198 d_init
= resolve_nondeduced_context (d_init
);
6199 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6201 if (type
== error_mark_node
)
6203 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6206 if (!ensure_literal_type_for_constexpr_object (decl
))
6207 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6210 && DECL_CLASS_SCOPE_P (decl
)
6211 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6212 check_static_variable_definition (decl
, type
);
6214 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6217 if (init
== ridpointers
[(int)RID_DELETE
])
6219 /* FIXME check this is 1st decl. */
6220 DECL_DELETED_FN (decl
) = 1;
6221 DECL_DECLARED_INLINE_P (decl
) = 1;
6222 DECL_INITIAL (decl
) = error_mark_node
;
6223 FOR_EACH_CLONE (clone
, decl
)
6225 DECL_DELETED_FN (clone
) = 1;
6226 DECL_DECLARED_INLINE_P (clone
) = 1;
6227 DECL_INITIAL (clone
) = error_mark_node
;
6231 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6233 if (defaultable_fn_check (decl
))
6234 DECL_DEFAULTED_FN (decl
) = 1;
6236 DECL_INITIAL (decl
) = NULL_TREE
;
6240 if (init
&& VAR_P (decl
))
6242 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6243 /* If DECL is a reference, then we want to know whether init is a
6244 reference constant; init_const_expr_p as passed tells us whether
6245 it's an rvalue constant. */
6246 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6247 init_const_expr_p
= potential_constant_expression (init
);
6248 if (init_const_expr_p
)
6250 /* Set these flags now for templates. We'll update the flags in
6251 store_init_value for instantiations. */
6252 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6253 if (decl_maybe_constant_var_p (decl
))
6254 TREE_CONSTANT (decl
) = 1;
6258 if (processing_template_decl
)
6260 bool type_dependent_p
;
6262 /* Add this declaration to the statement-tree. */
6263 if (at_function_scope_p ())
6264 add_decl_expr (decl
);
6266 type_dependent_p
= dependent_type_p (type
);
6268 if (check_for_bare_parameter_packs (init
))
6271 DECL_INITIAL (decl
) = NULL_TREE
;
6274 /* Generally, initializers in templates are expanded when the
6275 template is instantiated. But, if DECL is a variable constant
6276 then it can be used in future constant expressions, so its value
6277 must be available. */
6279 if (!VAR_P (decl
) || dependent_type_p (type
))
6280 /* We can't do anything if the decl has dependent type. */;
6282 && init_const_expr_p
6283 && !type_dependent_p
6284 && decl_maybe_constant_var_p (decl
)
6285 && !type_dependent_init_p (init
)
6286 && !value_dependent_init_p (init
))
6288 /* This variable seems to be a non-dependent constant, so process
6289 its initializer. If check_initializer returns non-null the
6290 initialization wasn't constant after all. */
6292 cleanups
= make_tree_vector ();
6293 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6294 if (init_code
== NULL_TREE
)
6296 release_tree_vector (cleanups
);
6298 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6300 /* Deduce array size even if the initializer is dependent. */
6301 maybe_deduce_size_from_array_init (decl
, init
);
6302 /* And complain about multiple initializers. */
6303 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6304 && !MAYBE_CLASS_TYPE_P (type
))
6305 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6306 tf_warning_or_error
);
6310 DECL_INITIAL (decl
) = init
;
6314 /* Just store non-static data member initializers for later. */
6315 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6316 DECL_INITIAL (decl
) = init
;
6318 /* Take care of TYPE_DECLs up front. */
6319 if (TREE_CODE (decl
) == TYPE_DECL
)
6321 if (type
!= error_mark_node
6322 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6324 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6325 warning (0, "shadowing previous type declaration of %q#D", decl
);
6326 set_identifier_type_value (DECL_NAME (decl
), decl
);
6329 /* If we have installed this as the canonical typedef for this
6330 type, and that type has not been defined yet, delay emitting
6331 the debug information for it, as we will emit it later. */
6332 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6333 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6334 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6336 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6341 /* A reference will be modified here, as it is initialized. */
6342 if (! DECL_EXTERNAL (decl
)
6343 && TREE_READONLY (decl
)
6344 && TREE_CODE (type
) == REFERENCE_TYPE
)
6347 TREE_READONLY (decl
) = 0;
6352 /* If this is a local variable that will need a mangled name,
6353 register it now. We must do this before processing the
6354 initializer for the variable, since the initialization might
6355 require a guard variable, and since the mangled name of the
6356 guard variable will depend on the mangled name of this
6358 if (DECL_FUNCTION_SCOPE_P (decl
)
6359 && TREE_STATIC (decl
)
6360 && !DECL_ARTIFICIAL (decl
))
6362 push_local_name (decl
);
6363 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6364 || DECL_DESTRUCTOR_P (current_function_decl
))
6365 /* Normally local_decls is populated during GIMPLE lowering,
6366 but [cd]tors are never actually compiled directly. We need
6367 to put statics on the list so we can deal with the label
6368 address extension. FIXME. */
6369 add_local_decl (cfun
, decl
);
6372 /* Convert the initializer to the type of DECL, if we have not
6373 already initialized DECL. */
6374 if (!DECL_INITIALIZED_P (decl
)
6375 /* If !DECL_EXTERNAL then DECL is being defined. In the
6376 case of a static data member initialized inside the
6377 class-specifier, there can be an initializer even if DECL
6378 is *not* defined. */
6379 && (!DECL_EXTERNAL (decl
) || init
))
6381 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6384 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6385 /* Allow libjava/prims.cc define primitive classes. */
6386 if (init
!= NULL_TREE
6387 || jclass
== NULL_TREE
6388 || TREE_CODE (jclass
) != TYPE_DECL
6389 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6390 || !same_type_ignoring_top_level_qualifiers_p
6391 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6392 error ("Java object %qD not allocated with %<new%>", decl
);
6395 cleanups
= make_tree_vector ();
6396 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6402 The memory occupied by any object of static storage
6403 duration is zero-initialized at program startup before
6404 any other initialization takes place.
6406 We cannot create an appropriate initializer until after
6407 the type of DECL is finalized. If DECL_INITIAL is set,
6408 then the DECL is statically initialized, and any
6409 necessary zero-initialization has already been performed. */
6410 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6411 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6412 /*nelts=*/NULL_TREE
,
6413 /*static_storage_p=*/true);
6414 /* Remember that the initialization for this variable has
6416 DECL_INITIALIZED_P (decl
) = 1;
6417 /* This declaration is the definition of this variable,
6418 unless we are initializing a static data member within
6419 the class specifier. */
6420 if (!DECL_EXTERNAL (decl
))
6421 var_definition_p
= true;
6423 /* If the variable has an array type, lay out the type, even if
6424 there is no initializer. It is valid to index through the
6425 array, and we must get TYPE_ALIGN set correctly on the array
6427 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6430 if (TREE_STATIC (decl
)
6431 && !at_function_scope_p ()
6432 && current_function_decl
== NULL
)
6433 /* So decl is a global variable or a static member of a
6434 non local class. Record the types it uses
6435 so that we can decide later to emit debug info for them. */
6436 record_types_used_by_current_var_decl (decl
);
6438 else if (TREE_CODE (decl
) == FIELD_DECL
6439 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6440 error ("non-static data member %qD has Java class type", decl
);
6442 /* Add this declaration to the statement-tree. This needs to happen
6443 after the call to check_initializer so that the DECL_EXPR for a
6444 reference temp is added before the DECL_EXPR for the reference itself. */
6445 if (DECL_FUNCTION_SCOPE_P (decl
))
6446 add_decl_expr (decl
);
6448 /* Let the middle end know about variables and functions -- but not
6449 static data members in uninstantiated class templates. */
6450 if (VAR_OR_FUNCTION_DECL_P (decl
))
6454 layout_var_decl (decl
);
6455 maybe_commonize_var (decl
);
6458 /* This needs to happen after the linkage is set. */
6459 determine_visibility (decl
);
6461 if (var_definition_p
&& TREE_STATIC (decl
))
6463 /* If a TREE_READONLY variable needs initialization
6464 at runtime, it is no longer readonly and we need to
6465 avoid MEM_READONLY_P being set on RTL created for it. */
6468 if (TREE_READONLY (decl
))
6469 TREE_READONLY (decl
) = 0;
6472 else if (was_readonly
)
6473 TREE_READONLY (decl
) = 1;
6475 /* Likewise if it needs destruction. */
6476 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6477 TREE_READONLY (decl
) = 0;
6480 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6482 /* Check for abstractness of the type. Notice that there is no
6483 need to strip array types here since the check for those types
6484 is already done within create_array_type_for_decl. */
6485 abstract_virtuals_error (decl
, type
);
6487 if (TREE_TYPE (decl
) == error_mark_node
)
6488 /* No initialization required. */
6490 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6494 if (init
== ridpointers
[(int)RID_DEFAULT
])
6496 /* An out-of-class default definition is defined at
6497 the point where it is explicitly defaulted. */
6498 if (DECL_DELETED_FN (decl
))
6499 maybe_explain_implicit_delete (decl
);
6500 else if (DECL_INITIAL (decl
) == error_mark_node
)
6501 synthesize_method (decl
);
6504 error ("function %q#D is initialized like a variable", decl
);
6506 /* else no initialization required. */
6508 else if (DECL_EXTERNAL (decl
)
6509 && ! (DECL_LANG_SPECIFIC (decl
)
6510 && DECL_NOT_REALLY_EXTERN (decl
)))
6513 DECL_INITIAL (decl
) = init
;
6515 /* A variable definition. */
6516 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6517 /* Initialize the local variable. */
6518 initialize_local_var (decl
, init
);
6520 /* If a variable is defined, and then a subsequent
6521 definition with external linkage is encountered, we will
6522 get here twice for the same variable. We want to avoid
6523 calling expand_static_init more than once. For variables
6524 that are not static data members, we can call
6525 expand_static_init only when we actually process the
6526 initializer. It is not legal to redeclare a static data
6527 member, so this issue does not arise in that case. */
6528 else if (var_definition_p
&& TREE_STATIC (decl
))
6529 expand_static_init (decl
, init
);
6532 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6533 reference, insert it in the statement-tree now. */
6537 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6538 push_cleanup (decl
, t
, false);
6539 release_tree_vector (cleanups
);
6543 TREE_READONLY (decl
) = 1;
6545 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6548 /* Returns a declaration for a VAR_DECL as if:
6550 extern "C" TYPE NAME;
6552 had been seen. Used to create compiler-generated global
6556 declare_global_var (tree name
, tree type
)
6560 push_to_top_level ();
6561 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6562 TREE_PUBLIC (decl
) = 1;
6563 DECL_EXTERNAL (decl
) = 1;
6564 DECL_ARTIFICIAL (decl
) = 1;
6565 /* If the user has explicitly declared this variable (perhaps
6566 because the code we are compiling is part of a low-level runtime
6567 library), then it is possible that our declaration will be merged
6568 with theirs by pushdecl. */
6569 decl
= pushdecl (decl
);
6570 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6571 pop_from_top_level ();
6576 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6577 if "__cxa_atexit" is not being used) corresponding to the function
6578 to be called when the program exits. */
6581 get_atexit_fn_ptr_type (void)
6585 if (!atexit_fn_ptr_type_node
)
6588 if (flag_use_cxa_atexit
6589 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6590 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6591 arg_type
= ptr_type_node
;
6593 /* The parameter to "atexit" is "void (*)(void)". */
6594 arg_type
= NULL_TREE
;
6596 fn_type
= build_function_type_list (void_type_node
,
6597 arg_type
, NULL_TREE
);
6598 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6601 return atexit_fn_ptr_type_node
;
6604 /* Returns a pointer to the `atexit' function. Note that if
6605 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6606 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6609 get_atexit_node (void)
6615 bool use_aeabi_atexit
;
6620 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6622 /* The declaration for `__cxa_atexit' is:
6624 int __cxa_atexit (void (*)(void *), void *, void *)
6626 We build up the argument types and then the function type
6628 tree argtype0
, argtype1
, argtype2
;
6630 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6631 /* First, build the pointer-to-function type for the first
6633 fn_ptr_type
= get_atexit_fn_ptr_type ();
6634 /* Then, build the rest of the argument types. */
6635 argtype2
= ptr_type_node
;
6636 if (use_aeabi_atexit
)
6638 argtype1
= fn_ptr_type
;
6639 argtype0
= ptr_type_node
;
6643 argtype1
= ptr_type_node
;
6644 argtype0
= fn_ptr_type
;
6646 /* And the final __cxa_atexit type. */
6647 fn_type
= build_function_type_list (integer_type_node
,
6648 argtype0
, argtype1
, argtype2
,
6650 if (use_aeabi_atexit
)
6651 name
= "__aeabi_atexit";
6653 name
= "__cxa_atexit";
6657 /* The declaration for `atexit' is:
6659 int atexit (void (*)());
6661 We build up the argument types and then the function type
6663 fn_ptr_type
= get_atexit_fn_ptr_type ();
6664 /* Build the final atexit type. */
6665 fn_type
= build_function_type_list (integer_type_node
,
6666 fn_ptr_type
, NULL_TREE
);
6670 /* Now, build the function declaration. */
6671 push_lang_context (lang_name_c
);
6672 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
6673 mark_used (atexit_fndecl
);
6674 pop_lang_context ();
6675 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6680 /* Like get_atexit_node, but for thread-local cleanups. */
6683 get_thread_atexit_node (void)
6685 /* The declaration for `__cxa_thread_atexit' is:
6687 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6688 tree fn_type
= build_function_type_list (integer_type_node
,
6689 get_atexit_fn_ptr_type (),
6690 ptr_type_node
, ptr_type_node
,
6693 /* Now, build the function declaration. */
6694 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
6695 ECF_LEAF
| ECF_NOTHROW
);
6696 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6699 /* Returns the __dso_handle VAR_DECL. */
6702 get_dso_handle_node (void)
6704 if (dso_handle_node
)
6705 return dso_handle_node
;
6707 /* Declare the variable. */
6708 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6711 #ifdef HAVE_GAS_HIDDEN
6712 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6713 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6716 return dso_handle_node
;
6719 /* Begin a new function with internal linkage whose job will be simply
6720 to destroy some particular variable. */
6722 static GTY(()) int start_cleanup_cnt
;
6725 start_cleanup_fn (void)
6730 bool use_cxa_atexit
= flag_use_cxa_atexit
6731 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6733 push_to_top_level ();
6735 /* No need to mangle this. */
6736 push_lang_context (lang_name_c
);
6738 /* Build the name of the function. */
6739 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6740 /* Build the function declaration. */
6741 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6742 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6743 /* It's a function with internal linkage, generated by the
6745 TREE_PUBLIC (fndecl
) = 0;
6746 DECL_ARTIFICIAL (fndecl
) = 1;
6747 /* Make the function `inline' so that it is only emitted if it is
6748 actually needed. It is unlikely that it will be inlined, since
6749 it is only called via a function pointer, but we avoid unnecessary
6750 emissions this way. */
6751 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6752 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6753 /* Build the parameter. */
6758 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6759 DECL_CONTEXT (parmdecl
) = fndecl
;
6760 TREE_USED (parmdecl
) = 1;
6761 DECL_READ_P (parmdecl
) = 1;
6762 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6766 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6768 pop_lang_context ();
6770 return current_function_decl
;
6773 /* Finish the cleanup function begun by start_cleanup_fn. */
6776 end_cleanup_fn (void)
6778 expand_or_defer_fn (finish_function (0));
6780 pop_from_top_level ();
6783 /* Generate code to handle the destruction of DECL, an object with
6784 static storage duration. */
6787 register_dtor_fn (tree decl
)
6794 bool ob_parm
, dso_parm
, use_dtor
;
6795 tree arg0
, arg1
, arg2
;
6798 type
= TREE_TYPE (decl
);
6799 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6800 return void_zero_node
;
6802 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
6803 "__aeabi_atexit"), and DECL is a class object, we can just pass the
6804 destructor to "__cxa_atexit"; we don't have to build a temporary
6805 function to do the cleanup. */
6806 dso_parm
= (flag_use_cxa_atexit
6807 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
6808 ob_parm
= (DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
6809 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
6814 /* Find the destructor. */
6815 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6816 gcc_assert (idx
>= 0);
6817 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
6818 /* Make sure it is accessible. */
6819 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
6820 tf_warning_or_error
);
6824 /* Call build_cleanup before we enter the anonymous function so
6825 that any access checks will be done relative to the current
6826 scope, rather than the scope of the anonymous function. */
6827 build_cleanup (decl
);
6829 /* Now start the function. */
6830 cleanup
= start_cleanup_fn ();
6832 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6833 to the original function, rather than the anonymous one. That
6834 will make the back end think that nested functions are in use,
6835 which causes confusion. */
6836 push_deferring_access_checks (dk_no_check
);
6837 fcall
= build_cleanup (decl
);
6838 pop_deferring_access_checks ();
6840 /* Create the body of the anonymous function. */
6841 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6842 finish_expr_stmt (fcall
);
6843 finish_compound_stmt (compound_stmt
);
6847 /* Call atexit with the cleanup function. */
6848 mark_used (cleanup
);
6849 cleanup
= build_address (cleanup
);
6851 if (DECL_THREAD_LOCAL_P (decl
))
6852 atex_node
= get_thread_atexit_node ();
6854 atex_node
= get_atexit_node ();
6858 /* We must convert CLEANUP to the type that "__cxa_atexit"
6860 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6861 /* "__cxa_atexit" will pass the address of DECL to the
6862 cleanup function. */
6864 addr
= build_address (decl
);
6865 /* The declared type of the parameter to "__cxa_atexit" is
6866 "void *". For plain "T*", we could just let the
6867 machinery in cp_build_function_call convert it -- but if the
6868 type is "cv-qualified T *", then we need to convert it
6869 before passing it in, to avoid spurious errors. */
6870 addr
= build_nop (ptr_type_node
, addr
);
6873 /* Since the cleanup functions we build ignore the address
6874 they're given, there's no reason to pass the actual address
6875 in, and, in general, it's cheaper to pass NULL than any
6877 addr
= null_pointer_node
;
6880 arg2
= cp_build_addr_expr (get_dso_handle_node (),
6881 tf_warning_or_error
);
6883 /* Just pass NULL to the dso handle parm if we don't actually
6884 have a DSO handle on this target. */
6885 arg2
= null_pointer_node
;
6891 if (!DECL_THREAD_LOCAL_P (decl
)
6892 && targetm
.cxx
.use_aeabi_atexit ())
6908 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
6909 arg0
, arg1
, arg2
, NULL_TREE
);
6912 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6913 is its initializer. Generate code to handle the construction
6914 and destruction of DECL. */
6917 expand_static_init (tree decl
, tree init
)
6919 gcc_assert (VAR_P (decl
));
6920 gcc_assert (TREE_STATIC (decl
));
6922 /* Some variables require no dynamic initialization. */
6924 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6926 /* Make sure the destructor is callable. */
6927 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6931 if (DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
6932 && !DECL_FUNCTION_SCOPE_P (decl
))
6935 error ("non-local variable %qD declared %<__thread%> "
6936 "needs dynamic initialization", decl
);
6938 error ("non-local variable %qD declared %<__thread%> "
6939 "has a non-trivial destructor", decl
);
6940 static bool informed
;
6943 inform (DECL_SOURCE_LOCATION (decl
),
6944 "C++11 %<thread_local%> allows dynamic initialization "
6951 if (DECL_FUNCTION_SCOPE_P (decl
))
6953 /* Emit code to perform this initialization but once. */
6954 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6955 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6956 tree guard
, guard_addr
;
6958 /* We don't need thread-safety code for thread-local vars. */
6959 bool thread_guard
= (flag_threadsafe_statics
6960 && !DECL_THREAD_LOCAL_P (decl
));
6962 /* Emit code to perform this initialization but once. This code
6965 static <type> guard;
6966 if (!guard.first_byte) {
6967 if (__cxa_guard_acquire (&guard)) {
6970 // Do initialization.
6971 flag = true; __cxa_guard_release (&guard);
6972 // Register variable for destruction at end of program.
6974 if (!flag) __cxa_guard_abort (&guard);
6978 Note that the `flag' variable is only set to 1 *after* the
6979 initialization is complete. This ensures that an exception,
6980 thrown during the construction, will cause the variable to
6981 reinitialized when we pass through this code again, as per:
6985 If the initialization exits by throwing an exception, the
6986 initialization is not complete, so it will be tried again
6987 the next time control enters the declaration.
6989 This process should be thread-safe, too; multiple threads
6990 should not be able to initialize the variable more than
6993 /* Create the guard variable. */
6994 guard
= get_guard (decl
);
6996 /* This optimization isn't safe on targets with relaxed memory
6997 consistency. On such targets we force synchronization in
6998 __cxa_guard_acquire. */
6999 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7001 /* Begin the conditional initialization. */
7002 if_stmt
= begin_if_stmt ();
7003 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
7004 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7009 tree vfntype
= NULL_TREE
;
7010 tree acquire_name
, release_name
, abort_name
;
7011 tree acquire_fn
, release_fn
, abort_fn
;
7012 guard_addr
= build_address (guard
);
7014 acquire_name
= get_identifier ("__cxa_guard_acquire");
7015 release_name
= get_identifier ("__cxa_guard_release");
7016 abort_name
= get_identifier ("__cxa_guard_abort");
7017 acquire_fn
= identifier_global_value (acquire_name
);
7018 release_fn
= identifier_global_value (release_name
);
7019 abort_fn
= identifier_global_value (abort_name
);
7021 acquire_fn
= push_library_fn
7022 (acquire_name
, build_function_type_list (integer_type_node
,
7023 TREE_TYPE (guard_addr
),
7025 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7026 if (!release_fn
|| !abort_fn
)
7027 vfntype
= build_function_type_list (void_type_node
,
7028 TREE_TYPE (guard_addr
),
7031 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7032 ECF_NOTHROW
| ECF_LEAF
);
7034 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7035 ECF_NOTHROW
| ECF_LEAF
);
7037 inner_if_stmt
= begin_if_stmt ();
7038 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7041 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7042 begin
= get_target_expr (boolean_false_node
);
7043 flag
= TARGET_EXPR_SLOT (begin
);
7045 TARGET_EXPR_CLEANUP (begin
)
7046 = build3 (COND_EXPR
, void_type_node
, flag
,
7048 build_call_n (abort_fn
, 1, guard_addr
));
7049 CLEANUP_EH_ONLY (begin
) = 1;
7051 /* Do the initialization itself. */
7052 init
= add_stmt_to_compound (begin
, init
);
7053 init
= add_stmt_to_compound
7054 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7055 init
= add_stmt_to_compound
7056 (init
, build_call_n (release_fn
, 1, guard_addr
));
7059 init
= add_stmt_to_compound (init
, set_guard (guard
));
7061 /* Use atexit to register a function for destroying this static
7063 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7065 finish_expr_stmt (init
);
7069 finish_compound_stmt (inner_then_clause
);
7070 finish_then_clause (inner_if_stmt
);
7071 finish_if_stmt (inner_if_stmt
);
7074 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7076 finish_compound_stmt (then_clause
);
7077 finish_then_clause (if_stmt
);
7078 finish_if_stmt (if_stmt
);
7081 else if (DECL_THREAD_LOCAL_P (decl
))
7082 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7084 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7088 /* Make TYPE a complete type based on INITIAL_VALUE.
7089 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7090 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7091 3 if the initializer list is empty (in pedantic mode). */
7094 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7097 tree type
, elt_type
;
7101 unsigned HOST_WIDE_INT i
;
7104 /* An array of character type can be initialized from a
7105 brace-enclosed string constant.
7107 FIXME: this code is duplicated from reshape_init. Probably
7108 we should just call reshape_init here? */
7109 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7110 && TREE_CODE (initial_value
) == CONSTRUCTOR
7111 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7113 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7114 tree value
= (*v
)[0].value
;
7116 if (TREE_CODE (value
) == STRING_CST
7117 && v
->length () == 1)
7118 initial_value
= value
;
7121 /* If any of the elements are parameter packs, we can't actually
7122 complete this type now because the array size is dependent. */
7123 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7125 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7128 if (PACK_EXPANSION_P (value
))
7134 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7136 /* We can create the array before the element type is complete, which
7137 means that we didn't have these two bits set in the original type
7138 either. In completing the type, we are expected to propagate these
7139 bits. See also complete_type which does the same thing for arrays
7142 if (TYPE_DOMAIN (type
))
7144 elt_type
= TREE_TYPE (type
);
7145 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7146 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7147 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7153 /* As above, but either give an error or reject zero-size arrays, depending
7157 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7158 bool do_default
, tsubst_flags_t complain
)
7161 bool sfinae
= !(complain
& tf_error
);
7162 /* In SFINAE context we can't be lenient about zero-size arrays. */
7165 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7171 /* Not an error. */;
7172 else if (failure
== 1)
7173 error ("initializer fails to determine size of %qT", *ptype
);
7174 else if (failure
== 2)
7177 error ("array size missing in %qT", *ptype
);
7179 else if (failure
== 3)
7180 error ("zero-size array %qT", *ptype
);
7181 *ptype
= error_mark_node
;
7186 /* Return zero if something is declared to be a member of type
7187 CTYPE when in the context of CUR_TYPE. STRING is the error
7188 message to print in that case. Otherwise, quietly return 1. */
7191 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7193 if (ctype
&& ctype
!= cur_type
)
7195 if (flags
== DTOR_FLAG
)
7196 error ("destructor for alien class %qT cannot be a member", ctype
);
7198 error ("constructor for alien class %qT cannot be a member", ctype
);
7204 /* Subroutine of `grokdeclarator'. */
7206 /* Generate errors possibly applicable for a given set of specifiers.
7207 This is for ARM $7.1.2. */
7210 bad_specifiers (tree object
,
7211 enum bad_spec_place type
,
7222 error ("%qD declared as a %<virtual%> variable", object
);
7224 error ("%qD declared as an %<inline%> variable", object
);
7226 error ("%<const%> and %<volatile%> function specifiers on "
7227 "%qD invalid in variable declaration", object
);
7231 error ("%qD declared as a %<virtual%> parameter", object
);
7233 error ("%qD declared as an %<inline%> parameter", object
);
7235 error ("%<const%> and %<volatile%> function specifiers on "
7236 "%qD invalid in parameter declaration", object
);
7240 error ("%qD declared as a %<virtual%> type", object
);
7242 error ("%qD declared as an %<inline%> type", object
);
7244 error ("%<const%> and %<volatile%> function specifiers on "
7245 "%qD invalid in type declaration", object
);
7249 error ("%qD declared as a %<virtual%> field", object
);
7251 error ("%qD declared as an %<inline%> field", object
);
7253 error ("%<const%> and %<volatile%> function specifiers on "
7254 "%qD invalid in field declaration", object
);
7260 error ("%q+D declared as a friend", object
);
7262 && (TREE_CODE (object
) == TYPE_DECL
7263 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7264 && !TYPE_REFFN_P (TREE_TYPE (object
))
7265 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7266 error ("%q+D declared with an exception specification", object
);
7269 /* DECL is a member function or static data member and is presently
7270 being defined. Check that the definition is taking place in a
7274 check_class_member_definition_namespace (tree decl
)
7276 /* These checks only apply to member functions and static data
7278 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7279 /* We check for problems with specializations in pt.c in
7280 check_specialization_namespace, where we can issue better
7282 if (processing_specialization
)
7284 /* There are no restrictions on the placement of
7285 explicit instantiations. */
7286 if (processing_explicit_instantiation
)
7290 A member function definition that appears outside of the
7291 class definition shall appear in a namespace scope enclosing
7292 the class definition.
7296 The definition for a static data member shall appear in a
7297 namespace scope enclosing the member's class definition. */
7298 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7299 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7300 decl
, DECL_CONTEXT (decl
));
7303 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7304 METHOD_TYPE for a non-static member function; QUALS are the
7305 cv-qualifiers that apply to the function. */
7308 build_this_parm (tree type
, cp_cv_quals quals
)
7313 cp_cv_quals this_quals
;
7315 if (CLASS_TYPE_P (type
))
7318 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7319 this_type
= build_pointer_type (this_type
);
7322 this_type
= type_of_this_parm (type
);
7323 /* The `this' parameter is implicitly `const'; it cannot be
7325 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7326 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7327 parm
= build_artificial_parm (this_identifier
, qual_type
);
7328 cp_apply_type_quals_to_decl (this_quals
, parm
);
7332 /* DECL is a static member function. Complain if it was declared
7333 with function-cv-quals. */
7336 check_static_quals (tree decl
, cp_cv_quals quals
)
7338 if (quals
!= TYPE_UNQUALIFIED
)
7339 error ("static member function %q#D declared with type qualifiers",
7343 /* Helper function. Replace the temporary this parameter injected
7344 during cp_finish_omp_declare_simd with the real this parameter. */
7347 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7349 tree this_parm
= (tree
) data
;
7350 if (TREE_CODE (*tp
) == PARM_DECL
7351 && DECL_NAME (*tp
) == this_identifier
7352 && *tp
!= this_parm
)
7354 else if (TYPE_P (*tp
))
7359 /* CTYPE is class type, or null if non-class.
7360 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7362 DECLARATOR is the function's name.
7363 PARMS is a chain of PARM_DECLs for the function.
7364 VIRTUALP is truthvalue of whether the function is virtual or not.
7365 FLAGS are to be passed through to `grokclassfn'.
7366 QUALS are qualifiers indicating whether the function is `const'
7368 RAISES is a list of exceptions that this function can raise.
7369 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7370 not look, and -1 if we should not call `grokclassfn' at all.
7372 SFK is the kind of special function (if any) for the new function.
7374 Returns `NULL_TREE' if something goes wrong, after issuing
7375 applicable error messages. */
7378 grokfndecl (tree ctype
,
7382 tree orig_declarator
,
7384 enum overload_flags flags
,
7386 cp_ref_qualifier rqual
,
7392 special_function_kind sfk
,
7397 location_t location
)
7400 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7404 type
= build_ref_qualified_type (type
, rqual
);
7406 type
= build_exception_variant (type
, raises
);
7408 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7410 /* If we have an explicit location, use it, otherwise use whatever
7411 build_lang_decl used (probably input_location). */
7412 if (location
!= UNKNOWN_LOCATION
)
7413 DECL_SOURCE_LOCATION (decl
) = location
;
7415 if (TREE_CODE (type
) == METHOD_TYPE
)
7418 parm
= build_this_parm (type
, quals
);
7419 DECL_CHAIN (parm
) = parms
;
7422 DECL_ARGUMENTS (decl
) = parms
;
7423 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7424 DECL_CONTEXT (t
) = decl
;
7425 /* Propagate volatile out from type to decl. */
7426 if (TYPE_VOLATILE (type
))
7427 TREE_THIS_VOLATILE (decl
) = 1;
7429 /* Setup decl according to sfk. */
7432 case sfk_constructor
:
7433 case sfk_copy_constructor
:
7434 case sfk_move_constructor
:
7435 DECL_CONSTRUCTOR_P (decl
) = 1;
7437 case sfk_destructor
:
7438 DECL_DESTRUCTOR_P (decl
) = 1;
7444 /* If pointers to member functions use the least significant bit to
7445 indicate whether a function is virtual, ensure a pointer
7446 to this function will have that bit clear. */
7447 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7448 && TREE_CODE (type
) == METHOD_TYPE
7449 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7450 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7453 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7457 ("defining explicit specialization %qD in friend declaration",
7461 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7462 tree args
= TREE_OPERAND (orig_declarator
, 1);
7464 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7466 /* Something like `template <class T> friend void f<T>()'. */
7467 error ("invalid use of template-id %qD in declaration "
7468 "of primary template",
7474 /* A friend declaration of the form friend void f<>(). Record
7475 the information in the TEMPLATE_ID_EXPR. */
7476 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7478 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7479 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7481 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7482 if (TREE_PURPOSE (t
)
7483 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7485 error ("default arguments are not allowed in declaration "
7486 "of friend template specialization %qD",
7492 error ("%<inline%> is not allowed in declaration of friend "
7493 "template specialization %qD",
7496 error ("%<constexpr%> is not allowed in declaration of friend "
7497 "template specialization %qD",
7504 /* If this decl has namespace scope, set that up. */
7506 set_decl_namespace (decl
, in_namespace
, friendp
);
7508 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7510 /* `main' and builtins have implicit 'C' linkage. */
7511 if ((MAIN_NAME_P (declarator
)
7512 || (IDENTIFIER_LENGTH (declarator
) > 10
7513 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7514 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7515 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
7516 || (targetcm
.cxx_implicit_extern_c
7517 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
7518 && current_lang_name
== lang_name_cplusplus
7519 && ctype
== NULL_TREE
7520 && DECL_FILE_SCOPE_P (decl
))
7521 SET_DECL_LANGUAGE (decl
, lang_c
);
7523 /* Should probably propagate const out from type to decl I bet (mrs). */
7526 DECL_STATIC_FUNCTION_P (decl
) = 1;
7527 DECL_CONTEXT (decl
) = ctype
;
7532 DECL_CONTEXT (decl
) = ctype
;
7534 check_class_member_definition_namespace (decl
);
7537 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7539 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7540 error ("cannot declare %<::main%> to be a template");
7542 error ("cannot declare %<::main%> to be inline");
7544 error ("cannot declare %<::main%> to be constexpr");
7546 error ("cannot declare %<::main%> to be static");
7551 /* Members of anonymous types and local classes have no linkage; make
7552 them internal. If a typedef is made later, this will be changed. */
7553 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
7554 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7557 if (publicp
&& cxx_dialect
== cxx98
)
7559 /* [basic.link]: A name with no linkage (notably, the name of a class
7560 or enumeration declared in a local scope) shall not be used to
7561 declare an entity with linkage.
7563 DR 757 relaxes this restriction for C++0x. */
7564 t
= no_linkage_check (TREE_TYPE (decl
),
7565 /*relaxed_p=*/false);
7568 if (TYPE_ANONYMOUS_P (t
))
7570 if (DECL_EXTERN_C_P (decl
))
7571 /* Allow this; it's pretty common in C. */;
7574 permerror (input_location
, "anonymous type with no linkage "
7575 "used to declare function %q#D with linkage",
7577 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7578 permerror (input_location
, "%q+#D does not refer to the unqualified "
7579 "type, so it is not used for linkage",
7584 permerror (input_location
, "type %qT with no linkage used to "
7585 "declare function %q#D with linkage", t
, decl
);
7589 TREE_PUBLIC (decl
) = publicp
;
7592 DECL_INTERFACE_KNOWN (decl
) = 1;
7593 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7596 /* If the declaration was declared inline, mark it as such. */
7598 DECL_DECLARED_INLINE_P (decl
) = 1;
7600 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7602 DECL_EXTERNAL (decl
) = 1;
7603 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7608 ? G_("static member function %qD cannot have cv-qualifier")
7609 : G_("non-member function %qD cannot have cv-qualifier"),
7611 quals
= TYPE_UNQUALIFIED
;
7617 ? G_("static member function %qD cannot have ref-qualifier")
7618 : G_("non-member function %qD cannot have ref-qualifier"),
7620 rqual
= REF_QUAL_NONE
;
7624 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7625 && !grok_op_properties (decl
, /*complain=*/true))
7627 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7629 bool long_long_unsigned_p
;
7631 const char *suffix
= NULL
;
7632 /* [over.literal]/6: Literal operators shall not have C linkage. */
7633 if (DECL_LANGUAGE (decl
) == lang_c
)
7635 error ("literal operator with C linkage");
7639 if (DECL_NAMESPACE_SCOPE_P (decl
))
7641 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7644 error ("%qD has invalid argument list", decl
);
7648 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7649 if (long_long_unsigned_p
)
7651 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7652 warning (0, "integer suffix %<%s%>"
7653 " shadowed by implementation", suffix
);
7655 else if (long_double_p
)
7657 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7658 warning (0, "floating point suffix %<%s%>"
7659 " shadowed by implementation", suffix
);
7664 error ("%qD must be a non-member function", decl
);
7670 /* Make the init_value nonzero so pushdecl knows this is not
7671 tentative. error_mark_node is replaced later with the BLOCK. */
7672 DECL_INITIAL (decl
) = error_mark_node
;
7674 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7675 TREE_NOTHROW (decl
) = 1;
7679 /* Adjust "omp declare simd" attributes. */
7680 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
7684 for (attr
= ods
; attr
;
7685 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
7687 if (TREE_CODE (type
) == METHOD_TYPE
)
7688 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
7689 DECL_ARGUMENTS (decl
), NULL
);
7690 if (TREE_VALUE (attr
) != NULL_TREE
)
7692 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
7693 cl
= c_omp_declare_simd_clauses_to_numbers
7694 (DECL_ARGUMENTS (decl
), cl
);
7696 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
7698 TREE_VALUE (attr
) = NULL_TREE
;
7704 /* Caller will do the rest of this. */
7708 if (ctype
!= NULL_TREE
)
7709 grokclassfn (ctype
, decl
, flags
);
7712 if (cxx_dialect
>= cxx11
7713 && DECL_DESTRUCTOR_P (decl
)
7714 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7715 && !processing_template_decl
)
7716 deduce_noexcept_on_destructor (decl
);
7718 decl
= check_explicit_specialization (orig_declarator
, decl
,
7721 4 * (friendp
!= 0));
7722 if (decl
== error_mark_node
)
7725 if (DECL_STATIC_FUNCTION_P (decl
))
7726 check_static_quals (decl
, quals
);
7730 cplus_decl_attributes (&decl
, *attrlist
, 0);
7731 *attrlist
= NULL_TREE
;
7734 /* Check main's type after attributes have been applied. */
7735 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7737 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7740 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7742 error ("%<::main%> must return %<int%>");
7743 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7744 TREE_TYPE (decl
) = newtype
;
7747 check_main_parameter_types (decl
);
7750 if (ctype
!= NULL_TREE
7751 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
7754 tree old_decl
= check_classfn (ctype
, decl
,
7755 (processing_template_decl
7756 > template_class_depth (ctype
))
7757 ? current_template_parms
7760 if (old_decl
== error_mark_node
)
7768 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
7769 /* Because grokfndecl is always supposed to return a
7770 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7771 here. We depend on our callers to figure out that its
7772 really a template that's being returned. */
7773 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
7775 if (DECL_STATIC_FUNCTION_P (old_decl
)
7776 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7778 /* Remove the `this' parm added by grokclassfn. */
7779 revert_static_member_fn (decl
);
7780 check_static_quals (decl
, quals
);
7782 if (DECL_ARTIFICIAL (old_decl
))
7784 error ("definition of implicitly-declared %qD", old_decl
);
7787 else if (DECL_DEFAULTED_FN (old_decl
))
7789 error ("definition of explicitly-defaulted %q+D", decl
);
7790 error ("%q+#D explicitly defaulted here", old_decl
);
7794 /* Since we've smashed OLD_DECL to its
7795 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7796 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7797 decl
= DECL_TEMPLATE_RESULT (decl
);
7799 /* Attempt to merge the declarations. This can fail, in
7800 the case of some invalid specialization declarations. */
7801 pushed_scope
= push_scope (ctype
);
7802 ok
= duplicate_decls (decl
, old_decl
, friendp
);
7804 pop_scope (pushed_scope
);
7807 error ("no %q#D member function declared in class %qT",
7815 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
7818 if (ctype
== NULL_TREE
|| check
)
7822 DECL_VIRTUAL_P (decl
) = 1;
7827 /* decl is a FUNCTION_DECL.
7828 specifiers are the parsed virt-specifiers.
7830 Set flags to reflect the virt-specifiers.
7835 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
7837 if (decl
== NULL_TREE
)
7839 if (specifiers
& VIRT_SPEC_OVERRIDE
)
7840 DECL_OVERRIDE_P (decl
) = 1;
7841 if (specifiers
& VIRT_SPEC_FINAL
)
7842 DECL_FINAL_P (decl
) = 1;
7846 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7847 the linkage that DECL will receive in the object file. */
7850 set_linkage_for_static_data_member (tree decl
)
7852 /* A static data member always has static storage duration and
7853 external linkage. Note that static data members are forbidden in
7854 local classes -- the only situation in which a class has
7855 non-external linkage. */
7856 TREE_PUBLIC (decl
) = 1;
7857 TREE_STATIC (decl
) = 1;
7858 /* For non-template classes, static data members are always put
7859 out in exactly those files where they are defined, just as
7860 with ordinary namespace-scope variables. */
7861 if (!processing_template_decl
)
7862 DECL_INTERFACE_KNOWN (decl
) = 1;
7865 /* Create a VAR_DECL named NAME with the indicated TYPE.
7867 If SCOPE is non-NULL, it is the class type or namespace containing
7868 the variable. If SCOPE is NULL, the variable should is created in
7869 the innermost enclosings scope. */
7872 grokvardecl (tree type
,
7874 const cp_decl_specifier_seq
*declspecs
,
7880 tree explicit_scope
;
7882 gcc_assert (!name
|| identifier_p (name
));
7884 /* Compute the scope in which to place the variable, but remember
7885 whether or not that scope was explicitly specified by the user. */
7886 explicit_scope
= scope
;
7889 /* An explicit "extern" specifier indicates a namespace-scope
7891 if (declspecs
->storage_class
== sc_extern
)
7892 scope
= current_decl_namespace ();
7893 else if (!at_function_scope_p ())
7894 scope
= current_scope ();
7898 && (/* If the variable is a namespace-scope variable declared in a
7899 template, we need DECL_LANG_SPECIFIC. */
7900 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
7901 /* Similarly for namespace-scope variables with language linkage
7903 || (TREE_CODE (scope
) == NAMESPACE_DECL
7904 && current_lang_name
!= lang_name_cplusplus
)
7905 /* Similarly for static data members. */
7907 decl
= build_lang_decl (VAR_DECL
, name
, type
);
7909 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7911 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
7912 set_decl_namespace (decl
, explicit_scope
, 0);
7914 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
7916 if (declspecs
->storage_class
== sc_extern
)
7918 DECL_THIS_EXTERN (decl
) = 1;
7919 DECL_EXTERNAL (decl
) = !initialized
;
7922 if (DECL_CLASS_SCOPE_P (decl
))
7924 set_linkage_for_static_data_member (decl
);
7925 /* This function is only called with out-of-class definitions. */
7926 DECL_EXTERNAL (decl
) = 0;
7927 check_class_member_definition_namespace (decl
);
7929 /* At top level, either `static' or no s.c. makes a definition
7930 (perhaps tentative), and absence of `static' makes it public. */
7931 else if (toplevel_bindings_p ())
7933 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
7934 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7935 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7937 /* Not at top level, only `static' makes a static definition. */
7940 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
7941 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7944 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
7946 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
7947 if (declspecs
->gnu_thread_keyword_p
)
7948 DECL_GNU_TLS_P (decl
) = true;
7951 /* If the type of the decl has no linkage, make sure that we'll
7952 notice that in mark_used. */
7953 if (cxx_dialect
> cxx98
7954 && decl_linkage (decl
) != lk_none
7955 && DECL_LANG_SPECIFIC (decl
) == NULL
7956 && !DECL_EXTERN_C_P (decl
)
7957 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
7958 retrofit_lang_decl (decl
);
7960 if (TREE_PUBLIC (decl
))
7962 /* [basic.link]: A name with no linkage (notably, the name of a class
7963 or enumeration declared in a local scope) shall not be used to
7964 declare an entity with linkage.
7966 DR 757 relaxes this restriction for C++0x. */
7967 tree t
= (cxx_dialect
> cxx98
? NULL_TREE
7968 : no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false));
7971 if (TYPE_ANONYMOUS_P (t
))
7973 if (DECL_EXTERN_C_P (decl
))
7974 /* Allow this; it's pretty common in C. */
7978 /* DRs 132, 319 and 389 seem to indicate types with
7979 no linkage can only be used to declare extern "C"
7980 entities. Since it's not always an error in the
7981 ISO C++ 90 Standard, we only issue a warning. */
7982 warning (0, "anonymous type with no linkage used to declare "
7983 "variable %q#D with linkage", decl
);
7984 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7985 warning (0, "%q+#D does not refer to the unqualified "
7986 "type, so it is not used for linkage",
7991 warning (0, "type %qT with no linkage used to declare variable "
7992 "%q#D with linkage", t
, decl
);
7996 DECL_INTERFACE_KNOWN (decl
) = 1;
8001 /* Create and return a canonical pointer to member function type, for
8002 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8005 build_ptrmemfunc_type (tree type
)
8009 tree unqualified_variant
= NULL_TREE
;
8011 if (type
== error_mark_node
)
8014 /* If a canonical type already exists for this type, use it. We use
8015 this method instead of type_hash_canon, because it only does a
8016 simple equality check on the list of field members. */
8018 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8021 /* Make sure that we always have the unqualified pointer-to-member
8023 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
8025 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8027 t
= make_class_type (RECORD_TYPE
);
8028 xref_basetypes (t
, NULL_TREE
);
8030 /* Let the front end know this is a pointer to member function... */
8031 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8032 /* ... and not really a class type. */
8033 SET_CLASS_TYPE_P (t
, 0);
8035 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8038 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8040 DECL_CHAIN (field
) = fields
;
8043 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8045 /* Zap out the name so that the back end will give us the debugging
8046 information for this anonymous RECORD_TYPE. */
8047 TYPE_NAME (t
) = NULL_TREE
;
8049 /* If this is not the unqualified form of this pointer-to-member
8050 type, set the TYPE_MAIN_VARIANT for this type to be the
8051 unqualified type. Since they are actually RECORD_TYPEs that are
8052 not variants of each other, we must do this manually.
8053 As we just built a new type there is no need to do yet another copy. */
8054 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
8056 int type_quals
= cp_type_quals (type
);
8057 TYPE_READONLY (t
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
8058 TYPE_VOLATILE (t
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
8059 TYPE_RESTRICT (t
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
8060 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
8061 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
8062 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
8063 TREE_TYPE (TYPE_BINFO (t
)) = t
;
8066 /* Cache this pointer-to-member type so that we can find it again
8068 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8070 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8071 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8072 else if (TYPE_CANONICAL (type
) != type
)
8073 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8078 /* Create and return a pointer to data member type. */
8081 build_ptrmem_type (tree class_type
, tree member_type
)
8083 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8085 cp_cv_quals quals
= type_memfn_quals (member_type
);
8086 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8087 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8088 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8092 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8093 return build_offset_type (class_type
, member_type
);
8097 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8098 Check to see that the definition is valid. Issue appropriate error
8099 messages. Return 1 if the definition is particularly bad, or 0
8103 check_static_variable_definition (tree decl
, tree type
)
8105 /* Can't check yet if we don't know the type. */
8106 if (dependent_type_p (type
))
8108 /* If DECL is declared constexpr, we'll do the appropriate checks
8109 in check_initializer. */
8110 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8112 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8114 if (!COMPLETE_TYPE_P (type
))
8115 error ("in-class initialization of static data member %q#D of "
8116 "incomplete type", decl
);
8117 else if (literal_type_p (type
))
8118 permerror (input_location
,
8119 "%<constexpr%> needed for in-class initialization of "
8120 "static data member %q#D of non-integral type", decl
);
8122 error ("in-class initialization of static data member %q#D of "
8123 "non-literal type", decl
);
8127 /* Motion 10 at San Diego: If a static const integral data member is
8128 initialized with an integral constant expression, the initializer
8129 may appear either in the declaration (within the class), or in
8130 the definition, but not both. If it appears in the class, the
8131 member is a member constant. The file-scope definition is always
8133 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8135 error ("invalid in-class initialization of static data member "
8136 "of non-integral type %qT",
8140 else if (!CP_TYPE_CONST_P (type
))
8141 error ("ISO C++ forbids in-class initialization of non-const "
8142 "static member %qD",
8144 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8145 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8146 "%qD of non-integral type %qT", decl
, type
);
8151 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8152 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8153 expressions out into temporary variables so that walk_tree doesn't
8154 step into them (c++/15764). */
8157 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8159 struct pointer_set_t
*pset
= (struct pointer_set_t
*)data
;
8160 tree expr
= *expr_p
;
8161 if (TREE_CODE (expr
) == SAVE_EXPR
)
8163 tree op
= TREE_OPERAND (expr
, 0);
8164 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8165 if (TREE_SIDE_EFFECTS (op
))
8166 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8169 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8174 /* Entry point for the above. */
8177 stabilize_vla_size (tree size
)
8179 struct pointer_set_t
*pset
= pointer_set_create ();
8180 /* Break out any function calls into temporary variables. */
8181 cp_walk_tree (&size
, stabilize_save_expr_r
, pset
, pset
);
8182 pointer_set_destroy (pset
);
8185 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8186 not inside of SAVE_EXPR and fold them. */
8189 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8191 tree expr
= *expr_p
;
8192 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8194 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8196 *(bool *)data
= true;
8197 if (SIZEOF_EXPR_TYPE_P (expr
))
8198 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8199 SIZEOF_EXPR
, false);
8200 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8201 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8204 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8206 if (expr
== error_mark_node
)
8207 expr
= size_one_node
;
8214 /* Given the SIZE (i.e., number of elements) in an array, compute an
8215 appropriate index type for the array. If non-NULL, NAME is the
8216 name of the thing being declared. */
8219 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8223 tree abi_1_itype
= NULL_TREE
;
8225 if (error_operand_p (size
))
8226 return error_mark_node
;
8228 if (!type_dependent_expression_p (size
))
8230 tree type
= TREE_TYPE (size
);
8232 mark_rvalue_use (size
);
8234 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8235 && TREE_SIDE_EFFECTS (size
))
8236 /* In C++98, we mark a non-constant array bound with a magic
8237 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8240 size
= fold_non_dependent_expr_sfinae (size
, complain
);
8242 if (CLASS_TYPE_P (type
)
8243 && CLASSTYPE_LITERAL_P (type
))
8245 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8248 if (!(complain
& tf_error
))
8249 return error_mark_node
;
8251 error ("size of array %qD has non-integral type %qT",
8254 error ("size of array has non-integral type %qT", type
);
8255 size
= integer_one_node
;
8257 if (size
== error_mark_node
)
8258 return error_mark_node
;
8259 type
= TREE_TYPE (size
);
8260 /* We didn't support this case in GCC 3.2, so don't bother
8261 trying to model it now in ABI v1. */
8262 abi_1_itype
= error_mark_node
;
8265 size
= maybe_constant_value (size
);
8266 if (!TREE_CONSTANT (size
))
8270 if (error_operand_p (size
))
8271 return error_mark_node
;
8273 /* The array bound must be an integer type. */
8274 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8276 if (!(complain
& tf_error
))
8277 return error_mark_node
;
8279 error ("size of array %qD has non-integral type %qT", name
, type
);
8281 error ("size of array has non-integral type %qT", type
);
8282 size
= integer_one_node
;
8283 type
= TREE_TYPE (size
);
8287 /* A type is dependent if it is...an array type constructed from any
8288 dependent type or whose size is specified by a constant expression
8289 that is value-dependent. */
8290 /* We can only call value_dependent_expression_p on integral constant
8291 expressions; treat non-constant expressions as dependent, too. */
8292 if (processing_template_decl
8293 && (type_dependent_expression_p (size
)
8294 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8296 /* We cannot do any checking for a SIZE that isn't known to be
8297 constant. Just build the index type and mark that it requires
8298 structural equality checks. */
8299 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8300 size
, size_one_node
));
8301 TYPE_DEPENDENT_P (itype
) = 1;
8302 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8303 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8307 if (!abi_version_at_least (2) && processing_template_decl
8308 && abi_1_itype
== NULL_TREE
)
8309 /* For abi-1, we handled all instances in templates the same way,
8310 even when they were non-dependent. This affects the manglings
8311 produced. So, we do the normal checking for non-dependent
8312 sizes, but at the end we'll return the same type that abi-1
8313 would have, but with TYPE_CANONICAL set to the "right"
8314 value that the current ABI would provide. */
8315 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8316 osize
, integer_one_node
));
8318 /* Normally, the array-bound will be a constant. */
8319 if (TREE_CODE (size
) == INTEGER_CST
)
8321 /* Check to see if the array bound overflowed. Make that an
8322 error, no matter how generous we're being. */
8323 constant_expression_error (size
);
8325 /* An array must have a positive number of elements. */
8326 if (INT_CST_LT (size
, integer_zero_node
))
8328 if (!(complain
& tf_error
))
8329 return error_mark_node
;
8331 error ("size of array %qD is negative", name
);
8333 error ("size of array is negative");
8334 size
= integer_one_node
;
8336 /* As an extension we allow zero-sized arrays. */
8337 else if (integer_zerop (size
))
8339 if (!(complain
& tf_error
))
8340 /* We must fail if performing argument deduction (as
8341 indicated by the state of complain), so that
8342 another substitution can be found. */
8343 return error_mark_node
;
8344 else if (in_system_header_at (input_location
))
8345 /* Allow them in system headers because glibc uses them. */;
8347 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8349 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8352 else if (TREE_CONSTANT (size
)
8353 /* We don't allow VLAs at non-function scopes, or during
8354 tentative template substitution. */
8355 || !at_function_scope_p ()
8356 || (cxx_dialect
< cxx1y
&& !(complain
& tf_error
)))
8358 if (!(complain
& tf_error
))
8359 return error_mark_node
;
8360 /* `(int) &fn' is not a valid array bound. */
8362 error ("size of array %qD is not an integral constant-expression",
8365 error ("size of array is not an integral constant-expression");
8366 size
= integer_one_node
;
8368 else if (cxx_dialect
< cxx1y
&& pedantic
&& warn_vla
!= 0)
8371 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8373 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8375 else if (warn_vla
> 0)
8379 "variable length array %qD is used", name
);
8382 "variable length array is used");
8385 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8386 /* A variable sized array. */
8387 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8390 HOST_WIDE_INT saved_processing_template_decl
;
8392 /* Compute the index of the largest element in the array. It is
8393 one less than the number of elements in the array. We save
8394 and restore PROCESSING_TEMPLATE_DECL so that computations in
8395 cp_build_binary_op will be appropriately folded. */
8396 saved_processing_template_decl
= processing_template_decl
;
8397 processing_template_decl
= 0;
8398 itype
= cp_build_binary_op (input_location
,
8400 cp_convert (ssizetype
, size
, complain
),
8401 cp_convert (ssizetype
, integer_one_node
,
8404 itype
= fold (itype
);
8405 processing_template_decl
= saved_processing_template_decl
;
8407 if (!TREE_CONSTANT (itype
))
8409 /* A variable sized array. */
8410 itype
= variable_size (itype
);
8412 if (TREE_CODE (itype
) != SAVE_EXPR
)
8414 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8415 they might survive till gimplification. */
8416 tree newitype
= itype
;
8418 cp_walk_tree_without_duplicates (&newitype
,
8419 fold_sizeof_expr_r
, &found
);
8421 itype
= variable_size (fold (newitype
));
8424 stabilize_vla_size (itype
);
8426 if (cxx_dialect
>= cxx1y
&& flag_exceptions
)
8428 /* If the VLA bound is larger than half the address space,
8429 or less than zero, throw std::bad_array_length. */
8430 tree comp
= build2 (LT_EXPR
, boolean_type_node
, itype
,
8432 comp
= build3 (COND_EXPR
, void_type_node
, comp
,
8433 throw_bad_array_length (), void_zero_node
);
8434 finish_expr_stmt (comp
);
8436 else if (flag_sanitize
& SANITIZE_VLA
)
8438 /* From C++1y onwards, we throw an exception on a negative
8439 length size of an array; see above. */
8441 /* We have to add 1 -- in the ubsan routine we generate
8442 LE_EXPR rather than LT_EXPR. */
8443 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8444 build_one_cst (TREE_TYPE (itype
)));
8445 t
= ubsan_instrument_vla (input_location
, t
);
8446 finish_expr_stmt (t
);
8449 /* Make sure that there was no overflow when creating to a signed
8450 index type. (For example, on a 32-bit machine, an array with
8451 size 2^32 - 1 is too big.) */
8452 else if (TREE_CODE (itype
) == INTEGER_CST
8453 && TREE_OVERFLOW (itype
))
8455 if (!(complain
& tf_error
))
8456 return error_mark_node
;
8457 error ("overflow in array dimension");
8458 TREE_OVERFLOW (itype
) = 0;
8462 /* Create and return the appropriate index type. */
8463 if (abi_1_itype
&& abi_1_itype
!= error_mark_node
)
8465 tree t
= build_index_type (itype
);
8466 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
8467 itype
= abi_1_itype
;
8470 itype
= build_index_type (itype
);
8472 /* If the index type were dependent, we would have returned early, so
8473 remember that it isn't. */
8474 TYPE_DEPENDENT_P (itype
) = 0;
8475 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8479 /* Returns the scope (if any) in which the entity declared by
8480 DECLARATOR will be located. If the entity was declared with an
8481 unqualified name, NULL_TREE is returned. */
8484 get_scope_of_declarator (const cp_declarator
*declarator
)
8486 while (declarator
&& declarator
->kind
!= cdk_id
)
8487 declarator
= declarator
->declarator
;
8489 /* If the declarator-id is a SCOPE_REF, the scope in which the
8490 declaration occurs is the first operand. */
8492 && declarator
->u
.id
.qualifying_scope
)
8493 return declarator
->u
.id
.qualifying_scope
;
8495 /* Otherwise, the declarator is not a qualified name; the entity will
8496 be declared in the current scope. */
8500 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8501 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8505 create_array_type_for_decl (tree name
, tree type
, tree size
)
8507 tree itype
= NULL_TREE
;
8509 /* If things have already gone awry, bail now. */
8510 if (type
== error_mark_node
|| size
== error_mark_node
)
8511 return error_mark_node
;
8513 /* 8.3.4/1: If the type of the identifier of D contains the auto
8514 type-specifier, the program is ill-formed. */
8515 if (pedantic
&& type_uses_auto (type
))
8516 pedwarn (input_location
, OPT_Wpedantic
,
8517 "declaration of %qD as array of %<auto%>", name
);
8519 /* If there are some types which cannot be array elements,
8520 issue an error-message and return. */
8521 switch (TREE_CODE (type
))
8525 error ("declaration of %qD as array of void", name
);
8527 error ("creating array of void");
8528 return error_mark_node
;
8532 error ("declaration of %qD as array of functions", name
);
8534 error ("creating array of functions");
8535 return error_mark_node
;
8537 case REFERENCE_TYPE
:
8539 error ("declaration of %qD as array of references", name
);
8541 error ("creating array of references");
8542 return error_mark_node
;
8546 error ("declaration of %qD as array of function members", name
);
8548 error ("creating array of function members");
8549 return error_mark_node
;
8557 The constant expressions that specify the bounds of the arrays
8558 can be omitted only for the first member of the sequence. */
8559 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8562 error ("declaration of %qD as multidimensional array must "
8563 "have bounds for all dimensions except the first",
8566 error ("multidimensional array must have bounds for all "
8567 "dimensions except the first");
8569 return error_mark_node
;
8572 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
))
8573 pedwarn (input_location
, OPT_Wvla
, "array of array of runtime bound");
8575 /* Figure out the index type for the array. */
8577 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8580 T is called the array element type; this type shall not be [...] an
8581 abstract class type. */
8582 abstract_virtuals_error (name
, type
);
8584 return build_cplus_array_type (type
, itype
);
8587 /* Check that it's OK to declare a function with the indicated TYPE.
8588 SFK indicates the kind of special function (if any) that this
8589 function is. OPTYPE is the type given in a conversion operator
8590 declaration, or the class type for a constructor/destructor.
8591 Returns the actual return type of the function; that
8592 may be different than TYPE if an error occurs, or for certain
8593 special functions. */
8596 check_special_function_return_type (special_function_kind sfk
,
8602 case sfk_constructor
:
8604 error ("return type specification for constructor invalid");
8606 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8607 type
= build_pointer_type (optype
);
8609 type
= void_type_node
;
8612 case sfk_destructor
:
8614 error ("return type specification for destructor invalid");
8615 /* We can't use the proper return type here because we run into
8616 problems with ambiguous bases and covariant returns.
8617 Java classes are left unchanged because (void *) isn't a valid
8618 Java type, and we don't want to change the Java ABI. */
8619 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8620 type
= build_pointer_type (void_type_node
);
8622 type
= void_type_node
;
8625 case sfk_conversion
:
8627 error ("return type specified for %<operator %T%>", optype
);
8638 /* A variable or data member (whose unqualified name is IDENTIFIER)
8639 has been declared with the indicated TYPE. If the TYPE is not
8640 acceptable, issue an error message and return a type to use for
8641 error-recovery purposes. */
8644 check_var_type (tree identifier
, tree type
)
8646 if (VOID_TYPE_P (type
))
8649 error ("unnamed variable or field declared void");
8650 else if (identifier_p (identifier
))
8652 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8653 error ("variable or field %qE declared void", identifier
);
8656 error ("variable or field declared void");
8657 type
= error_mark_node
;
8663 /* Functions for adjusting the visibility of a tagged type and its nested
8664 types when it gets a name for linkage purposes from a typedef. */
8666 static void bt_reset_linkage (binding_entry
, void *);
8668 reset_type_linkage (tree type
)
8670 set_linkage_according_to_type (type
, TYPE_MAIN_DECL (type
));
8671 if (CLASS_TYPE_P (type
))
8672 binding_table_foreach (CLASSTYPE_NESTED_UTDS (type
), bt_reset_linkage
, NULL
);
8675 bt_reset_linkage (binding_entry b
, void */
*data*/
)
8677 reset_type_linkage (b
->type
);
8680 /* Given declspecs and a declarator (abstract or otherwise), determine
8681 the name and type of the object declared and construct a DECL node
8684 DECLSPECS points to the representation of declaration-specifier
8685 sequence that precedes declarator.
8687 DECL_CONTEXT says which syntactic context this declaration is in:
8688 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8689 FUNCDEF for a function definition. Like NORMAL but a few different
8690 error messages in each case. Return value may be zero meaning
8691 this definition is too screwy to try to parse.
8692 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8693 handle member functions (which have FIELD context).
8694 Return value may be zero meaning this definition is too screwy to
8696 PARM for a parameter declaration (either within a function prototype
8697 or before a function body). Make a PARM_DECL, or return void_type_node.
8698 TPARM for a template parameter declaration.
8699 CATCHPARM for a parameter declaration before a catch clause.
8700 TYPENAME if for a typename (in a cast or sizeof).
8701 Don't make a DECL node; just return the ..._TYPE node.
8702 FIELD for a struct or union field; make a FIELD_DECL.
8703 BITFIELD for a field with specified width.
8705 INITIALIZED is as for start_decl.
8707 ATTRLIST is a pointer to the list of attributes, which may be NULL
8708 if there are none; *ATTRLIST may be modified if attributes from inside
8709 the declarator should be applied to the declaration.
8711 When this function is called, scoping variables (such as
8712 CURRENT_CLASS_TYPE) should reflect the scope in which the
8713 declaration occurs, not the scope in which the new declaration will
8714 be placed. For example, on:
8718 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8721 Returns a DECL (if a declarator is present), a TYPE (if there is no
8722 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8726 grokdeclarator (const cp_declarator
*declarator
,
8727 cp_decl_specifier_seq
*declspecs
,
8728 enum decl_context decl_context
,
8732 tree type
= NULL_TREE
;
8734 int explicit_int128
= 0;
8735 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8736 int explicit_int
= 0;
8737 int explicit_char
= 0;
8738 int defaulted_int
= 0;
8740 tree typedef_decl
= NULL_TREE
;
8741 const char *name
= NULL
;
8742 tree typedef_type
= NULL_TREE
;
8743 /* True if this declarator is a function definition. */
8744 bool funcdef_flag
= false;
8745 cp_declarator_kind innermost_code
= cdk_error
;
8748 /* See the code below that used this. */
8749 tree decl_attr
= NULL_TREE
;
8752 /* Keep track of what sort of function is being processed
8753 so that we can warn about default return values, or explicit
8754 return values which do not match prescribed defaults. */
8755 special_function_kind sfk
= sfk_none
;
8757 tree dname
= NULL_TREE
;
8758 tree ctor_return_type
= NULL_TREE
;
8759 enum overload_flags flags
= NO_SPECIAL
;
8760 /* cv-qualifiers that apply to the declarator, for a declaration of
8761 a member function. */
8762 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8763 /* virt-specifiers that apply to the declarator, for a declaration of
8764 a member function. */
8765 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8766 /* ref-qualifier that applies to the declarator, for a declaration of
8767 a member function. */
8768 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
8769 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8771 tree raises
= NULL_TREE
;
8772 int template_count
= 0;
8773 tree returned_attrs
= NULL_TREE
;
8774 tree parms
= NULL_TREE
;
8775 const cp_declarator
*id_declarator
;
8776 /* The unqualified name of the declarator; either an
8777 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8778 tree unqualified_id
;
8779 /* The class type, if any, in which this entity is located,
8780 or NULL_TREE if none. Note that this value may be different from
8781 the current class type; for example if an attempt is made to declare
8782 "A::f" inside "B", this value will be "A". */
8783 tree ctype
= current_class_type
;
8784 /* The NAMESPACE_DECL for the namespace in which this entity is
8785 located. If an unqualified name is used to declare the entity,
8786 this value will be NULL_TREE, even if the entity is located at
8788 tree in_namespace
= NULL_TREE
;
8789 cp_storage_class storage_class
;
8790 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8791 bool type_was_error_mark_node
= false;
8792 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8793 bool template_type_arg
= false;
8794 bool template_parm_flag
= false;
8795 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
8796 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8797 source_location saved_loc
= input_location
;
8800 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8801 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8802 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8803 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8804 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8805 explicit_int128
= declspecs
->explicit_int128_p
;
8806 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8808 if (decl_context
== FUNCDEF
)
8809 funcdef_flag
= true, decl_context
= NORMAL
;
8810 else if (decl_context
== MEMFUNCDEF
)
8811 funcdef_flag
= true, decl_context
= FIELD
;
8812 else if (decl_context
== BITFIELD
)
8813 bitfield
= 1, decl_context
= FIELD
;
8814 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8815 template_type_arg
= true, decl_context
= TYPENAME
;
8816 else if (decl_context
== TPARM
)
8817 template_parm_flag
= true, decl_context
= PARM
;
8819 if (initialized
> 1)
8820 funcdef_flag
= true;
8822 /* Look inside a declarator for the name being declared
8823 and get it as a string, for an error message. */
8824 for (id_declarator
= declarator
;
8826 id_declarator
= id_declarator
->declarator
)
8828 if (id_declarator
->kind
!= cdk_id
)
8829 innermost_code
= id_declarator
->kind
;
8831 switch (id_declarator
->kind
)
8834 if (id_declarator
->declarator
8835 && id_declarator
->declarator
->kind
== cdk_id
)
8837 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8838 if (sfk
== sfk_destructor
)
8845 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8846 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8849 if (qualifying_scope
)
8851 if (at_function_scope_p ())
8855 A declarator-id shall not be qualified except
8858 None of the cases are permitted in block
8860 if (qualifying_scope
== global_namespace
)
8861 error ("invalid use of qualified-name %<::%D%>",
8863 else if (TYPE_P (qualifying_scope
))
8864 error ("invalid use of qualified-name %<%T::%D%>",
8865 qualifying_scope
, decl
);
8867 error ("invalid use of qualified-name %<%D::%D%>",
8868 qualifying_scope
, decl
);
8869 return error_mark_node
;
8871 else if (TYPE_P (qualifying_scope
))
8873 ctype
= qualifying_scope
;
8874 if (!MAYBE_CLASS_TYPE_P (ctype
))
8876 error ("%q#T is not a class or a namespace", ctype
);
8879 else if (innermost_code
!= cdk_function
8880 && current_class_type
8881 && !uniquely_derived_from_p (ctype
,
8882 current_class_type
))
8884 error ("invalid use of qualified-name %<%T::%D%>",
8885 qualifying_scope
, decl
);
8886 return error_mark_node
;
8889 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
8890 in_namespace
= qualifying_scope
;
8892 switch (TREE_CODE (decl
))
8898 if (innermost_code
!= cdk_function
)
8900 error ("declaration of %qD as non-function", decl
);
8901 return error_mark_node
;
8903 else if (!qualifying_scope
8904 && !(current_class_type
&& at_class_scope_p ()))
8906 error ("declaration of %qD as non-member", decl
);
8907 return error_mark_node
;
8910 type
= TREE_OPERAND (decl
, 0);
8912 type
= constructor_name (type
);
8913 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
8918 case TEMPLATE_ID_EXPR
:
8920 tree fns
= TREE_OPERAND (decl
, 0);
8923 if (!identifier_p (dname
))
8925 gcc_assert (is_overloaded_fn (dname
));
8926 dname
= DECL_NAME (get_first_fn (dname
));
8931 case IDENTIFIER_NODE
:
8932 if (identifier_p (decl
))
8935 if (C_IS_RESERVED_WORD (dname
))
8937 error ("declarator-id missing; using reserved word %qD",
8939 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8941 else if (!IDENTIFIER_TYPENAME_P (dname
))
8942 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8945 gcc_assert (flags
== NO_SPECIAL
);
8946 flags
= TYPENAME_FLAG
;
8947 ctor_return_type
= TREE_TYPE (dname
);
8948 sfk
= sfk_conversion
;
8949 if (is_typename_at_global_scope (dname
))
8950 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8952 name
= "<invalid operator>";
8969 return error_mark_node
;
8974 if (id_declarator
->kind
== cdk_id
)
8980 The declarator in a function-definition shall have the form
8981 D1 ( parameter-declaration-clause) ... */
8982 if (funcdef_flag
&& innermost_code
!= cdk_function
)
8984 error ("function definition does not declare parameters");
8985 return error_mark_node
;
8988 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8989 && innermost_code
!= cdk_function
8990 && ! (ctype
&& !declspecs
->any_specifiers_p
))
8992 error ("declaration of %qD as non-function", dname
);
8993 return error_mark_node
;
8997 && identifier_p (dname
)
8998 && UDLIT_OPER_P (dname
)
8999 && innermost_code
!= cdk_function
)
9001 error ("declaration of %qD as non-function", dname
);
9002 return error_mark_node
;
9005 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9009 error ("declaration of %qD as %<typedef%>", dname
);
9010 return error_mark_node
;
9012 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9014 error ("declaration of %qD as parameter", dname
);
9015 return error_mark_node
;
9019 /* Anything declared one level down from the top level
9020 must be one of the parameters of a function
9021 (because the body is at least two levels down). */
9023 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9024 by not allowing C++ class definitions to specify their parameters
9025 with xdecls (must be spec.d in the parmlist).
9027 Since we now wait to push a class scope until we are sure that
9028 we are in a legitimate method context, we must set oldcname
9029 explicitly (since current_class_name is not yet alive).
9031 We also want to avoid calling this a PARM if it is in a namespace. */
9033 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9035 cp_binding_level
*b
= current_binding_level
;
9036 current_binding_level
= b
->level_chain
;
9037 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9038 decl_context
= PARM
;
9039 current_binding_level
= b
;
9043 name
= decl_context
== PARM
? "parameter" : "type name";
9045 if (constexpr_p
&& typedef_p
)
9047 error ("%<constexpr%> cannot appear in a typedef declaration");
9048 return error_mark_node
;
9051 /* If there were multiple types specified in the decl-specifier-seq,
9052 issue an error message. */
9053 if (declspecs
->multiple_types_p
)
9055 error ("two or more data types in declaration of %qs", name
);
9056 return error_mark_node
;
9059 if (declspecs
->conflicting_specifiers_p
)
9061 error ("conflicting specifiers in declaration of %qs", name
);
9062 return error_mark_node
;
9065 /* Extract the basic type from the decl-specifier-seq. */
9066 type
= declspecs
->type
;
9067 if (type
== error_mark_node
)
9070 type_was_error_mark_node
= true;
9072 /* If the entire declaration is itself tagged as deprecated then
9073 suppress reports of deprecated items. */
9074 if (type
&& TREE_DEPRECATED (type
)
9075 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9076 warn_deprecated_use (type
, NULL_TREE
);
9077 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9079 typedef_decl
= type
;
9080 type
= TREE_TYPE (typedef_decl
);
9081 if (TREE_DEPRECATED (type
)
9082 && DECL_ARTIFICIAL (typedef_decl
)
9083 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9084 warn_deprecated_use (type
, NULL_TREE
);
9086 /* No type at all: default to `int', and set DEFAULTED_INT
9087 because it was not a user-defined typedef. */
9088 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
9090 /* These imply 'int'. */
9091 type
= integer_type_node
;
9095 explicit_int
= declspecs
->explicit_int_p
;
9096 explicit_char
= declspecs
->explicit_char_p
;
9099 /* See the code below that used this. */
9101 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9103 typedef_type
= type
;
9106 if (sfk
!= sfk_conversion
)
9107 ctor_return_type
= ctype
;
9109 if (sfk
!= sfk_none
)
9110 type
= check_special_function_return_type (sfk
, type
,
9112 else if (type
== NULL_TREE
)
9118 /* We handle `main' specially here, because 'main () { }' is so
9119 common. With no options, it is allowed. With -Wreturn-type,
9120 it is a warning. It is only an error with -pedantic-errors. */
9121 is_main
= (funcdef_flag
9122 && dname
&& identifier_p (dname
)
9123 && MAIN_NAME_P (dname
)
9124 && ctype
== NULL_TREE
9125 && in_namespace
== NULL_TREE
9126 && current_namespace
== global_namespace
);
9128 if (type_was_error_mark_node
)
9129 /* We've already issued an error, don't complain more. */;
9130 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9131 /* Allow it, sigh. */;
9133 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9135 pedwarn (input_location
, OPT_Wpedantic
,
9136 "ISO C++ forbids declaration of %qs with no type", name
);
9138 warning (OPT_Wreturn_type
,
9139 "ISO C++ forbids declaration of %qs with no type", name
);
9141 type
= integer_type_node
;
9146 if (explicit_int128
)
9148 if (int128_integer_type_node
== NULL_TREE
)
9150 error ("%<__int128%> is not supported by this target");
9151 explicit_int128
= false;
9153 else if (pedantic
&& ! in_system_header_at (input_location
))
9154 pedwarn (input_location
, OPT_Wpedantic
,
9155 "ISO C++ does not support %<__int128%> for %qs", name
);
9158 /* Now process the modifiers that were specified
9159 and check for invalid combinations. */
9161 /* Long double is a special combination. */
9162 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9165 type
= cp_build_qualified_type (long_double_type_node
,
9166 cp_type_quals (type
));
9169 /* Check all other uses of type modifiers. */
9171 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9175 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9176 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9177 else if (signed_p
&& unsigned_p
)
9178 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9179 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9180 error ("%<long long%> invalid for %qs", name
);
9181 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9182 error ("%<long%> invalid for %qs", name
);
9183 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9184 error ("%<short%> invalid for %qs", name
);
9185 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9186 error ("%<long%> or %<short%> invalid for %qs", name
);
9187 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_int128
)
9188 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9189 else if ((long_p
|| short_p
) && explicit_char
)
9190 error ("%<long%> or %<short%> specified with char for %qs", name
);
9191 else if (long_p
&& short_p
)
9192 error ("%<long%> and %<short%> specified together for %qs", name
);
9193 else if (type
== char16_type_node
|| type
== char32_type_node
)
9195 if (signed_p
|| unsigned_p
)
9196 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9197 else if (short_p
|| long_p
)
9198 error ("%<short%> or %<long%> invalid for %qs", name
);
9203 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_int128
&& pedantic
)
9205 pedwarn (input_location
, OPT_Wpedantic
,
9206 "long, short, signed or unsigned used invalidly for %qs",
9208 if (flag_pedantic_errors
)
9213 /* Discard the type modifiers if they are invalid. */
9224 /* Decide whether an integer type is signed or not.
9225 Optionally treat bitfields as signed by default. */
9229 It is implementation-defined whether a plain (neither
9230 explicitly signed or unsigned) char, short, int, or long
9231 bit-field is signed or unsigned.
9233 Naturally, we extend this to long long as well. Note that
9234 this does not include wchar_t. */
9235 || (bitfield
&& !flag_signed_bitfields
9237 /* A typedef for plain `int' without `signed' can be
9238 controlled just like plain `int', but a typedef for
9239 `signed int' cannot be so controlled. */
9241 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9242 && TREE_CODE (type
) == INTEGER_TYPE
9243 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9245 if (explicit_int128
)
9246 type
= int128_unsigned_type_node
;
9248 type
= long_long_unsigned_type_node
;
9250 type
= long_unsigned_type_node
;
9252 type
= short_unsigned_type_node
;
9253 else if (type
== char_type_node
)
9254 type
= unsigned_char_type_node
;
9255 else if (typedef_decl
)
9256 type
= unsigned_type_for (type
);
9258 type
= unsigned_type_node
;
9260 else if (signed_p
&& type
== char_type_node
)
9261 type
= signed_char_type_node
;
9262 else if (explicit_int128
)
9263 type
= int128_integer_type_node
;
9265 type
= long_long_integer_type_node
;
9267 type
= long_integer_type_node
;
9269 type
= short_integer_type_node
;
9271 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9273 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9274 error ("complex invalid for %qs", name
);
9275 /* If we just have "complex", it is equivalent to
9276 "complex double", but if any modifiers at all are specified it is
9277 the complex form of TYPE. E.g, "complex short" is
9278 "complex short int". */
9279 else if (defaulted_int
&& ! longlong
&& ! explicit_int128
9280 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
9281 type
= complex_double_type_node
;
9282 else if (type
== integer_type_node
)
9283 type
= complex_integer_type_node
;
9284 else if (type
== float_type_node
)
9285 type
= complex_float_type_node
;
9286 else if (type
== double_type_node
)
9287 type
= complex_double_type_node
;
9288 else if (type
== long_double_type_node
)
9289 type
= complex_long_double_type_node
;
9291 type
= build_complex_type (type
);
9294 type_quals
= TYPE_UNQUALIFIED
;
9295 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9296 type_quals
|= TYPE_QUAL_CONST
;
9297 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9298 type_quals
|= TYPE_QUAL_VOLATILE
;
9299 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9300 type_quals
|= TYPE_QUAL_RESTRICT
;
9301 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9302 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9305 /* If we're using the injected-class-name to form a compound type or a
9306 declaration, replace it with the underlying class so we don't get
9307 redundant typedefs in the debug output. But if we are returning the
9308 type unchanged, leave it alone so that it's available to
9309 maybe_get_template_decl_from_type_decl. */
9310 if (CLASS_TYPE_P (type
)
9311 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9312 && type
== TREE_TYPE (TYPE_NAME (type
))
9313 && (declarator
|| type_quals
))
9314 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9316 type_quals
|= cp_type_quals (type
);
9317 type
= cp_build_qualified_type_real
9318 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
9319 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9320 /* We might have ignored or rejected some of the qualifiers. */
9321 type_quals
= cp_type_quals (type
);
9324 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9325 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9326 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9328 storage_class
= declspecs
->storage_class
;
9329 if (storage_class
== sc_static
)
9330 staticp
= 1 + (decl_context
== FIELD
);
9332 if (virtualp
&& staticp
== 2)
9334 error ("member %qD cannot be declared both virtual and static", dname
);
9335 storage_class
= sc_none
;
9338 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9340 /* Issue errors about use of storage classes for parameters. */
9341 if (decl_context
== PARM
)
9345 error ("typedef declaration invalid in parameter declaration");
9346 return error_mark_node
;
9348 else if (template_parm_flag
&& storage_class
!= sc_none
)
9350 error ("storage class specified for template parameter %qs", name
);
9351 return error_mark_node
;
9353 else if (storage_class
== sc_static
9354 || storage_class
== sc_extern
9356 error ("storage class specifiers invalid in parameter declarations");
9358 /* Function parameters cannot be constexpr. If we saw one, moan
9359 and pretend it wasn't there. */
9362 error ("a parameter cannot be declared %<constexpr%>");
9367 /* Give error if `virtual' is used outside of class declaration. */
9369 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9371 error ("%<virtual%> outside class declaration");
9375 /* Static anonymous unions are dealt with here. */
9376 if (staticp
&& decl_context
== TYPENAME
9378 && ANON_AGGR_TYPE_P (declspecs
->type
))
9379 decl_context
= FIELD
;
9381 /* Warn about storage classes that are invalid for certain
9382 kinds of declarations (parameters, typenames, etc.). */
9385 && storage_class
!= sc_extern
9386 && storage_class
!= sc_static
)
9389 error ("multiple storage classes in declaration of %qs", name
);
9392 if (decl_context
!= NORMAL
9393 && ((storage_class
!= sc_none
9394 && storage_class
!= sc_mutable
)
9397 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9398 && (storage_class
== sc_register
9399 || storage_class
== sc_auto
))
9403 else if (decl_context
== FIELD
9404 /* C++ allows static class elements. */
9405 && storage_class
== sc_static
)
9406 /* C++ also allows inlines and signed and unsigned elements,
9407 but in those cases we don't come in here. */
9411 if (decl_context
== FIELD
)
9412 error ("storage class specified for %qs", name
);
9415 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9416 error ("storage class specified for parameter %qs", name
);
9418 error ("storage class specified for typename");
9420 if (storage_class
== sc_register
9421 || storage_class
== sc_auto
9422 || storage_class
== sc_extern
9424 storage_class
= sc_none
;
9427 else if (storage_class
== sc_extern
&& funcdef_flag
9428 && ! toplevel_bindings_p ())
9429 error ("nested function %qs declared %<extern%>", name
);
9430 else if (toplevel_bindings_p ())
9432 if (storage_class
== sc_auto
)
9433 error ("top-level declaration of %qs specifies %<auto%>", name
);
9436 && storage_class
!= sc_extern
9437 && storage_class
!= sc_static
)
9439 if (declspecs
->gnu_thread_keyword_p
)
9440 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9441 "declared %<__thread%>", name
);
9443 /* When thread_local is applied to a variable of block scope the
9444 storage-class-specifier static is implied if it does not appear
9446 storage_class
= declspecs
->storage_class
= sc_static
;
9450 if (storage_class
&& friendp
)
9452 error ("storage class specifiers invalid in friend function declarations");
9453 storage_class
= sc_none
;
9458 unqualified_id
= NULL_TREE
;
9461 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9462 switch (TREE_CODE (unqualified_id
))
9465 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9466 if (TYPE_P (unqualified_id
))
9467 unqualified_id
= constructor_name (unqualified_id
);
9470 case IDENTIFIER_NODE
:
9471 case TEMPLATE_ID_EXPR
:
9479 if (declspecs
->std_attributes
)
9481 /* Apply the c++11 attributes to the type preceding them. */
9482 input_location
= declspecs
->locations
[ds_std_attribute
];
9483 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9484 input_location
= saved_loc
;
9487 /* Determine the type of the entity declared by recurring on the
9489 for (; declarator
; declarator
= declarator
->declarator
)
9491 const cp_declarator
*inner_declarator
;
9494 if (type
== error_mark_node
)
9495 return error_mark_node
;
9497 attrs
= declarator
->attributes
;
9503 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9504 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9505 if (declarator
->kind
== cdk_function
)
9506 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9507 if (declarator
->kind
== cdk_array
)
9508 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9509 returned_attrs
= decl_attributes (&type
,
9510 chainon (returned_attrs
, attrs
),
9514 if (declarator
->kind
== cdk_id
)
9517 inner_declarator
= declarator
->declarator
;
9519 switch (declarator
->kind
)
9522 type
= create_array_type_for_decl (dname
, type
,
9523 declarator
->u
.array
.bounds
);
9524 if (declarator
->std_attributes
)
9527 The optional attribute-specifier-seq appertains to the
9529 returned_attrs
= chainon (returned_attrs
,
9530 declarator
->std_attributes
);
9538 /* Declaring a function type.
9539 Make sure we have a valid type for the function to return. */
9541 if (type_quals
!= TYPE_UNQUALIFIED
)
9543 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9544 warning (OPT_Wignored_qualifiers
,
9545 "type qualifiers ignored on function return type");
9546 /* We now know that the TYPE_QUALS don't apply to the
9547 decl, but to its return type. */
9548 type_quals
= TYPE_UNQUALIFIED
;
9550 errmsg
= targetm
.invalid_return_type (type
);
9554 type
= integer_type_node
;
9557 /* Error about some types functions can't return. */
9559 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9561 error ("%qs declared as function returning a function", name
);
9562 return error_mark_node
;
9564 if (TREE_CODE (type
) == ARRAY_TYPE
)
9566 error ("%qs declared as function returning an array", name
);
9567 return error_mark_node
;
9570 input_location
= declspecs
->locations
[ds_type_spec
];
9571 abstract_virtuals_error (ACU_RETURN
, type
);
9572 input_location
= saved_loc
;
9574 /* Pick up type qualifiers which should be applied to `this'. */
9575 memfn_quals
= declarator
->u
.function
.qualifiers
;
9576 /* Pick up virt-specifiers. */
9577 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9578 /* And ref-qualifier, too */
9579 rqual
= declarator
->u
.function
.ref_qualifier
;
9580 /* Pick up the exception specifications. */
9581 raises
= declarator
->u
.function
.exception_specification
;
9582 /* If the exception-specification is ill-formed, let's pretend
9583 there wasn't one. */
9584 if (raises
== error_mark_node
)
9587 /* Say it's a definition only for the CALL_EXPR
9588 closest to the identifier. */
9589 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9591 /* Handle a late-specified return type. */
9594 if (type_uses_auto (type
))
9596 if (!declarator
->u
.function
.late_return_type
)
9598 if (current_class_type
9599 && LAMBDA_TYPE_P (current_class_type
))
9600 /* OK for C++11 lambdas. */;
9601 else if (cxx_dialect
< cxx1y
)
9602 pedwarn (input_location
, 0, "%qs function uses "
9603 "%<auto%> type specifier without trailing "
9604 "return type", name
);
9606 permerror (input_location
, "virtual function cannot "
9607 "have deduced return type");
9609 else if (!is_auto (type
))
9611 error ("%qs function with trailing return type has"
9612 " %qT as its type rather than plain %<auto%>",
9614 return error_mark_node
;
9617 else if (declarator
->u
.function
.late_return_type
)
9619 if (cxx_dialect
< cxx11
)
9620 /* Not using maybe_warn_cpp0x because this should
9621 always be an error. */
9622 error ("trailing return type only available with "
9623 "-std=c++11 or -std=gnu++11");
9625 error ("%qs function with trailing return type not "
9626 "declared with %<auto%> type specifier", name
);
9627 return error_mark_node
;
9630 type
= splice_late_return_type
9631 (type
, declarator
->u
.function
.late_return_type
);
9632 if (type
== error_mark_node
)
9633 return error_mark_node
;
9635 if (ctype
== NULL_TREE
9636 && decl_context
== FIELD
9638 && (friendp
== 0 || dname
== current_class_name
))
9639 ctype
= current_class_type
;
9641 if (ctype
&& (sfk
== sfk_constructor
9642 || sfk
== sfk_destructor
))
9644 /* We are within a class's scope. If our declarator name
9645 is the same as the class name, and we are defining
9646 a function, then it is a constructor/destructor, and
9647 therefore returns a void type. */
9649 /* ISO C++ 12.4/2. A destructor may not be declared
9650 const or volatile. A destructor may not be static.
9651 A destructor may not be declared with ref-qualifier.
9653 ISO C++ 12.1. A constructor may not be declared
9654 const or volatile. A constructor may not be
9655 virtual. A constructor may not be static.
9656 A constructor may not be declared with ref-qualifier. */
9658 error ((flags
== DTOR_FLAG
)
9659 ? G_("destructor cannot be static member function")
9660 : G_("constructor cannot be static member function"));
9663 error ((flags
== DTOR_FLAG
)
9664 ? G_("destructors may not be cv-qualified")
9665 : G_("constructors may not be cv-qualified"));
9666 memfn_quals
= TYPE_UNQUALIFIED
;
9671 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
9672 error ((flags
== DTOR_FLAG
)
9673 ? "destructors may not be ref-qualified"
9674 : "constructors may not be ref-qualified");
9675 rqual
= REF_QUAL_NONE
;
9678 if (decl_context
== FIELD
9679 && !member_function_or_else (ctype
,
9682 return error_mark_node
;
9684 if (flags
!= DTOR_FLAG
)
9686 /* It's a constructor. */
9691 permerror (input_location
, "constructors cannot be declared virtual");
9694 if (decl_context
== FIELD
9695 && sfk
!= sfk_constructor
)
9696 return error_mark_node
;
9698 if (decl_context
== FIELD
)
9704 error ("can%'t initialize friend function %qs", name
);
9707 /* Cannot be both friend and virtual. */
9708 error ("virtual functions cannot be friends");
9711 if (decl_context
== NORMAL
)
9712 error ("friend declaration not in class definition");
9713 if (current_function_decl
&& funcdef_flag
)
9714 error ("can%'t define friend function %qs in a local "
9718 else if (ctype
&& sfk
== sfk_conversion
)
9722 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9727 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9730 if (inner_declarator
9731 && inner_declarator
->kind
== cdk_id
9732 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9733 && arg_types
!= void_list_node
)
9735 error ("destructors may not have parameters");
9736 arg_types
= void_list_node
;
9740 type
= build_function_type (type
, arg_types
);
9741 if (declarator
->std_attributes
)
9744 The optional attribute-specifier-seq appertains to
9745 the function type. */
9746 decl_attributes (&type
, declarator
->std_attributes
,
9754 /* Filter out pointers-to-references and references-to-references.
9755 We can get these if a TYPE_DECL is used. */
9757 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9759 if (declarator
->kind
!= cdk_reference
)
9761 error ("cannot declare pointer to %q#T", type
);
9762 type
= TREE_TYPE (type
);
9765 /* In C++0x, we allow reference to reference declarations
9766 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9767 and template type arguments [14.3.1/4 temp.arg.type]. The
9768 check for direct reference to reference declarations, which
9769 are still forbidden, occurs below. Reasoning behind the change
9770 can be found in DR106, DR540, and the rvalue reference
9772 else if (cxx_dialect
== cxx98
)
9774 error ("cannot declare reference to %q#T", type
);
9775 type
= TREE_TYPE (type
);
9778 else if (VOID_TYPE_P (type
))
9780 if (declarator
->kind
== cdk_reference
)
9781 error ("cannot declare reference to %q#T", type
);
9782 else if (declarator
->kind
== cdk_ptrmem
)
9783 error ("cannot declare pointer to %q#T member", type
);
9786 /* We now know that the TYPE_QUALS don't apply to the decl,
9787 but to the target of the pointer. */
9788 type_quals
= TYPE_UNQUALIFIED
;
9790 /* This code used to handle METHOD_TYPE, but I don't think it's
9791 possible to get it here anymore. */
9792 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9793 if (declarator
->kind
== cdk_ptrmem
9794 && TREE_CODE (type
) == FUNCTION_TYPE
)
9796 memfn_quals
|= type_memfn_quals (type
);
9797 type
= build_memfn_type (type
,
9798 declarator
->u
.pointer
.class_type
,
9801 if (type
== error_mark_node
)
9802 return error_mark_node
;
9804 rqual
= REF_QUAL_NONE
;
9805 memfn_quals
= TYPE_UNQUALIFIED
;
9808 if (TREE_CODE (type
) == FUNCTION_TYPE
9809 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
9810 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
9811 error (declarator
->kind
== cdk_reference
9812 ? G_("cannot declare reference to qualified function type %qT")
9813 : G_("cannot declare pointer to qualified function type %qT"),
9816 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
))
9817 pedwarn (input_location
, OPT_Wvla
,
9818 declarator
->kind
== cdk_reference
9819 ? G_("reference to array of runtime bound")
9820 : G_("pointer to array of runtime bound"));
9822 /* When the pointed-to type involves components of variable size,
9823 care must be taken to ensure that the size evaluation code is
9824 emitted early enough to dominate all the possible later uses
9825 and late enough for the variables on which it depends to have
9828 This is expected to happen automatically when the pointed-to
9829 type has a name/declaration of it's own, but special attention
9830 is required if the type is anonymous.
9832 We handle the NORMAL and FIELD contexts here by inserting a
9833 dummy statement that just evaluates the size at a safe point
9834 and ensures it is not deferred until e.g. within a deeper
9835 conditional context (c++/43555).
9837 We expect nothing to be needed here for PARM or TYPENAME.
9838 Evaluating the size at this point for TYPENAME would
9839 actually be incorrect, as we might be in the middle of an
9840 expression with side effects on the pointed-to type size
9841 "arguments" prior to the pointer declaration point and the
9842 size evaluation could end up prior to the side effects. */
9844 if (!TYPE_NAME (type
)
9845 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9846 && at_function_scope_p ()
9847 && variably_modified_type_p (type
, NULL_TREE
))
9848 /* Force evaluation of the SAVE_EXPR. */
9849 finish_expr_stmt (TYPE_SIZE (type
));
9851 if (declarator
->kind
== cdk_reference
)
9853 /* In C++0x, the type we are creating a reference to might be
9854 a typedef which is itself a reference type. In that case,
9855 we follow the reference collapsing rules in
9856 [7.1.3/8 dcl.typedef] to create the final reference type:
9858 "If a typedef TD names a type that is a reference to a type
9859 T, an attempt to create the type 'lvalue reference to cv TD'
9860 creates the type 'lvalue reference to T,' while an attempt
9861 to create the type "rvalue reference to cv TD' creates the
9864 if (VOID_TYPE_P (type
))
9865 /* We already gave an error. */;
9866 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9868 if (declarator
->u
.reference
.rvalue_ref
)
9869 /* Leave type alone. */;
9871 type
= cp_build_reference_type (TREE_TYPE (type
), false);
9874 type
= cp_build_reference_type
9875 (type
, declarator
->u
.reference
.rvalue_ref
);
9877 /* In C++0x, we need this check for direct reference to
9878 reference declarations, which are forbidden by
9879 [8.3.2/5 dcl.ref]. Reference to reference declarations
9880 are only allowed indirectly through typedefs and template
9881 type arguments. Example:
9883 void foo(int & &); // invalid ref-to-ref decl
9885 typedef int & int_ref;
9886 void foo(int_ref &); // valid ref-to-ref decl
9888 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
9889 error ("cannot declare reference to %q#T, which is not "
9890 "a typedef or a template type argument", type
);
9892 else if (TREE_CODE (type
) == METHOD_TYPE
)
9893 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9894 else if (declarator
->kind
== cdk_ptrmem
)
9896 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
9898 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
9899 /* We will already have complained. */
9900 type
= error_mark_node
;
9902 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
9906 type
= build_pointer_type (type
);
9908 /* Process a list of type modifier keywords (such as
9909 const or volatile) that were given inside the `*' or `&'. */
9911 if (declarator
->u
.pointer
.qualifiers
)
9914 = cp_build_qualified_type (type
,
9915 declarator
->u
.pointer
.qualifiers
);
9916 type_quals
= cp_type_quals (type
);
9919 /* Apply C++11 attributes to the pointer, and not to the
9920 type pointed to. This is unlike what is done for GNU
9921 attributes above. It is to comply with [dcl.ptr]/1:
9923 [the optional attribute-specifier-seq (7.6.1) appertains
9924 to the pointer and not to the object pointed to]. */
9925 if (declarator
->std_attributes
)
9926 decl_attributes (&type
, declarator
->std_attributes
,
9940 /* A `constexpr' specifier used in an object declaration declares
9941 the object as `const'. */
9942 if (constexpr_p
&& innermost_code
!= cdk_function
)
9944 if (type_quals
& TYPE_QUAL_VOLATILE
)
9945 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9946 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9948 type_quals
|= TYPE_QUAL_CONST
;
9949 type
= cp_build_qualified_type (type
, type_quals
);
9953 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
9954 && TREE_CODE (type
) != FUNCTION_TYPE
9955 && TREE_CODE (type
) != METHOD_TYPE
)
9957 error ("template-id %qD used as a declarator",
9959 unqualified_id
= dname
;
9962 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9963 qualified with a class-name, turn it into a METHOD_TYPE, unless
9964 we know that the function is static. We take advantage of this
9965 opportunity to do other processing that pertains to entities
9966 explicitly declared to be class members. Note that if DECLARATOR
9967 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9968 would not have exited the loop above. */
9970 && declarator
->u
.id
.qualifying_scope
9971 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
9973 ctype
= declarator
->u
.id
.qualifying_scope
;
9974 ctype
= TYPE_MAIN_VARIANT (ctype
);
9975 template_count
= num_template_headers_for_class (ctype
);
9977 if (ctype
== current_class_type
)
9981 permerror (input_location
, "member functions are implicitly friends of their class");
9985 permerror (declarator
->id_loc
,
9986 "extra qualification %<%T::%> on member %qs",
9989 else if (/* If the qualifying type is already complete, then we
9990 can skip the following checks. */
9991 !COMPLETE_TYPE_P (ctype
)
9992 && (/* If the function is being defined, then
9993 qualifying type must certainly be complete. */
9995 /* A friend declaration of "T::f" is OK, even if
9996 "T" is a template parameter. But, if this
9997 function is not a friend, the qualifying type
9999 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10000 /* For a declaration, the type need not be
10001 complete, if either it is dependent (since there
10002 is no meaningful definition of complete in that
10003 case) or the qualifying class is currently being
10005 || !(dependent_type_p (ctype
)
10006 || currently_open_class (ctype
)))
10007 /* Check that the qualifying type is complete. */
10008 && !complete_type_or_else (ctype
, NULL_TREE
))
10009 return error_mark_node
;
10010 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10012 if (current_class_type
10013 && (!friendp
|| funcdef_flag
))
10015 error (funcdef_flag
10016 ? G_("cannot define member function %<%T::%s%> "
10018 : G_("cannot declare member function %<%T::%s%> "
10020 ctype
, name
, current_class_type
);
10021 return error_mark_node
;
10024 else if (typedef_p
&& current_class_type
)
10026 error ("cannot declare member %<%T::%s%> within %qT",
10027 ctype
, name
, current_class_type
);
10028 return error_mark_node
;
10032 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10033 ctype
= current_class_type
;
10035 /* Now TYPE has the actual type. */
10037 if (returned_attrs
)
10040 *attrlist
= chainon (returned_attrs
, *attrlist
);
10042 attrlist
= &returned_attrs
;
10046 && declarator
->kind
== cdk_id
10047 && declarator
->std_attributes
)
10048 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10049 a declarator-id appertains to the entity that is declared. */
10050 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10052 /* Handle parameter packs. */
10053 if (parameter_pack_p
)
10055 if (decl_context
== PARM
)
10056 /* Turn the type into a pack expansion.*/
10057 type
= make_pack_expansion (type
);
10059 error ("non-parameter %qs cannot be a parameter pack", name
);
10062 /* Did array size calculations overflow or does the array cover more
10063 than half of the address-space? */
10064 if (TREE_CODE (type
) == ARRAY_TYPE
10065 && COMPLETE_TYPE_P (type
)
10066 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
10067 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
10069 error ("size of array %qs is too large", name
);
10070 /* If we proceed with the array type as it is, we'll eventually
10071 crash in tree_to_[su]hwi(). */
10072 type
= error_mark_node
;
10075 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10076 && !processing_template_decl
10077 && variably_modified_type_p (type
, NULL_TREE
))
10079 if (decl_context
== FIELD
)
10080 error ("data member may not have variably modified type %qT", type
);
10082 error ("parameter may not have variably modified type %qT", type
);
10083 type
= error_mark_node
;
10086 if (explicitp
== 1 || (explicitp
&& friendp
))
10088 /* [dcl.fct.spec] The explicit specifier shall only be used in
10089 declarations of constructors within a class definition. */
10090 error ("only declarations of constructors can be %<explicit%>");
10094 if (storage_class
== sc_mutable
)
10096 if (decl_context
!= FIELD
|| friendp
)
10098 error ("non-member %qs cannot be declared %<mutable%>", name
);
10099 storage_class
= sc_none
;
10101 else if (decl_context
== TYPENAME
|| typedef_p
)
10103 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10104 storage_class
= sc_none
;
10106 else if (TREE_CODE (type
) == FUNCTION_TYPE
10107 || TREE_CODE (type
) == METHOD_TYPE
)
10109 error ("function %qs cannot be declared %<mutable%>", name
);
10110 storage_class
= sc_none
;
10114 error ("static %qs cannot be declared %<mutable%>", name
);
10115 storage_class
= sc_none
;
10117 else if (type_quals
& TYPE_QUAL_CONST
)
10119 error ("const %qs cannot be declared %<mutable%>", name
);
10120 storage_class
= sc_none
;
10122 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10124 permerror (input_location
, "reference %qs cannot be declared "
10125 "%<mutable%>", name
);
10126 storage_class
= sc_none
;
10130 /* If this is declaring a typedef name, return a TYPE_DECL. */
10131 if (typedef_p
&& decl_context
!= TYPENAME
)
10135 /* Note that the grammar rejects storage classes
10136 in typenames, fields or parameters. */
10137 if (current_lang_name
== lang_name_java
)
10138 TYPE_FOR_JAVA (type
) = 1;
10140 /* This declaration:
10142 typedef void f(int) const;
10144 declares a function type which is not a member of any
10145 particular class, but which is cv-qualified; for
10146 example "f S::*" declares a pointer to a const-qualified
10147 member function of S. We record the cv-qualification in the
10149 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10151 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10153 /* We have now dealt with these qualifiers. */
10154 memfn_quals
= TYPE_UNQUALIFIED
;
10155 rqual
= REF_QUAL_NONE
;
10158 if (type_uses_auto (type
))
10160 error ("typedef declared %<auto%>");
10161 type
= error_mark_node
;
10164 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
))
10165 pedwarn (input_location
, OPT_Wvla
,
10166 "typedef naming array of runtime bound");
10168 if (decl_context
== FIELD
)
10169 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10171 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10172 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10173 error_at (DECL_SOURCE_LOCATION (decl
),
10174 "typedef name may not be a nested-name-specifier");
10175 TREE_TYPE (decl
) = error_mark_node
;
10178 if (decl_context
!= FIELD
)
10180 if (!current_function_decl
)
10181 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10182 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10183 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10184 (current_function_decl
)))
10185 /* The TYPE_DECL is "abstract" because there will be
10186 clones of this constructor/destructor, and there will
10187 be copies of this TYPE_DECL generated in those
10189 DECL_ABSTRACT (decl
) = 1;
10191 else if (current_class_type
10192 && constructor_name_p (unqualified_id
, current_class_type
))
10193 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10194 "as enclosing class",
10197 /* If the user declares "typedef struct {...} foo" then the
10198 struct will have an anonymous name. Fill that name in now.
10199 Nothing can refer to it, so nothing needs know about the name
10201 if (type
!= error_mark_node
10203 && TYPE_NAME (type
)
10204 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10205 && TYPE_ANONYMOUS_P (type
)
10206 && declspecs
->type_definition_p
10207 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10211 /* Replace the anonymous name with the real name everywhere. */
10212 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10214 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10215 /* We do not rename the debug info representing the
10216 anonymous tagged type because the standard says in
10217 [dcl.typedef] that the naming applies only for
10218 linkage purposes. */
10219 /*debug_hooks->set_name (t, decl);*/
10220 TYPE_NAME (t
) = decl
;
10223 if (TYPE_LANG_SPECIFIC (type
))
10224 TYPE_WAS_ANONYMOUS (type
) = 1;
10226 /* If this is a typedef within a template class, the nested
10227 type is a (non-primary) template. The name for the
10228 template needs updating as well. */
10229 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10230 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10231 = TYPE_IDENTIFIER (type
);
10233 /* Adjust linkage now that we aren't anonymous anymore. */
10234 reset_type_linkage (type
);
10236 /* FIXME remangle member functions; member functions of a
10237 type with external linkage have external linkage. */
10241 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10242 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10244 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10245 memfn_quals
!= TYPE_UNQUALIFIED
,
10246 inlinep
, friendp
, raises
!= NULL_TREE
);
10248 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10249 /* Acknowledge that this was written:
10250 `using analias = atype;'. */
10251 TYPE_DECL_ALIAS_P (decl
) = 1;
10256 /* Detect the case of an array type of unspecified size
10257 which came, as such, direct from a typedef name.
10258 We must copy the type, so that the array's domain can be
10259 individually set by the object's initializer. */
10261 if (type
&& typedef_type
10262 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10263 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10264 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10266 /* Detect where we're using a typedef of function type to declare a
10267 function. PARMS will not be set, so we must create it now. */
10269 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10271 tree decls
= NULL_TREE
;
10274 for (args
= TYPE_ARG_TYPES (type
);
10275 args
&& args
!= void_list_node
;
10276 args
= TREE_CHAIN (args
))
10278 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10280 DECL_CHAIN (decl
) = decls
;
10284 parms
= nreverse (decls
);
10286 if (decl_context
!= TYPENAME
)
10288 /* The qualifiers on the function type become the qualifiers on
10289 the non-static member function. */
10290 memfn_quals
|= type_memfn_quals (type
);
10291 rqual
= type_memfn_rqual (type
);
10292 type_quals
= TYPE_UNQUALIFIED
;
10296 /* If this is a type name (such as, in a cast or sizeof),
10297 compute the type and return it now. */
10299 if (decl_context
== TYPENAME
)
10301 /* Note that the grammar rejects storage classes
10302 in typenames, fields or parameters. */
10303 if (type_quals
!= TYPE_UNQUALIFIED
)
10304 type_quals
= TYPE_UNQUALIFIED
;
10306 /* Special case: "friend class foo" looks like a TYPENAME context. */
10309 if (type_quals
!= TYPE_UNQUALIFIED
)
10311 error ("type qualifiers specified for friend class declaration");
10312 type_quals
= TYPE_UNQUALIFIED
;
10316 error ("%<inline%> specified for friend class declaration");
10322 /* Don't allow friend declaration without a class-key. */
10323 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10324 permerror (input_location
, "template parameters cannot be friends");
10325 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10326 permerror (input_location
, "friend declaration requires class-key, "
10327 "i.e. %<friend class %T::%D%>",
10328 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10330 permerror (input_location
, "friend declaration requires class-key, "
10331 "i.e. %<friend %#T%>",
10335 /* Only try to do this stuff if we didn't already give up. */
10336 if (type
!= integer_type_node
)
10338 /* A friendly class? */
10339 if (current_class_type
)
10340 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10341 /*complain=*/true);
10343 error ("trying to make class %qT a friend of global scope",
10346 type
= void_type_node
;
10349 else if (memfn_quals
|| rqual
)
10351 if (ctype
== NULL_TREE
10352 && TREE_CODE (type
) == METHOD_TYPE
)
10353 ctype
= TYPE_METHOD_BASETYPE (type
);
10356 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10357 /* Core issue #547: need to allow this in template type args.
10358 Allow it in general in C++11 for alias-declarations. */
10359 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10360 && TREE_CODE (type
) == FUNCTION_TYPE
)
10361 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10363 error ("invalid qualifiers on non-member function type");
10368 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10369 && decl_context
!= CATCHPARM
10370 && TREE_CODE (type
) != UNION_TYPE
10373 error ("abstract declarator %qT used as declaration", type
);
10374 return error_mark_node
;
10377 /* Only functions may be declared using an operator-function-id. */
10379 && IDENTIFIER_OPNAME_P (unqualified_id
)
10380 && TREE_CODE (type
) != FUNCTION_TYPE
10381 && TREE_CODE (type
) != METHOD_TYPE
)
10383 error ("declaration of %qD as non-function", unqualified_id
);
10384 return error_mark_node
;
10387 /* We don't check parameter types here because we can emit a better
10388 error message later. */
10389 if (decl_context
!= PARM
)
10391 type
= check_var_type (unqualified_id
, type
);
10392 if (type
== error_mark_node
)
10393 return error_mark_node
;
10396 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10397 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10399 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10401 if (ctype
|| in_namespace
)
10402 error ("cannot use %<::%> in parameter declaration");
10404 if (type_uses_auto (type
))
10406 if (cxx_dialect
>= cxx1y
)
10407 error ("%<auto%> parameter not permitted in this context");
10409 error ("parameter declared %<auto%>");
10410 type
= error_mark_node
;
10413 /* A parameter declared as an array of T is really a pointer to T.
10414 One declared as a function is really a pointer to a function.
10415 One declared as a member is really a pointer to member. */
10417 if (TREE_CODE (type
) == ARRAY_TYPE
)
10419 /* Transfer const-ness of array into that of type pointed to. */
10420 type
= build_pointer_type (TREE_TYPE (type
));
10421 type_quals
= TYPE_UNQUALIFIED
;
10423 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10424 type
= build_pointer_type (type
);
10427 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10428 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10430 cp_cv_quals real_quals
= memfn_quals
;
10431 if (constexpr_p
&& sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10432 real_quals
|= TYPE_QUAL_CONST
;
10433 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10439 if (decl_context
== PARM
)
10441 decl
= cp_build_parm_decl (unqualified_id
, type
);
10443 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10444 memfn_quals
!= TYPE_UNQUALIFIED
,
10445 inlinep
, friendp
, raises
!= NULL_TREE
);
10447 else if (decl_context
== FIELD
)
10449 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10450 && type_uses_auto (type
))
10452 error ("non-static data member declared %<auto%>");
10453 type
= error_mark_node
;
10456 /* The C99 flexible array extension. */
10457 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10458 && TYPE_DOMAIN (type
) == NULL_TREE
)
10460 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10461 tf_warning_or_error
);
10462 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10465 if (type
== error_mark_node
)
10467 /* Happens when declaring arrays of sizes which
10468 are error_mark_node, for example. */
10471 else if (in_namespace
&& !friendp
)
10473 /* Something like struct S { int N::j; }; */
10474 error ("invalid use of %<::%>");
10475 return error_mark_node
;
10477 else if (TREE_CODE (type
) == FUNCTION_TYPE
10478 || TREE_CODE (type
) == METHOD_TYPE
)
10481 tree function_context
;
10485 /* This should never happen in pure C++ (the check
10486 could be an assert). It could happen in
10487 Objective-C++ if someone writes invalid code that
10488 uses a function declaration for an instance
10489 variable or property (instance variables and
10490 properties are parsed as FIELD_DECLs, but they are
10491 part of an Objective-C class, not a C++ class).
10492 That code is invalid and is caught by this
10496 error ("declaration of function %qD in invalid context",
10498 return error_mark_node
;
10501 /* ``A union may [ ... ] not [ have ] virtual functions.''
10503 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10505 error ("function %qD declared virtual inside a union",
10507 return error_mark_node
;
10510 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10514 error ("%qD cannot be declared virtual, since it "
10515 "is always static",
10522 /* Check that the name used for a destructor makes sense. */
10523 if (sfk
== sfk_destructor
)
10525 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10529 gcc_assert (friendp
);
10530 error ("expected qualified name in friend declaration "
10531 "for destructor %qD", uqname
);
10532 return error_mark_node
;
10535 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10537 error ("declaration of %qD as member of %qT",
10539 return error_mark_node
;
10543 error ("a destructor cannot be %<constexpr%>");
10544 return error_mark_node
;
10547 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10549 error ("expected qualified name in friend declaration "
10550 "for constructor %qD",
10551 id_declarator
->u
.id
.unqualified_name
);
10552 return error_mark_node
;
10555 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10556 function_context
= (ctype
!= NULL_TREE
) ?
10557 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10558 publicp
= (! friendp
|| ! staticp
)
10559 && function_context
== NULL_TREE
;
10560 decl
= grokfndecl (ctype
, type
,
10561 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10562 ? unqualified_id
: dname
,
10565 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10566 friendp
? -1 : 0, friendp
, publicp
,
10567 inlinep
| (2 * constexpr_p
),
10569 funcdef_flag
, template_count
, in_namespace
,
10570 attrlist
, declarator
->id_loc
);
10571 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10572 if (decl
== NULL_TREE
)
10573 return error_mark_node
;
10575 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10576 /* The decl and setting of decl_attr is also turned off. */
10577 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10580 /* [class.conv.ctor]
10582 A constructor declared without the function-specifier
10583 explicit that can be called with a single parameter
10584 specifies a conversion from the type of its first
10585 parameter to the type of its class. Such a constructor
10586 is called a converting constructor. */
10587 if (explicitp
== 2)
10588 DECL_NONCONVERTING_P (decl
) = 1;
10590 else if (!staticp
&& !dependent_type_p (type
)
10591 && !COMPLETE_TYPE_P (complete_type (type
))
10592 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10594 if (unqualified_id
)
10595 error ("field %qD has incomplete type %qT",
10596 unqualified_id
, type
);
10598 error ("name %qT has incomplete type", type
);
10600 type
= error_mark_node
;
10607 error ("%qE is neither function nor member function; "
10608 "cannot be declared friend", unqualified_id
);
10616 /* Friends are treated specially. */
10617 if (ctype
== current_class_type
)
10618 ; /* We already issued a permerror. */
10619 else if (decl
&& DECL_NAME (decl
))
10621 if (template_class_depth (current_class_type
) == 0)
10623 decl
= check_explicit_specialization
10624 (unqualified_id
, decl
, template_count
,
10625 2 * funcdef_flag
+ 4);
10626 if (decl
== error_mark_node
)
10627 return error_mark_node
;
10630 decl
= do_friend (ctype
, unqualified_id
, decl
,
10636 return error_mark_node
;
10639 /* Structure field. It may not be a function, except for C++. */
10641 if (decl
== NULL_TREE
)
10645 /* C++ allows static class members. All other work
10646 for this is done by grokfield. */
10647 decl
= build_lang_decl_loc (declarator
10648 ? declarator
->id_loc
10650 VAR_DECL
, unqualified_id
, type
);
10651 set_linkage_for_static_data_member (decl
);
10652 /* Even if there is an in-class initialization, DECL
10653 is considered undefined until an out-of-class
10654 definition is provided. */
10655 DECL_EXTERNAL (decl
) = 1;
10659 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
10660 if (declspecs
->gnu_thread_keyword_p
)
10661 DECL_GNU_TLS_P (decl
) = true;
10664 if (constexpr_p
&& !initialized
)
10666 error ("constexpr static data member %qD must have an "
10667 "initializer", decl
);
10668 constexpr_p
= false;
10675 error ("non-static data member %qE declared %<constexpr%>",
10677 constexpr_p
= false;
10679 decl
= build_decl (input_location
,
10680 FIELD_DECL
, unqualified_id
, type
);
10681 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10682 if (bitfield
&& !unqualified_id
)
10683 TREE_NO_WARNING (decl
) = 1;
10685 if (storage_class
== sc_mutable
)
10687 DECL_MUTABLE_P (decl
) = 1;
10688 storage_class
= sc_none
;
10693 /* An attempt is being made to initialize a non-static
10694 member. This is new in C++11. */
10695 maybe_warn_cpp0x (CPP0X_NSDMI
);
10697 /* If this has been parsed with static storage class, but
10698 errors forced staticp to be cleared, ensure NSDMI is
10700 if (declspecs
->storage_class
== sc_static
)
10701 DECL_INITIAL (decl
) = error_mark_node
;
10705 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10706 memfn_quals
!= TYPE_UNQUALIFIED
,
10707 inlinep
, friendp
, raises
!= NULL_TREE
);
10710 else if (TREE_CODE (type
) == FUNCTION_TYPE
10711 || TREE_CODE (type
) == METHOD_TYPE
)
10713 tree original_name
;
10716 if (!unqualified_id
)
10717 return error_mark_node
;
10719 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10720 original_name
= dname
;
10722 original_name
= unqualified_id
;
10724 if (storage_class
== sc_auto
)
10725 error ("storage class %<auto%> invalid for function %qs", name
);
10726 else if (storage_class
== sc_register
)
10727 error ("storage class %<register%> invalid for function %qs", name
);
10730 if (declspecs
->gnu_thread_keyword_p
)
10731 error ("storage class %<__thread%> invalid for function %qs",
10734 error ("storage class %<thread_local%> invalid for function %qs",
10738 if (virt_specifiers
)
10739 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10740 /* Function declaration not at top level.
10741 Storage classes other than `extern' are not allowed
10742 and `extern' makes no difference. */
10743 if (! toplevel_bindings_p ()
10744 && (storage_class
== sc_static
10745 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10748 if (storage_class
== sc_static
)
10749 pedwarn (input_location
, OPT_Wpedantic
,
10750 "%<static%> specified invalid for function %qs "
10751 "declared out of global scope", name
);
10753 pedwarn (input_location
, OPT_Wpedantic
,
10754 "%<inline%> specifier invalid for function %qs "
10755 "declared out of global scope", name
);
10758 if (ctype
== NULL_TREE
)
10762 error ("virtual non-class function %qs", name
);
10765 else if (sfk
== sfk_constructor
10766 || sfk
== sfk_destructor
)
10768 error (funcdef_flag
10769 ? G_("%qs defined in a non-class scope")
10770 : G_("%qs declared in a non-class scope"), name
);
10775 /* Record whether the function is public. */
10776 publicp
= (ctype
!= NULL_TREE
10777 || storage_class
!= sc_static
);
10779 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10780 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10782 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10784 template_count
, in_namespace
, attrlist
,
10785 declarator
->id_loc
);
10786 if (decl
== NULL_TREE
)
10787 return error_mark_node
;
10791 int invalid_static
= 0;
10793 /* Don't allow a static member function in a class, and forbid
10794 declaring main to be static. */
10795 if (TREE_CODE (type
) == METHOD_TYPE
)
10797 permerror (input_location
, "cannot declare member function %qD to have "
10798 "static linkage", decl
);
10799 invalid_static
= 1;
10801 else if (current_function_decl
)
10803 /* FIXME need arm citation */
10804 error ("cannot declare static function inside another function");
10805 invalid_static
= 1;
10808 if (invalid_static
)
10811 storage_class
= sc_none
;
10817 /* It's a variable. */
10819 /* An uninitialized decl with `extern' is a reference. */
10820 decl
= grokvardecl (type
, unqualified_id
,
10823 (type_quals
& TYPE_QUAL_CONST
) != 0,
10824 ctype
? ctype
: in_namespace
);
10825 bad_specifiers (decl
, BSP_VAR
, virtualp
,
10826 memfn_quals
!= TYPE_UNQUALIFIED
,
10827 inlinep
, friendp
, raises
!= NULL_TREE
);
10831 DECL_CONTEXT (decl
) = ctype
;
10834 permerror (input_location
, "%<static%> may not be used when defining "
10835 "(as opposed to declaring) a static data member");
10837 storage_class
= sc_none
;
10839 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
10841 error ("static member %qD declared %<register%>", decl
);
10842 storage_class
= sc_none
;
10844 if (storage_class
== sc_extern
&& pedantic
)
10846 pedwarn (input_location
, OPT_Wpedantic
,
10847 "cannot explicitly declare member %q#D to have "
10848 "extern linkage", decl
);
10849 storage_class
= sc_none
;
10852 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
10854 error ("declaration of constexpr variable %qD is not a definition",
10856 constexpr_p
= false;
10860 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
10862 if (toplevel_bindings_p ())
10864 /* It's common practice (and completely valid) to have a const
10865 be initialized and declared extern. */
10866 if (!(type_quals
& TYPE_QUAL_CONST
))
10867 warning (0, "%qs initialized and declared %<extern%>", name
);
10871 error ("%qs has both %<extern%> and initializer", name
);
10872 return error_mark_node
;
10876 /* Record `register' declaration for warnings on &
10877 and in case doing stupid register allocation. */
10879 if (storage_class
== sc_register
)
10880 DECL_REGISTER (decl
) = 1;
10881 else if (storage_class
== sc_extern
)
10882 DECL_THIS_EXTERN (decl
) = 1;
10883 else if (storage_class
== sc_static
)
10884 DECL_THIS_STATIC (decl
) = 1;
10886 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10887 if (constexpr_p
&& VAR_P (decl
))
10888 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
10890 /* Record constancy and volatility on the DECL itself . There's
10891 no need to do this when processing a template; we'll do this
10892 for the instantiated declaration based on the type of DECL. */
10893 if (!processing_template_decl
)
10894 cp_apply_type_quals_to_decl (type_quals
, decl
);
10900 /* Subroutine of start_function. Ensure that each of the parameter
10901 types (as listed in PARMS) is complete, as is required for a
10902 function definition. */
10905 require_complete_types_for_parms (tree parms
)
10907 for (; parms
; parms
= DECL_CHAIN (parms
))
10909 if (dependent_type_p (TREE_TYPE (parms
)))
10911 if (!VOID_TYPE_P (TREE_TYPE (parms
))
10912 && complete_type_or_else (TREE_TYPE (parms
), parms
))
10914 relayout_decl (parms
);
10915 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
10918 /* grokparms or complete_type_or_else will have already issued
10920 TREE_TYPE (parms
) = error_mark_node
;
10924 /* Returns nonzero if T is a local variable. */
10927 local_variable_p (const_tree t
)
10930 /* A VAR_DECL with a context that is a _TYPE is a static data
10932 && !TYPE_P (CP_DECL_CONTEXT (t
))
10933 /* Any other non-local variable must be at namespace scope. */
10934 && !DECL_NAMESPACE_SCOPE_P (t
))
10935 || (TREE_CODE (t
) == PARM_DECL
))
10941 /* Like local_variable_p, but suitable for use as a tree-walking
10945 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
10948 if (local_variable_p (*tp
)
10949 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
10951 else if (TYPE_P (*tp
))
10952 *walk_subtrees
= 0;
10957 /* Check that ARG, which is a default-argument expression for a
10958 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10959 something goes wrong. DECL may also be a _TYPE node, rather than a
10960 DECL, if there is no DECL available. */
10963 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
10968 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10969 /* We get a DEFAULT_ARG when looking at an in-class declaration
10970 with a default argument. Ignore the argument for now; we'll
10971 deal with it after the class is complete. */
10980 decl_type
= TREE_TYPE (decl
);
10982 if (arg
== error_mark_node
10983 || decl
== error_mark_node
10984 || TREE_TYPE (arg
) == error_mark_node
10985 || decl_type
== error_mark_node
)
10986 /* Something already went wrong. There's no need to check
10988 return error_mark_node
;
10990 /* [dcl.fct.default]
10992 A default argument expression is implicitly converted to the
10994 ++cp_unevaluated_operand
;
10995 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
10997 --cp_unevaluated_operand
;
10999 if (warn_zero_as_null_pointer_constant
11000 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
11001 && null_ptr_cst_p (arg
)
11002 && (complain
& tf_warning
)
11003 && maybe_warn_zero_as_null_pointer_constant (arg
, input_location
))
11004 return nullptr_node
;
11006 /* [dcl.fct.default]
11008 Local variables shall not be used in default argument
11011 The keyword `this' shall not be used in a default argument of a
11012 member function. */
11013 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11016 if (complain
& tf_warning_or_error
)
11018 if (DECL_NAME (var
) == this_identifier
)
11019 permerror (input_location
, "default argument %qE uses %qD",
11022 error ("default argument %qE uses local variable %qD", arg
, var
);
11024 return error_mark_node
;
11031 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11034 type_is_deprecated (tree type
)
11036 enum tree_code code
;
11037 if (TREE_DEPRECATED (type
))
11039 if (TYPE_NAME (type
)
11040 && TREE_DEPRECATED (TYPE_NAME (type
)))
11043 /* Do warn about using typedefs to a deprecated class. */
11044 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11045 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11047 code
= TREE_CODE (type
);
11049 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11050 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11051 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11052 return type_is_deprecated (TREE_TYPE (type
));
11054 if (TYPE_PTRMEMFUNC_P (type
))
11055 return type_is_deprecated
11056 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11061 /* Decode the list of parameter types for a function type.
11062 Given the list of things declared inside the parens,
11063 return a list of types.
11065 If this parameter does not end with an ellipsis, we append
11068 *PARMS is set to the chain of PARM_DECLs created. */
11071 grokparms (tree parmlist
, tree
*parms
)
11073 tree result
= NULL_TREE
;
11074 tree decls
= NULL_TREE
;
11078 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11080 tree type
= NULL_TREE
;
11081 tree init
= TREE_PURPOSE (parm
);
11082 tree decl
= TREE_VALUE (parm
);
11083 const char *errmsg
;
11085 if (parm
== void_list_node
)
11088 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11091 type
= TREE_TYPE (decl
);
11092 if (VOID_TYPE_P (type
))
11094 if (same_type_p (type
, void_type_node
)
11095 && DECL_SELF_REFERENCE_P (type
)
11096 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
11097 /* this is a parmlist of `(void)', which is ok. */
11099 cxx_incomplete_type_error (decl
, type
);
11100 /* It's not a good idea to actually create parameters of
11101 type `void'; other parts of the compiler assume that a
11102 void type terminates the parameter list. */
11103 type
= error_mark_node
;
11104 TREE_TYPE (decl
) = error_mark_node
;
11107 if (type
!= error_mark_node
11108 && TYPE_FOR_JAVA (type
)
11109 && MAYBE_CLASS_TYPE_P (type
))
11111 error ("parameter %qD has Java class type", decl
);
11112 type
= error_mark_node
;
11113 TREE_TYPE (decl
) = error_mark_node
;
11117 if (type
!= error_mark_node
11118 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11121 type
= error_mark_node
;
11122 TREE_TYPE (decl
) = error_mark_node
;
11125 if (type
!= error_mark_node
)
11127 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11129 tree deptype
= type_is_deprecated (type
);
11131 warn_deprecated_use (deptype
, NULL_TREE
);
11134 /* Top-level qualifiers on the parameters are
11135 ignored for function types. */
11136 type
= cp_build_qualified_type (type
, 0);
11137 if (TREE_CODE (type
) == METHOD_TYPE
)
11139 error ("parameter %qD invalidly declared method type", decl
);
11140 type
= build_pointer_type (type
);
11141 TREE_TYPE (decl
) = type
;
11143 else if (abstract_virtuals_error (decl
, type
))
11144 any_error
= 1; /* Seems like a good idea. */
11145 else if (POINTER_TYPE_P (type
))
11147 /* [dcl.fct]/6, parameter types cannot contain pointers
11148 (references) to arrays of unknown bound. */
11149 tree t
= TREE_TYPE (type
);
11150 int ptr
= TYPE_PTR_P (type
);
11154 if (TYPE_PTR_P (t
))
11156 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11158 else if (!TYPE_DOMAIN (t
))
11162 if (TREE_CODE (t
) == ARRAY_TYPE
)
11164 ? G_("parameter %qD includes pointer to array of "
11165 "unknown bound %qT")
11166 : G_("parameter %qD includes reference to array of "
11167 "unknown bound %qT"),
11173 else if (init
&& !processing_template_decl
)
11174 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11177 DECL_CHAIN (decl
) = decls
;
11179 result
= tree_cons (init
, type
, result
);
11181 decls
= nreverse (decls
);
11182 result
= nreverse (result
);
11184 result
= chainon (result
, void_list_node
);
11191 /* D is a constructor or overloaded `operator='.
11193 Let T be the class in which D is declared. Then, this function
11196 -1 if D's is an ill-formed constructor or copy assignment operator
11197 whose first parameter is of type `T'.
11198 0 if D is not a copy constructor or copy assignment
11200 1 if D is a copy constructor or copy assignment operator whose
11201 first parameter is a reference to non-const qualified T.
11202 2 if D is a copy constructor or copy assignment operator whose
11203 first parameter is a reference to const qualified T.
11205 This function can be used as a predicate. Positive values indicate
11206 a copy constructor and nonzero values indicate a copy assignment
11210 copy_fn_p (const_tree d
)
11216 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11218 if (TREE_CODE (d
) == TEMPLATE_DECL
11219 || (DECL_TEMPLATE_INFO (d
)
11220 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11221 /* Instantiations of template member functions are never copy
11222 functions. Note that member functions of templated classes are
11223 represented as template functions internally, and we must
11224 accept those as copy functions. */
11227 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11231 arg_type
= TREE_VALUE (args
);
11232 if (arg_type
== error_mark_node
)
11235 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11237 /* Pass by value copy assignment operator. */
11240 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11241 && !TYPE_REF_IS_RVALUE (arg_type
)
11242 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11244 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11250 args
= TREE_CHAIN (args
);
11252 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11253 /* There are more non-optional args. */
11259 /* D is a constructor or overloaded `operator='.
11261 Let T be the class in which D is declared. Then, this function
11262 returns true when D is a move constructor or move assignment
11263 operator, false otherwise. */
11266 move_fn_p (const_tree d
)
11268 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11270 if (cxx_dialect
== cxx98
)
11271 /* There are no move constructors if we are in C++98 mode. */
11274 if (TREE_CODE (d
) == TEMPLATE_DECL
11275 || (DECL_TEMPLATE_INFO (d
)
11276 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11277 /* Instantiations of template member functions are never move
11278 functions. Note that member functions of templated classes are
11279 represented as template functions internally, and we must
11280 accept those as move functions. */
11283 return move_signature_fn_p (d
);
11286 /* D is a constructor or overloaded `operator='.
11288 Then, this function returns true when D has the same signature as a move
11289 constructor or move assignment operator (because either it is such a
11290 ctor/op= or it is a template specialization with the same signature),
11291 false otherwise. */
11294 move_signature_fn_p (const_tree d
)
11298 bool result
= false;
11300 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11304 arg_type
= TREE_VALUE (args
);
11305 if (arg_type
== error_mark_node
)
11308 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11309 && TYPE_REF_IS_RVALUE (arg_type
)
11310 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11314 args
= TREE_CHAIN (args
);
11316 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11317 /* There are more non-optional args. */
11323 /* Remember any special properties of member function DECL. */
11326 grok_special_member_properties (tree decl
)
11330 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11333 class_type
= DECL_CONTEXT (decl
);
11334 if (DECL_CONSTRUCTOR_P (decl
))
11336 int ctor
= copy_fn_p (decl
);
11338 if (!DECL_ARTIFICIAL (decl
))
11339 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11345 A non-template constructor for class X is a copy
11346 constructor if its first parameter is of type X&, const
11347 X&, volatile X& or const volatile X&, and either there
11348 are no other parameters or else all other parameters have
11349 default arguments. */
11350 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11351 if (user_provided_p (decl
))
11352 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11354 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11356 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11358 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11359 if (user_provided_p (decl
))
11360 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
11362 else if (move_fn_p (decl
) && user_provided_p (decl
))
11363 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11364 else if (is_list_ctor (decl
))
11365 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11367 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11368 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11369 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11371 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11375 A non-template assignment operator for class X is a copy
11376 assignment operator if its parameter is of type X, X&, const
11377 X&, volatile X& or const volatile X&. */
11379 int assop
= copy_fn_p (decl
);
11383 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11384 if (user_provided_p (decl
))
11385 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11387 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11389 else if (move_fn_p (decl
) && user_provided_p (decl
))
11390 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11392 /* Destructors are handled in check_methods. */
11395 /* Check a constructor DECL has the correct form. Complains
11396 if the class has a constructor of the form X(X). */
11399 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11401 int ctor_parm
= copy_fn_p (decl
);
11407 A declaration of a constructor for a class X is ill-formed if
11408 its first parameter is of type (optionally cv-qualified) X
11409 and either there are no other parameters or else all other
11410 parameters have default arguments.
11412 We *don't* complain about member template instantiations that
11413 have this form, though; they can occur as we try to decide
11414 what constructor to use during overload resolution. Since
11415 overload resolution will never prefer such a constructor to
11416 the non-template copy constructor (which is either explicitly
11417 or implicitly defined), there's no need to worry about their
11418 existence. Theoretically, they should never even be
11419 instantiated, but that's hard to forestall. */
11420 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11428 /* An operator with this code is unary, but can also be binary. */
11431 ambi_op_p (enum tree_code code
)
11433 return (code
== INDIRECT_REF
11434 || code
== ADDR_EXPR
11435 || code
== UNARY_PLUS_EXPR
11436 || code
== NEGATE_EXPR
11437 || code
== PREINCREMENT_EXPR
11438 || code
== PREDECREMENT_EXPR
);
11441 /* An operator with this name can only be unary. */
11444 unary_op_p (enum tree_code code
)
11446 return (code
== TRUTH_NOT_EXPR
11447 || code
== BIT_NOT_EXPR
11448 || code
== COMPONENT_REF
11449 || code
== TYPE_EXPR
);
11452 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11453 errors are issued for invalid declarations. */
11456 grok_op_properties (tree decl
, bool complain
)
11458 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11460 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11461 tree name
= DECL_NAME (decl
);
11462 enum tree_code operator_code
;
11467 /* Count the number of arguments and check for ellipsis. */
11468 for (argtype
= argtypes
, arity
= 0;
11469 argtype
&& argtype
!= void_list_node
;
11470 argtype
= TREE_CHAIN (argtype
))
11472 ellipsis_p
= !argtype
;
11474 class_type
= DECL_CONTEXT (decl
);
11475 if (class_type
&& !CLASS_TYPE_P (class_type
))
11476 class_type
= NULL_TREE
;
11478 if (DECL_CONV_FN_P (decl
))
11479 operator_code
= TYPE_EXPR
;
11483 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11484 if (ansi_opname (CODE) == name) \
11486 operator_code = (CODE); \
11489 else if (ansi_assopname (CODE) == name) \
11491 operator_code = (CODE); \
11492 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11496 #include "operators.def"
11497 #undef DEF_OPERATOR
11499 gcc_unreachable ();
11502 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11503 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11506 switch (operator_code
)
11509 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11513 TYPE_GETS_DELETE (class_type
) |= 1;
11517 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11520 case VEC_DELETE_EXPR
:
11521 TYPE_GETS_DELETE (class_type
) |= 2;
11528 /* [basic.std.dynamic.allocation]/1:
11530 A program is ill-formed if an allocation function is declared
11531 in a namespace scope other than global scope or declared static
11534 The same also holds true for deallocation functions. */
11535 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11536 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11538 if (DECL_NAMESPACE_SCOPE_P (decl
))
11540 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11542 error ("%qD may not be declared within a namespace", decl
);
11545 else if (!TREE_PUBLIC (decl
))
11547 error ("%qD may not be declared as static", decl
);
11553 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11555 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11556 DECL_IS_OPERATOR_NEW (decl
) = 1;
11558 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11559 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11562 /* An operator function must either be a non-static member function
11563 or have at least one parameter of a class, a reference to a class,
11564 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11565 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11567 if (operator_code
== TYPE_EXPR
11568 || operator_code
== CALL_EXPR
11569 || operator_code
== COMPONENT_REF
11570 || operator_code
== ARRAY_REF
11571 || operator_code
== NOP_EXPR
)
11573 error ("%qD must be a nonstatic member function", decl
);
11580 if (DECL_STATIC_FUNCTION_P (decl
))
11582 error ("%qD must be either a non-static member "
11583 "function or a non-member function", decl
);
11587 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11589 tree arg
= non_reference (TREE_VALUE (p
));
11590 if (arg
== error_mark_node
)
11593 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11594 because these checks are performed even on
11595 template functions. */
11596 if (MAYBE_CLASS_TYPE_P (arg
)
11597 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11601 if (!p
|| p
== void_list_node
)
11604 error ("%qD must have an argument of class or "
11605 "enumerated type", decl
);
11611 /* There are no restrictions on the arguments to an overloaded
11613 if (operator_code
== CALL_EXPR
)
11616 /* Warn about conversion operators that will never be used. */
11617 if (IDENTIFIER_TYPENAME_P (name
)
11618 && ! DECL_TEMPLATE_INFO (decl
)
11620 /* Warn only declaring the function; there is no need to
11621 warn again about out-of-class definitions. */
11622 && class_type
== current_class_type
)
11624 tree t
= TREE_TYPE (name
);
11625 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11628 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11630 if (VOID_TYPE_P (t
))
11631 warning (OPT_Wconversion
,
11633 ? G_("conversion to a reference to void "
11634 "will never use a type conversion operator")
11635 : G_("conversion to void "
11636 "will never use a type conversion operator"));
11637 else if (class_type
)
11639 if (t
== class_type
)
11640 warning (OPT_Wconversion
,
11642 ? G_("conversion to a reference to the same type "
11643 "will never use a type conversion operator")
11644 : G_("conversion to the same type "
11645 "will never use a type conversion operator"));
11646 /* Don't force t to be complete here. */
11647 else if (MAYBE_CLASS_TYPE_P (t
)
11648 && COMPLETE_TYPE_P (t
)
11649 && DERIVED_FROM_P (t
, class_type
))
11650 warning (OPT_Wconversion
,
11652 ? G_("conversion to a reference to a base class "
11653 "will never use a type conversion operator")
11654 : G_("conversion to a base class "
11655 "will never use a type conversion operator"));
11660 if (operator_code
== COND_EXPR
)
11663 error ("ISO C++ prohibits overloading operator ?:");
11666 else if (ellipsis_p
)
11668 error ("%qD must not have variable number of arguments", decl
);
11671 else if (ambi_op_p (operator_code
))
11674 /* We pick the one-argument operator codes by default, so
11675 we don't have to change anything. */
11677 else if (arity
== 2)
11679 /* If we thought this was a unary operator, we now know
11680 it to be a binary operator. */
11681 switch (operator_code
)
11684 operator_code
= MULT_EXPR
;
11688 operator_code
= BIT_AND_EXPR
;
11691 case UNARY_PLUS_EXPR
:
11692 operator_code
= PLUS_EXPR
;
11696 operator_code
= MINUS_EXPR
;
11699 case PREINCREMENT_EXPR
:
11700 operator_code
= POSTINCREMENT_EXPR
;
11703 case PREDECREMENT_EXPR
:
11704 operator_code
= POSTDECREMENT_EXPR
;
11708 gcc_unreachable ();
11711 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11713 if ((operator_code
== POSTINCREMENT_EXPR
11714 || operator_code
== POSTDECREMENT_EXPR
)
11715 && ! processing_template_decl
11716 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11719 error ("postfix %qD must take %<int%> as its argument",
11722 error ("postfix %qD must take %<int%> as its second "
11730 error ("%qD must take either zero or one argument", decl
);
11732 error ("%qD must take either one or two arguments", decl
);
11736 /* More Effective C++ rule 6. */
11738 && (operator_code
== POSTINCREMENT_EXPR
11739 || operator_code
== POSTDECREMENT_EXPR
11740 || operator_code
== PREINCREMENT_EXPR
11741 || operator_code
== PREDECREMENT_EXPR
))
11743 tree arg
= TREE_VALUE (argtypes
);
11744 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11745 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11746 arg
= TREE_TYPE (arg
);
11747 arg
= TYPE_MAIN_VARIANT (arg
);
11748 if (operator_code
== PREINCREMENT_EXPR
11749 || operator_code
== PREDECREMENT_EXPR
)
11751 if (TREE_CODE (ret
) != REFERENCE_TYPE
11752 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11754 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11755 build_reference_type (arg
));
11759 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11760 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11764 else if (unary_op_p (operator_code
))
11769 error ("%qD must take %<void%>", decl
);
11771 error ("%qD must take exactly one argument", decl
);
11775 else /* if (binary_op_p (operator_code)) */
11780 error ("%qD must take exactly one argument", decl
);
11782 error ("%qD must take exactly two arguments", decl
);
11786 /* More Effective C++ rule 7. */
11788 && (operator_code
== TRUTH_ANDIF_EXPR
11789 || operator_code
== TRUTH_ORIF_EXPR
11790 || operator_code
== COMPOUND_EXPR
))
11791 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11795 /* Effective C++ rule 23. */
11798 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11799 && (operator_code
== PLUS_EXPR
11800 || operator_code
== MINUS_EXPR
11801 || operator_code
== TRUNC_DIV_EXPR
11802 || operator_code
== MULT_EXPR
11803 || operator_code
== TRUNC_MOD_EXPR
)
11804 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11805 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11807 /* [over.oper]/8 */
11808 for (; argtypes
&& argtypes
!= void_list_node
;
11809 argtypes
= TREE_CHAIN (argtypes
))
11810 if (TREE_PURPOSE (argtypes
))
11812 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11813 if (operator_code
== POSTINCREMENT_EXPR
11814 || operator_code
== POSTDECREMENT_EXPR
)
11816 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
11821 error ("%qD cannot have default arguments", decl
);
11829 /* Return a string giving the keyword associate with CODE. */
11831 static const char *
11832 tag_name (enum tag_types code
)
11844 case typename_type
:
11847 gcc_unreachable ();
11851 /* Name lookup in an elaborated-type-specifier (after the keyword
11852 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11853 elaborated-type-specifier is invalid, issue a diagnostic and return
11854 error_mark_node; otherwise, return the *_TYPE to which it referred.
11855 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11858 check_elaborated_type_specifier (enum tag_types tag_code
,
11860 bool allow_template_p
)
11866 struct S { struct S *p; };
11868 name lookup will find the TYPE_DECL for the implicit "S::S"
11869 typedef. Adjust for that here. */
11870 if (DECL_SELF_REFERENCE_P (decl
))
11871 decl
= TYPE_NAME (TREE_TYPE (decl
));
11873 type
= TREE_TYPE (decl
);
11875 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11876 is false for this case as well. */
11877 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11879 error ("using template type parameter %qT after %qs",
11880 type
, tag_name (tag_code
));
11881 return error_mark_node
;
11883 /* Accept template template parameters. */
11884 else if (allow_template_p
11885 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
11886 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
11890 If the identifier resolves to a typedef-name or the
11891 simple-template-id resolves to an alias template
11892 specialization, the elaborated-type-specifier is ill-formed.
11894 In other words, the only legitimate declaration to use in the
11895 elaborated type specifier is the implicit typedef created when
11896 the type is declared. */
11897 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
11898 && !DECL_SELF_REFERENCE_P (decl
)
11899 && tag_code
!= typename_type
)
11901 if (alias_template_specialization_p (type
))
11902 error ("using alias template specialization %qT after %qs",
11903 type
, tag_name (tag_code
));
11905 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
11906 inform (DECL_SOURCE_LOCATION (decl
),
11907 "%qD has a previous declaration here", decl
);
11908 return error_mark_node
;
11910 else if (TREE_CODE (type
) != RECORD_TYPE
11911 && TREE_CODE (type
) != UNION_TYPE
11912 && tag_code
!= enum_type
11913 && tag_code
!= typename_type
)
11915 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
11916 inform (input_location
, "%q+T has a previous declaration here", type
);
11917 return error_mark_node
;
11919 else if (TREE_CODE (type
) != ENUMERAL_TYPE
11920 && tag_code
== enum_type
)
11922 error ("%qT referred to as enum", type
);
11923 inform (input_location
, "%q+T has a previous declaration here", type
);
11924 return error_mark_node
;
11926 else if (!allow_template_p
11927 && TREE_CODE (type
) == RECORD_TYPE
11928 && CLASSTYPE_IS_TEMPLATE (type
))
11930 /* If a class template appears as elaborated type specifier
11931 without a template header such as:
11933 template <class T> class C {};
11934 void f(class C); // No template header here
11936 then the required template argument is missing. */
11937 error ("template argument required for %<%s %T%>",
11938 tag_name (tag_code
),
11939 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
11940 return error_mark_node
;
11946 /* Lookup NAME in elaborate type specifier in scope according to
11947 SCOPE and issue diagnostics if necessary.
11948 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11949 found, and ERROR_MARK_NODE for type error. */
11952 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
11953 tag_scope scope
, bool template_header_p
)
11957 if (scope
== ts_global
)
11959 /* First try ordinary name lookup, ignoring hidden class name
11960 injected via friend declaration. */
11961 decl
= lookup_name_prefer_type (name
, 2);
11962 /* If that fails, the name will be placed in the smallest
11963 non-class, non-function-prototype scope according to 3.3.1/5.
11964 We may already have a hidden name declared as friend in this
11965 scope. So lookup again but not ignoring hidden names.
11966 If we find one, that name will be made visible rather than
11967 creating a new tag. */
11969 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
11972 decl
= lookup_type_scope (name
, scope
);
11975 && (DECL_CLASS_TEMPLATE_P (decl
)
11976 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl
)))
11977 decl
= DECL_TEMPLATE_RESULT (decl
);
11979 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
11981 /* Look for invalid nested type:
11985 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
11987 error ("%qD has the same name as the class in which it is "
11990 return error_mark_node
;
11993 /* Two cases we need to consider when deciding if a class
11994 template is allowed as an elaborated type specifier:
11995 1. It is a self reference to its own class.
11996 2. It comes with a template header.
12000 template <class T> class C {
12001 class C *c1; // DECL_SELF_REFERENCE_P is true
12004 template <class U> class C; // template_header_p is true
12005 template <class T> class C<T>::D {
12006 class C *c2; // DECL_SELF_REFERENCE_P is true
12009 t
= check_elaborated_type_specifier (tag_code
,
12012 | DECL_SELF_REFERENCE_P (decl
));
12015 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12017 error ("reference to %qD is ambiguous", name
);
12018 print_candidates (decl
);
12019 return error_mark_node
;
12025 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12026 Define the tag as a forward-reference if it is not defined.
12028 If a declaration is given, process it here, and report an error if
12029 multiple declarations are not identical.
12031 SCOPE is TS_CURRENT when this is also a definition. Only look in
12032 the current frame for the name (since C++ allows new names in any
12033 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12034 declaration. Only look beginning from the current scope outward up
12035 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12037 TEMPLATE_HEADER_P is true when this declaration is preceded by
12038 a set of template parameters. */
12041 xref_tag_1 (enum tag_types tag_code
, tree name
,
12042 tag_scope orig_scope
, bool template_header_p
)
12044 enum tree_code code
;
12046 tree context
= NULL_TREE
;
12049 gcc_assert (identifier_p (name
));
12055 code
= RECORD_TYPE
;
12061 code
= ENUMERAL_TYPE
;
12064 gcc_unreachable ();
12067 if (orig_scope
== ts_lambda
)
12068 scope
= ts_current
;
12070 scope
= orig_scope
;
12072 /* In case of anonymous name, xref_tag is only called to
12073 make type node and push name. Name lookup is not required. */
12074 if (ANON_AGGRNAME_P (name
))
12077 t
= lookup_and_check_tag (tag_code
, name
,
12078 scope
, template_header_p
);
12080 if (t
== error_mark_node
)
12081 return error_mark_node
;
12083 if (scope
!= ts_current
&& t
&& current_class_type
12084 && template_class_depth (current_class_type
)
12085 && template_header_p
)
12087 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12090 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12091 definition of this tag. Since, in addition, we are currently
12092 processing a (member) template declaration of a template
12093 class, we must be very careful; consider:
12100 { template <class V>
12101 friend struct S1; };
12103 Here, the S2::S1 declaration should not be confused with the
12104 outer declaration. In particular, the inner version should
12105 have a template parameter of level 2, not level 1. This
12106 would be particularly important if the member declaration
12109 template <class V = U> friend struct S1;
12111 say, when we should tsubst into `U' when instantiating
12112 S2. On the other hand, when presented with:
12122 we must find the inner binding eventually. We
12123 accomplish this by making sure that the new type we
12124 create to represent this declaration has the right
12126 context
= TYPE_CONTEXT (t
);
12132 /* If no such tag is yet defined, create a forward-reference node
12133 and record it as the "definition".
12134 When a real declaration of this type is found,
12135 the forward-reference will be altered into a real type. */
12136 if (code
== ENUMERAL_TYPE
)
12138 error ("use of enum %q#D without previous declaration", name
);
12139 return error_mark_node
;
12143 t
= make_class_type (code
);
12144 TYPE_CONTEXT (t
) = context
;
12145 if (orig_scope
== ts_lambda
)
12146 /* Remember that we're declaring a lambda to avoid bogus errors
12147 in push_template_decl. */
12148 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12149 t
= pushtag (name
, t
, scope
);
12154 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12156 if (!redeclare_class_template (t
, current_template_parms
))
12157 return error_mark_node
;
12159 else if (!processing_template_decl
12160 && CLASS_TYPE_P (t
)
12161 && CLASSTYPE_IS_TEMPLATE (t
))
12163 error ("redeclaration of %qT as a non-template", t
);
12164 error ("previous declaration %q+D", t
);
12165 return error_mark_node
;
12168 /* Make injected friend class visible. */
12169 if (scope
!= ts_within_enclosing_non_class
12170 && hidden_name_p (TYPE_NAME (t
)))
12172 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12173 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12175 if (TYPE_TEMPLATE_INFO (t
))
12177 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12178 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12186 /* Wrapper for xref_tag_1. */
12189 xref_tag (enum tag_types tag_code
, tree name
,
12190 tag_scope scope
, bool template_header_p
)
12194 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12195 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12196 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12202 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12204 enum tag_types tag_kind
;
12206 if (TREE_CODE (old
) == RECORD_TYPE
)
12207 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12209 tag_kind
= union_type
;
12211 if (id
== NULL_TREE
)
12212 id
= TYPE_IDENTIFIER (old
);
12214 return xref_tag (tag_kind
, id
, scope
, false);
12217 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12218 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12219 access_* node, and the TREE_VALUE is the type of the base-class.
12220 Non-NULL TREE_TYPE indicates virtual inheritance.
12222 Returns true if the binfo hierarchy was successfully created,
12223 false if an error was detected. */
12226 xref_basetypes (tree ref
, tree base_list
)
12229 tree binfo
, base_binfo
;
12230 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12231 unsigned max_bases
= 0; /* Maximum direct bases. */
12233 tree default_access
;
12234 tree igo_prev
; /* Track Inheritance Graph Order. */
12236 if (ref
== error_mark_node
)
12239 /* The base of a derived class is private by default, all others are
12241 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12242 && CLASSTYPE_DECLARED_CLASS (ref
)
12243 ? access_private_node
: access_public_node
);
12245 /* First, make sure that any templates in base-classes are
12246 instantiated. This ensures that if we call ourselves recursively
12247 we do not get confused about which classes are marked and which
12249 basep
= &base_list
;
12252 tree basetype
= TREE_VALUE (*basep
);
12254 /* The dependent_type_p call below should really be dependent_scope_p
12255 so that we give a hard error about using an incomplete type as a
12256 base, but we allow it with a pedwarn for backward
12258 if (processing_template_decl
12259 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12260 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12261 if (!dependent_type_p (basetype
)
12262 && !complete_type_or_else (basetype
, NULL
))
12263 /* An incomplete type. Remove it from the list. */
12264 *basep
= TREE_CHAIN (*basep
);
12268 if (TREE_TYPE (*basep
))
12270 if (CLASS_TYPE_P (basetype
))
12271 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12272 basep
= &TREE_CHAIN (*basep
);
12276 TYPE_MARKED_P (ref
) = 1;
12278 /* The binfo slot should be empty, unless this is an (ill-formed)
12280 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12282 error ("redefinition of %q#T", ref
);
12286 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12288 binfo
= make_tree_binfo (max_bases
);
12290 TYPE_BINFO (ref
) = binfo
;
12291 BINFO_OFFSET (binfo
) = size_zero_node
;
12292 BINFO_TYPE (binfo
) = ref
;
12294 /* Apply base-class info set up to the variants of this type. */
12295 fixup_type_variants (ref
);
12299 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12300 /* An aggregate cannot have baseclasses. */
12301 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12303 if (TREE_CODE (ref
) == UNION_TYPE
)
12305 error ("derived union %qT invalid", ref
);
12312 if (TYPE_FOR_JAVA (ref
))
12314 error ("Java class %qT cannot have multiple bases", ref
);
12321 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12323 if (TYPE_FOR_JAVA (ref
))
12325 error ("Java class %qT cannot have virtual bases", ref
);
12330 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12332 tree access
= TREE_PURPOSE (base_list
);
12333 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12334 tree basetype
= TREE_VALUE (base_list
);
12336 if (access
== access_default_node
)
12337 access
= default_access
;
12339 if (PACK_EXPANSION_P (basetype
))
12340 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12341 if (TREE_CODE (basetype
) == TYPE_DECL
)
12342 basetype
= TREE_TYPE (basetype
);
12343 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12345 error ("base type %qT fails to be a struct or class type",
12350 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12351 TYPE_FOR_JAVA (ref
) = 1;
12353 base_binfo
= NULL_TREE
;
12354 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12356 base_binfo
= TYPE_BINFO (basetype
);
12357 /* The original basetype could have been a typedef'd type. */
12358 basetype
= BINFO_TYPE (base_binfo
);
12360 /* Inherit flags from the base. */
12361 TYPE_HAS_NEW_OPERATOR (ref
)
12362 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12363 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12364 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12365 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12366 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12367 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12368 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12369 CLASSTYPE_REPEATED_BASE_P (ref
)
12370 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12373 /* We must do this test after we've seen through a typedef
12375 if (TYPE_MARKED_P (basetype
))
12377 if (basetype
== ref
)
12378 error ("recursive type %qT undefined", basetype
);
12380 error ("duplicate base type %qT invalid", basetype
);
12384 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12385 /* Regenerate the pack expansion for the bases. */
12386 basetype
= make_pack_expansion (basetype
);
12388 TYPE_MARKED_P (basetype
) = 1;
12390 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12391 &igo_prev
, via_virtual
);
12392 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12393 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12395 BINFO_BASE_APPEND (binfo
, base_binfo
);
12396 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12399 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12400 /* If we didn't get max_vbases vbases, we must have shared at
12401 least one of them, and are therefore diamond shaped. */
12402 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12404 /* Unmark all the types. */
12405 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12406 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12407 TYPE_MARKED_P (ref
) = 0;
12409 /* Now see if we have a repeated base type. */
12410 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12412 for (base_binfo
= binfo
; base_binfo
;
12413 base_binfo
= TREE_CHAIN (base_binfo
))
12415 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12417 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12420 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12422 for (base_binfo
= binfo
; base_binfo
;
12423 base_binfo
= TREE_CHAIN (base_binfo
))
12424 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12425 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12434 /* Copies the enum-related properties from type SRC to type DST.
12435 Used with the underlying type of an enum and the enum itself. */
12437 copy_type_enum (tree dst
, tree src
)
12440 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12442 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12443 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12444 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12445 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12446 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12447 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12448 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12449 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12450 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12454 /* Begin compiling the definition of an enumeration type.
12457 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12459 UNDERLYING_TYPE is the type that will be used as the storage for
12460 the enumeration type. This should be NULL_TREE if no storage type
12463 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12465 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12467 Returns the type object, as yet incomplete.
12468 Also records info about it so that build_enumerator
12469 may be used to declare the individual values as they are read. */
12472 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12473 bool scoped_enum_p
, bool *is_new
)
12475 tree prevtype
= NULL_TREE
;
12476 gcc_assert (identifier_p (name
));
12480 /* [C++0x dcl.enum]p5:
12482 If not explicitly specified, the underlying type of a scoped
12483 enumeration type is int. */
12484 if (!underlying_type
&& scoped_enum_p
)
12485 underlying_type
= integer_type_node
;
12487 if (underlying_type
)
12488 underlying_type
= cv_unqualified (underlying_type
);
12490 /* If this is the real definition for a previous forward reference,
12491 fill in the contents in the same object that used to be the
12492 forward reference. */
12494 enumtype
= lookup_and_check_tag (enum_type
, name
,
12495 /*tag_scope=*/ts_current
,
12496 /*template_header_p=*/false);
12498 /* In case of a template_decl, the only check that should be deferred
12499 to instantiation time is the comparison of underlying types. */
12500 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12502 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12504 error_at (input_location
, "scoped/unscoped mismatch "
12505 "in enum %q#T", enumtype
);
12506 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12507 "previous definition here");
12508 enumtype
= error_mark_node
;
12510 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12512 error_at (input_location
, "underlying type mismatch "
12513 "in enum %q#T", enumtype
);
12514 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12515 "previous definition here");
12516 enumtype
= error_mark_node
;
12518 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12519 && !dependent_type_p (underlying_type
)
12520 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12521 && !same_type_p (underlying_type
,
12522 ENUM_UNDERLYING_TYPE (enumtype
)))
12524 error_at (input_location
, "different underlying type "
12525 "in enum %q#T", enumtype
);
12526 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12527 "previous definition here");
12528 underlying_type
= NULL_TREE
;
12532 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12533 || processing_template_decl
)
12535 /* In case of error, make a dummy enum to allow parsing to
12537 if (enumtype
== error_mark_node
)
12539 name
= make_anon_name ();
12540 enumtype
= NULL_TREE
;
12543 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12544 of an opaque enum, or an opaque enum of an already defined
12545 enumeration (C++0x only).
12546 In any other case, it'll be NULL_TREE. */
12552 prevtype
= enumtype
;
12554 /* Do not push the decl more than once, unless we need to
12555 compare underlying types at instantiation time */
12557 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12558 || (underlying_type
12559 && dependent_type_p (underlying_type
))
12560 || (ENUM_UNDERLYING_TYPE (enumtype
)
12561 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12563 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12564 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12567 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12570 if (enumtype
== error_mark_node
)
12571 return error_mark_node
;
12573 /* The enum is considered opaque until the opening '{' of the
12574 enumerator list. */
12575 SET_OPAQUE_ENUM_P (enumtype
, true);
12576 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12579 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12581 if (underlying_type
)
12583 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12585 copy_type_enum (enumtype
, underlying_type
);
12586 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12588 else if (dependent_type_p (underlying_type
))
12589 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12591 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12592 underlying_type
, enumtype
);
12595 /* If into a template class, the returned enum is always the first
12596 declaration (opaque or not) seen. This way all the references to
12597 this type will be to the same declaration. The following ones are used
12598 only to check for definition errors. */
12599 if (prevtype
&& processing_template_decl
)
12605 /* After processing and defining all the values of an enumeration type,
12606 install their decls in the enumeration type.
12607 ENUMTYPE is the type object. */
12610 finish_enum_value_list (tree enumtype
)
12613 tree underlying_type
;
12616 tree minnode
, maxnode
;
12619 bool fixed_underlying_type_p
12620 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12622 /* We built up the VALUES in reverse order. */
12623 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12625 /* For an enum defined in a template, just set the type of the values;
12626 all further processing is postponed until the template is
12627 instantiated. We need to set the type so that tsubst of a CONST_DECL
12629 if (processing_template_decl
)
12631 for (values
= TYPE_VALUES (enumtype
);
12633 values
= TREE_CHAIN (values
))
12634 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12638 /* Determine the minimum and maximum values of the enumerators. */
12639 if (TYPE_VALUES (enumtype
))
12641 minnode
= maxnode
= NULL_TREE
;
12643 for (values
= TYPE_VALUES (enumtype
);
12645 values
= TREE_CHAIN (values
))
12647 decl
= TREE_VALUE (values
);
12649 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12650 each enumerator has the type of its enumeration. Prior to the
12651 closing brace, the type of each enumerator is the type of its
12652 initializing value. */
12653 TREE_TYPE (decl
) = enumtype
;
12655 /* Update the minimum and maximum values, if appropriate. */
12656 value
= DECL_INITIAL (decl
);
12657 if (value
== error_mark_node
)
12658 value
= integer_zero_node
;
12659 /* Figure out what the minimum and maximum values of the
12660 enumerators are. */
12662 minnode
= maxnode
= value
;
12663 else if (tree_int_cst_lt (maxnode
, value
))
12665 else if (tree_int_cst_lt (value
, minnode
))
12672 If the enumerator-list is empty, the underlying type is as if
12673 the enumeration had a single enumerator with value 0. */
12674 minnode
= maxnode
= integer_zero_node
;
12676 if (!fixed_underlying_type_p
)
12678 /* Compute the number of bits require to represent all values of the
12679 enumeration. We must do this before the type of MINNODE and
12680 MAXNODE are transformed, since tree_int_cst_min_precision relies
12681 on the TREE_TYPE of the value it is passed. */
12682 bool unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12683 int lowprec
= tree_int_cst_min_precision (minnode
, unsignedp
);
12684 int highprec
= tree_int_cst_min_precision (maxnode
, unsignedp
);
12685 int precision
= MAX (lowprec
, highprec
);
12687 bool use_short_enum
;
12689 /* Determine the underlying type of the enumeration.
12693 The underlying type of an enumeration is an integral type that
12694 can represent all the enumerator values defined in the
12695 enumeration. It is implementation-defined which integral type is
12696 used as the underlying type for an enumeration except that the
12697 underlying type shall not be larger than int unless the value of
12698 an enumerator cannot fit in an int or unsigned int.
12700 We use "int" or an "unsigned int" as the underlying type, even if
12701 a smaller integral type would work, unless the user has
12702 explicitly requested that we use the smallest possible type. The
12703 user can request that for all enumerations with a command line
12704 flag, or for just one enumeration with an attribute. */
12706 use_short_enum
= flag_short_enums
12707 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12709 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12713 underlying_type
= integer_types
[itk
];
12714 if (underlying_type
!= NULL_TREE
12715 && TYPE_PRECISION (underlying_type
) >= precision
12716 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
12719 if (itk
== itk_none
)
12723 IF no integral type can represent all the enumerator values, the
12724 enumeration is ill-formed. */
12725 error ("no integral type can represent all of the enumerator values "
12726 "for %qT", enumtype
);
12727 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12728 underlying_type
= integer_types
[itk_unsigned_long_long
];
12733 The value of sizeof() applied to an enumeration type, an object
12734 of an enumeration type, or an enumerator, is the value of sizeof()
12735 applied to the underlying type. */
12736 copy_type_enum (enumtype
, underlying_type
);
12738 /* Compute the minimum and maximum values for the type.
12742 For an enumeration where emin is the smallest enumerator and emax
12743 is the largest, the values of the enumeration are the values of the
12744 underlying type in the range bmin to bmax, where bmin and bmax are,
12745 respectively, the smallest and largest values of the smallest bit-
12746 field that can store emin and emax. */
12748 /* The middle-end currently assumes that types with TYPE_PRECISION
12749 narrower than their underlying type are suitably zero or sign
12750 extended to fill their mode. Similarly, it assumes that the front
12751 end assures that a value of a particular type must be within
12752 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12754 We used to set these fields based on bmin and bmax, but that led
12755 to invalid assumptions like optimizing away bounds checking. So
12756 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12757 TYPE_MAX_VALUE to the values for the mode above and only restrict
12758 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12759 ENUM_UNDERLYING_TYPE (enumtype
)
12760 = build_distinct_type_copy (underlying_type
);
12761 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12762 set_min_and_max_values_for_integral_type
12763 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, unsignedp
);
12765 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12766 if (flag_strict_enums
)
12767 set_min_and_max_values_for_integral_type (enumtype
, precision
,
12771 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12773 /* Convert each of the enumerators to the type of the underlying
12774 type of the enumeration. */
12775 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12777 location_t saved_location
;
12779 decl
= TREE_VALUE (values
);
12780 saved_location
= input_location
;
12781 input_location
= DECL_SOURCE_LOCATION (decl
);
12782 if (fixed_underlying_type_p
)
12783 /* If the enumeration type has a fixed underlying type, we
12784 already checked all of the enumerator values. */
12785 value
= DECL_INITIAL (decl
);
12787 value
= perform_implicit_conversion (underlying_type
,
12788 DECL_INITIAL (decl
),
12789 tf_warning_or_error
);
12790 input_location
= saved_location
;
12792 /* Do not clobber shared ints. */
12793 value
= copy_node (value
);
12795 TREE_TYPE (value
) = enumtype
;
12796 DECL_INITIAL (decl
) = value
;
12799 /* Fix up all variant types of this enum type. */
12800 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12801 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12803 if (at_class_scope_p ()
12804 && COMPLETE_TYPE_P (current_class_type
)
12805 && UNSCOPED_ENUM_P (enumtype
))
12806 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
12807 current_class_type
);
12809 /* Finish debugging output for this type. */
12810 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12813 /* Finishes the enum type. This is called only the first time an
12814 enumeration is seen, be it opaque or odinary.
12815 ENUMTYPE is the type object. */
12818 finish_enum (tree enumtype
)
12820 if (processing_template_decl
)
12822 if (at_function_scope_p ())
12823 add_stmt (build_min (TAG_DEFN
, enumtype
));
12827 /* If this is a forward declaration, there should not be any variants,
12828 though we can get a variant in the middle of an enum-specifier with
12829 wacky code like 'enum E { e = sizeof(const E*) };' */
12830 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
12831 && (TYPE_VALUES (enumtype
)
12832 || !TYPE_NEXT_VARIANT (enumtype
)));
12835 /* Build and install a CONST_DECL for an enumeration constant of the
12836 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12837 LOC is the location of NAME.
12838 Assignment of sequential values by default is handled here. */
12841 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
12847 /* If the VALUE was erroneous, pretend it wasn't there; that will
12848 result in the enum being assigned the next value in sequence. */
12849 if (value
== error_mark_node
)
12852 /* Remove no-op casts from the value. */
12854 STRIP_TYPE_NOPS (value
);
12856 if (! processing_template_decl
)
12858 /* Validate and default VALUE. */
12859 if (value
!= NULL_TREE
)
12861 value
= cxx_constant_value (value
);
12863 if (TREE_CODE (value
) != INTEGER_CST
12864 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
12866 error ("enumerator value for %qD is not an integer constant",
12872 /* Default based on previous value. */
12873 if (value
== NULL_TREE
)
12875 if (TYPE_VALUES (enumtype
))
12880 /* C++03 7.2/4: If no initializer is specified for the first
12881 enumerator, the type is an unspecified integral
12882 type. Otherwise the type is the same as the type of the
12883 initializing value of the preceding enumerator unless the
12884 incremented value is not representable in that type, in
12885 which case the type is an unspecified integral type
12886 sufficient to contain the incremented value. */
12887 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12888 if (error_operand_p (prev_value
))
12889 value
= error_mark_node
;
12892 double_int di
= TREE_INT_CST (prev_value
)
12893 .add_with_sign (double_int_one
,
12894 false, &overflowed
);
12897 tree type
= TREE_TYPE (prev_value
);
12898 bool pos
= TYPE_UNSIGNED (type
) || !di
.is_negative ();
12899 if (!double_int_fits_to_tree_p (type
, di
))
12902 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
12904 type
= integer_types
[itk
];
12905 if (type
!= NULL_TREE
12906 && (pos
|| !TYPE_UNSIGNED (type
))
12907 && double_int_fits_to_tree_p (type
, di
))
12910 if (type
&& cxx_dialect
< cxx11
12911 && itk
> itk_unsigned_long
)
12912 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
12913 incremented enumerator value is too large for %<unsigned long%>" : "\
12914 incremented enumerator value is too large for %<long%>");
12916 if (type
== NULL_TREE
)
12919 value
= double_int_to_tree (type
, di
);
12924 error ("overflow in enumeration values at %qD", name
);
12925 value
= error_mark_node
;
12930 value
= integer_zero_node
;
12933 /* Remove no-op casts from the value. */
12934 STRIP_TYPE_NOPS (value
);
12936 /* If the underlying type of the enum is fixed, check whether
12937 the enumerator values fits in the underlying type. If it
12938 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12939 if (ENUM_UNDERLYING_TYPE (enumtype
)
12941 && TREE_CODE (value
) == INTEGER_CST
)
12943 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
12944 error ("enumerator value %E is outside the range of underlying "
12945 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
12947 /* Convert the value to the appropriate type. */
12948 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
12952 /* C++ associates enums with global, function, or class declarations. */
12953 context
= current_scope ();
12955 /* Build the actual enumeration constant. Note that the enumeration
12956 constants have the underlying type of the enum (if it is fixed)
12957 or the type of their initializer (if the underlying type of the
12958 enum is not fixed):
12962 If the underlying type is fixed, the type of each enumerator
12963 prior to the closing brace is the underlying type; if the
12964 initializing value of an enumerator cannot be represented by
12965 the underlying type, the program is ill-formed. If the
12966 underlying type is not fixed, the type of each enumerator is
12967 the type of its initializing value.
12969 If the underlying type is not fixed, it will be computed by
12970 finish_enum and we will reset the type of this enumerator. Of
12971 course, if we're processing a template, there may be no value. */
12972 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12974 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
12976 DECL_CONTEXT (decl
) = enumtype
;
12977 TREE_CONSTANT (decl
) = 1;
12978 TREE_READONLY (decl
) = 1;
12979 DECL_INITIAL (decl
) = value
;
12981 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
12982 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12983 on the TYPE_FIELDS list for `S'. (That's so that you can say
12984 things like `S::i' later.) */
12985 finish_member_declaration (decl
);
12989 /* Add this enumeration constant to the list for this type. */
12990 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12993 /* Look for an enumerator with the given NAME within the enumeration
12994 type ENUMTYPE. This routine is used primarily for qualified name
12995 lookup into an enumerator in C++0x, e.g.,
12997 enum class Color { Red, Green, Blue };
12999 Color color = Color::Red;
13001 Returns the value corresponding to the enumerator, or
13002 NULL_TREE if no such enumerator was found. */
13004 lookup_enumerator (tree enumtype
, tree name
)
13007 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13009 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13010 return e
? TREE_VALUE (e
) : NULL_TREE
;
13014 /* We're defining DECL. Make sure that its type is OK. */
13017 check_function_type (tree decl
, tree current_function_parms
)
13019 tree fntype
= TREE_TYPE (decl
);
13020 tree return_type
= complete_type (TREE_TYPE (fntype
));
13022 /* In a function definition, arg types must be complete. */
13023 require_complete_types_for_parms (current_function_parms
);
13025 if (dependent_type_p (return_type
)
13026 || type_uses_auto (return_type
))
13028 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13029 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13031 tree args
= TYPE_ARG_TYPES (fntype
);
13033 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13034 error ("return type %q#T is incomplete", return_type
);
13036 error ("return type has Java class type %q#T", return_type
);
13038 /* Make it return void instead. */
13039 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13040 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13042 TREE_CHAIN (args
));
13044 fntype
= build_function_type (void_type_node
, args
);
13046 = build_exception_variant (fntype
,
13047 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13048 fntype
= (cp_build_type_attribute_variant
13049 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13050 TREE_TYPE (decl
) = fntype
;
13053 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13056 /* Create the FUNCTION_DECL for a function definition.
13057 DECLSPECS and DECLARATOR are the parts of the declaration;
13058 they describe the function's name and the type it returns,
13059 but twisted together in a fashion that parallels the syntax of C.
13061 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13062 DECLARATOR is really the DECL for the function we are about to
13063 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13064 indicating that the function is an inline defined in-class.
13066 This function creates a binding context for the function body
13067 as well as setting up the FUNCTION_DECL in current_function_decl.
13069 For C++, we must first check whether that datum makes any sense.
13070 For example, "class A local_a(1,2);" means that variable local_a
13071 is an aggregate of type A, which should have a constructor
13072 applied to it with the argument list [1, 2].
13074 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13075 or may be a BLOCK if the function has been defined previously
13076 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13077 error_mark_node if the function has never been defined, or
13078 a BLOCK if the function has been defined somewhere. */
13081 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13083 tree ctype
= NULL_TREE
;
13086 int doing_friend
= 0;
13087 cp_binding_level
*bl
;
13088 tree current_function_parms
;
13089 struct c_fileinfo
*finfo
13090 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13091 bool honor_interface
;
13093 /* Sanity check. */
13094 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13095 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13097 fntype
= TREE_TYPE (decl1
);
13098 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13099 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13101 /* ISO C++ 11.4/5. A friend function defined in a class is in
13102 the (lexical) scope of the class in which it is defined. */
13103 if (!ctype
&& DECL_FRIEND_P (decl1
))
13105 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13107 /* CTYPE could be null here if we're dealing with a template;
13108 for example, `inline friend float foo()' inside a template
13109 will have no CTYPE set. */
13110 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13116 if (DECL_DECLARED_INLINE_P (decl1
)
13117 && lookup_attribute ("noinline", attrs
))
13118 warning (0, "inline function %q+D given attribute noinline", decl1
);
13120 /* Handle gnu_inline attribute. */
13121 if (GNU_INLINE_P (decl1
))
13123 DECL_EXTERNAL (decl1
) = 1;
13124 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13125 DECL_INTERFACE_KNOWN (decl1
) = 1;
13126 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13129 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13130 /* This is a constructor, we must ensure that any default args
13131 introduced by this definition are propagated to the clones
13132 now. The clones are used directly in overload resolution. */
13133 adjust_clone_args (decl1
);
13135 /* Sometimes we don't notice that a function is a static member, and
13136 build a METHOD_TYPE for it. Fix that up now. */
13137 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13138 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13140 /* Set up current_class_type, and enter the scope of the class, if
13143 push_nested_class (ctype
);
13144 else if (DECL_STATIC_FUNCTION_P (decl1
))
13145 push_nested_class (DECL_CONTEXT (decl1
));
13147 /* Now that we have entered the scope of the class, we must restore
13148 the bindings for any template parameters surrounding DECL1, if it
13149 is an inline member template. (Order is important; consider the
13150 case where a template parameter has the same name as a field of
13151 the class.) It is not until after this point that
13152 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13153 if (flags
& SF_INCLASS_INLINE
)
13154 maybe_begin_member_template_processing (decl1
);
13156 /* Effective C++ rule 15. */
13158 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13159 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13160 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13162 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13163 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13164 if (!DECL_INITIAL (decl1
))
13165 DECL_INITIAL (decl1
) = error_mark_node
;
13167 /* This function exists in static storage.
13168 (This does not mean `static' in the C sense!) */
13169 TREE_STATIC (decl1
) = 1;
13171 /* We must call push_template_decl after current_class_type is set
13172 up. (If we are processing inline definitions after exiting a
13173 class scope, current_class_type will be NULL_TREE until set above
13174 by push_nested_class.) */
13175 if (processing_template_decl
)
13177 tree newdecl1
= push_template_decl (decl1
);
13178 if (newdecl1
== error_mark_node
)
13180 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13181 pop_nested_class ();
13187 /* We are now in the scope of the function being defined. */
13188 current_function_decl
= decl1
;
13190 /* Save the parm names or decls from this function's declarator
13191 where store_parm_decls will find them. */
13192 current_function_parms
= DECL_ARGUMENTS (decl1
);
13194 /* Make sure the parameter and return types are reasonable. When
13195 you declare a function, these types can be incomplete, but they
13196 must be complete when you define the function. */
13197 check_function_type (decl1
, current_function_parms
);
13199 /* Build the return declaration for the function. */
13200 restype
= TREE_TYPE (fntype
);
13202 if (DECL_RESULT (decl1
) == NULL_TREE
)
13206 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13207 DECL_ARTIFICIAL (resdecl
) = 1;
13208 DECL_IGNORED_P (resdecl
) = 1;
13209 DECL_RESULT (decl1
) = resdecl
;
13211 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13214 /* Let the user know we're compiling this function. */
13215 announce_function (decl1
);
13217 /* Record the decl so that the function name is defined.
13218 If we already have a decl for this name, and it is a FUNCTION_DECL,
13219 use the old decl. */
13220 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13222 /* A specialization is not used to guide overload resolution. */
13223 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13224 && !(DECL_USE_TEMPLATE (decl1
) &&
13225 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13227 tree olddecl
= pushdecl (decl1
);
13229 if (olddecl
== error_mark_node
)
13230 /* If something went wrong when registering the declaration,
13231 use DECL1; we have to have a FUNCTION_DECL to use when
13232 parsing the body of the function. */
13236 /* Otherwise, OLDDECL is either a previous declaration
13237 of the same function or DECL1 itself. */
13239 if (warn_missing_declarations
13240 && olddecl
== decl1
13241 && !DECL_MAIN_P (decl1
)
13242 && TREE_PUBLIC (decl1
)
13243 && !DECL_DECLARED_INLINE_P (decl1
))
13247 /* Check whether DECL1 is in an anonymous
13249 for (context
= DECL_CONTEXT (decl1
);
13251 context
= DECL_CONTEXT (context
))
13253 if (TREE_CODE (context
) == NAMESPACE_DECL
13254 && DECL_NAME (context
) == NULL_TREE
)
13258 if (context
== NULL
)
13259 warning (OPT_Wmissing_declarations
,
13260 "no previous declaration for %q+D", decl1
);
13268 /* We need to set the DECL_CONTEXT. */
13269 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13270 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13272 fntype
= TREE_TYPE (decl1
);
13273 restype
= TREE_TYPE (fntype
);
13275 /* If #pragma weak applies, mark the decl appropriately now.
13276 The pragma only applies to global functions. Because
13277 determining whether or not the #pragma applies involves
13278 computing the mangled name for the declaration, we cannot
13279 apply the pragma until after we have merged this declaration
13280 with any previous declarations; if the original declaration
13281 has a linkage specification, that specification applies to
13282 the definition as well, and may affect the mangled name. */
13283 if (DECL_FILE_SCOPE_P (decl1
))
13284 maybe_apply_pragma_weak (decl1
);
13287 /* Reset this in case the call to pushdecl changed it. */
13288 current_function_decl
= decl1
;
13290 gcc_assert (DECL_INITIAL (decl1
));
13292 /* This function may already have been parsed, in which case just
13293 return; our caller will skip over the body without parsing. */
13294 if (DECL_INITIAL (decl1
) != error_mark_node
)
13297 /* Initialize RTL machinery. We cannot do this until
13298 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13299 even when processing a template; this is how we get
13300 CFUN set up, and our per-function variables initialized.
13301 FIXME factor out the non-RTL stuff. */
13302 bl
= current_binding_level
;
13303 allocate_struct_function (decl1
, processing_template_decl
);
13305 /* Initialize the language data structures. Whenever we start
13306 a new function, we destroy temporaries in the usual way. */
13307 cfun
->language
= ggc_alloc_cleared_language_function ();
13308 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13309 current_binding_level
= bl
;
13311 if (!processing_template_decl
&& type_uses_auto (restype
))
13313 FNDECL_USED_AUTO (decl1
) = true;
13314 current_function_auto_return_pattern
= restype
;
13317 /* Start the statement-tree, start the tree now. */
13318 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13320 /* If we are (erroneously) defining a function that we have already
13321 defined before, wipe out what we knew before. */
13322 if (!DECL_PENDING_INLINE_P (decl1
))
13323 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13325 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13327 /* We know that this was set up by `grokclassfn'. We do not
13328 wait until `store_parm_decls', since evil parse errors may
13329 never get us to that point. Here we keep the consistency
13330 between `current_class_type' and `current_class_ptr'. */
13331 tree t
= DECL_ARGUMENTS (decl1
);
13333 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13334 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13336 cp_function_chain
->x_current_class_ref
13337 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13338 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13339 cp_function_chain
->x_current_class_ptr
= t
;
13341 /* Constructors and destructors need to know whether they're "in
13342 charge" of initializing virtual base classes. */
13343 t
= DECL_CHAIN (t
);
13344 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13346 current_in_charge_parm
= t
;
13347 t
= DECL_CHAIN (t
);
13349 if (DECL_HAS_VTT_PARM_P (decl1
))
13351 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13352 current_vtt_parm
= t
;
13356 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13357 /* Implicitly-defined methods (like the
13358 destructor for a class in which no destructor
13359 is explicitly declared) must not be defined
13360 until their definition is needed. So, we
13361 ignore interface specifications for
13362 compiler-generated functions. */
13363 && !DECL_ARTIFICIAL (decl1
));
13365 if (processing_template_decl
)
13366 /* Don't mess with interface flags. */;
13367 else if (DECL_INTERFACE_KNOWN (decl1
))
13369 tree ctx
= decl_function_context (decl1
);
13371 if (DECL_NOT_REALLY_EXTERN (decl1
))
13372 DECL_EXTERNAL (decl1
) = 0;
13374 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13375 /* This is a function in a local class in an extern inline
13376 or template function. */
13377 comdat_linkage (decl1
);
13379 /* If this function belongs to an interface, it is public.
13380 If it belongs to someone else's interface, it is also external.
13381 This only affects inlines and template instantiations. */
13382 else if (!finfo
->interface_unknown
&& honor_interface
)
13384 if (DECL_DECLARED_INLINE_P (decl1
)
13385 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13387 DECL_EXTERNAL (decl1
)
13388 = (finfo
->interface_only
13389 || (DECL_DECLARED_INLINE_P (decl1
)
13390 && ! flag_implement_inlines
13391 && !DECL_VINDEX (decl1
)));
13393 /* For WIN32 we also want to put these in linkonce sections. */
13394 maybe_make_one_only (decl1
);
13397 DECL_EXTERNAL (decl1
) = 0;
13398 DECL_INTERFACE_KNOWN (decl1
) = 1;
13399 /* If this function is in an interface implemented in this file,
13400 make sure that the back end knows to emit this function
13402 if (!DECL_EXTERNAL (decl1
))
13403 mark_needed (decl1
);
13405 else if (finfo
->interface_unknown
&& finfo
->interface_only
13406 && honor_interface
)
13408 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13409 interface, we will have both finfo->interface_unknown and
13410 finfo->interface_only set. In that case, we don't want to
13411 use the normal heuristics because someone will supply a
13412 #pragma implementation elsewhere, and deducing it here would
13413 produce a conflict. */
13414 comdat_linkage (decl1
);
13415 DECL_EXTERNAL (decl1
) = 0;
13416 DECL_INTERFACE_KNOWN (decl1
) = 1;
13417 DECL_DEFER_OUTPUT (decl1
) = 1;
13421 /* This is a definition, not a reference.
13422 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13423 if (!GNU_INLINE_P (decl1
))
13424 DECL_EXTERNAL (decl1
) = 0;
13426 if ((DECL_DECLARED_INLINE_P (decl1
)
13427 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13428 && ! DECL_INTERFACE_KNOWN (decl1
))
13429 DECL_DEFER_OUTPUT (decl1
) = 1;
13431 DECL_INTERFACE_KNOWN (decl1
) = 1;
13434 /* Determine the ELF visibility attribute for the function. We must not
13435 do this before calling "pushdecl", as we must allow "duplicate_decls"
13436 to merge any attributes appropriately. We also need to wait until
13438 if (!DECL_CLONED_FUNCTION_P (decl1
))
13439 determine_visibility (decl1
);
13441 begin_scope (sk_function_parms
, decl1
);
13445 if (DECL_DESTRUCTOR_P (decl1
)
13446 || (DECL_CONSTRUCTOR_P (decl1
)
13447 && targetm
.cxx
.cdtor_returns_this ()))
13449 cdtor_label
= build_decl (input_location
,
13450 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13451 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13454 start_fname_decls ();
13456 store_parm_decls (current_function_parms
);
13462 /* Like start_preparsed_function, except that instead of a
13463 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13465 Returns true on success. If the DECLARATOR is not suitable
13466 for a function, we return false, which tells the parser to
13467 skip the entire function. */
13470 start_function (cp_decl_specifier_seq
*declspecs
,
13471 const cp_declarator
*declarator
,
13476 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13477 if (decl1
== error_mark_node
)
13479 /* If the declarator is not suitable for a function definition,
13480 cause a syntax error. */
13481 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13483 error ("invalid function declaration");
13487 if (DECL_MAIN_P (decl1
))
13488 /* main must return int. grokfndecl should have corrected it
13489 (and issued a diagnostic) if the user got it wrong. */
13490 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13491 integer_type_node
));
13493 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13496 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13500 use_eh_spec_block (tree fn
)
13502 return (flag_exceptions
&& flag_enforce_eh_specs
13503 && !processing_template_decl
13504 && !type_throw_all_p (TREE_TYPE (fn
))
13505 /* We insert the EH_SPEC_BLOCK only in the original
13506 function; then, it is copied automatically to the
13508 && !DECL_CLONED_FUNCTION_P (fn
)
13509 /* Implicitly-generated constructors and destructors have
13510 exception specifications. However, those specifications
13511 are the union of the possible exceptions specified by the
13512 constructors/destructors for bases and members, so no
13513 unallowed exception will ever reach this function. By
13514 not creating the EH_SPEC_BLOCK we save a little memory,
13515 and we avoid spurious warnings about unreachable
13517 && !DECL_DEFAULTED_FN (fn
));
13520 /* Store the parameter declarations into the current function declaration.
13521 This is called after parsing the parameter declarations, before
13522 digesting the body of the function.
13524 Also install to binding contour return value identifier, if any. */
13527 store_parm_decls (tree current_function_parms
)
13529 tree fndecl
= current_function_decl
;
13532 /* This is a chain of any other decls that came in among the parm
13533 declarations. If a parm is declared with enum {foo, bar} x;
13534 then CONST_DECLs for foo and bar are put here. */
13535 tree nonparms
= NULL_TREE
;
13537 if (current_function_parms
)
13539 /* This case is when the function was defined with an ANSI prototype.
13540 The parms already have decls, so we need not do anything here
13541 except record them as in effect
13542 and complain if any redundant old-style parm decls were written. */
13544 tree specparms
= current_function_parms
;
13547 /* Must clear this because it might contain TYPE_DECLs declared
13549 current_binding_level
->names
= NULL
;
13551 /* If we're doing semantic analysis, then we'll call pushdecl
13552 for each of these. We must do them in reverse order so that
13553 they end in the correct forward order. */
13554 specparms
= nreverse (specparms
);
13556 for (parm
= specparms
; parm
; parm
= next
)
13558 next
= DECL_CHAIN (parm
);
13559 if (TREE_CODE (parm
) == PARM_DECL
)
13561 if (DECL_NAME (parm
) == NULL_TREE
13562 || !VOID_TYPE_P (parm
))
13565 error ("parameter %qD declared void", parm
);
13569 /* If we find an enum constant or a type tag,
13570 put it aside for the moment. */
13571 TREE_CHAIN (parm
) = NULL_TREE
;
13572 nonparms
= chainon (nonparms
, parm
);
13576 /* Get the decls in their original chain order and record in the
13577 function. This is all and only the PARM_DECLs that were
13578 pushed into scope by the loop above. */
13579 DECL_ARGUMENTS (fndecl
) = getdecls ();
13582 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13584 /* Now store the final chain of decls for the arguments
13585 as the decl-chain of the current lexical scope.
13586 Put the enumerators in as well, at the front so that
13587 DECL_ARGUMENTS is not modified. */
13588 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13590 if (use_eh_spec_block (current_function_decl
))
13591 current_eh_spec_block
= begin_eh_spec_block ();
13595 /* We have finished doing semantic analysis on DECL, but have not yet
13596 generated RTL for its body. Save away our current state, so that
13597 when we want to generate RTL later we know what to do. */
13600 save_function_data (tree decl
)
13602 struct language_function
*f
;
13604 /* Save the language-specific per-function data so that we can
13605 get it back when we really expand this function. */
13606 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13609 f
= ggc_alloc_language_function ();
13610 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13611 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13613 /* Clear out the bits we don't need. */
13614 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13615 f
->bindings
= NULL
;
13616 f
->x_local_names
= NULL
;
13617 f
->base
.local_typedefs
= NULL
;
13621 /* Set the return value of the constructor (if present). */
13624 finish_constructor_body (void)
13629 if (targetm
.cxx
.cdtor_returns_this ()
13630 && (! TYPE_FOR_JAVA (current_class_type
)))
13632 /* Any return from a constructor will end up here. */
13633 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13635 val
= DECL_ARGUMENTS (current_function_decl
);
13636 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13637 DECL_RESULT (current_function_decl
), val
);
13638 /* Return the address of the object. */
13639 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13640 add_stmt (exprstmt
);
13644 /* Do all the processing for the beginning of a destructor; set up the
13645 vtable pointers and cleanups for bases and members. */
13648 begin_destructor_body (void)
13650 tree compound_stmt
;
13652 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13653 issued an error message. We still want to try to process the
13654 body of the function, but initialize_vtbl_ptrs will crash if
13655 TYPE_BINFO is NULL. */
13656 if (COMPLETE_TYPE_P (current_class_type
))
13658 compound_stmt
= begin_compound_stmt (0);
13659 /* Make all virtual function table pointers in non-virtual base
13660 classes point to CURRENT_CLASS_TYPE's virtual function
13662 initialize_vtbl_ptrs (current_class_ptr
);
13663 finish_compound_stmt (compound_stmt
);
13665 /* Insert a cleanup to let the back end know that the object is dead
13666 when we exit the destructor, either normally or via exception. */
13667 tree clobber
= build_constructor (current_class_type
, NULL
);
13668 TREE_THIS_VOLATILE (clobber
) = true;
13669 tree exprstmt
= build2 (MODIFY_EXPR
, current_class_type
,
13670 current_class_ref
, clobber
);
13671 finish_decl_cleanup (NULL_TREE
, exprstmt
);
13673 /* And insert cleanups for our bases and members so that they
13674 will be properly destroyed if we throw. */
13675 push_base_cleanups ();
13679 /* At the end of every destructor we generate code to delete the object if
13680 necessary. Do that now. */
13683 finish_destructor_body (void)
13687 /* Any return from a destructor will end up here; that way all base
13688 and member cleanups will be run when the function returns. */
13689 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13691 /* In a virtual destructor, we must call delete. */
13692 if (DECL_VIRTUAL_P (current_function_decl
))
13695 tree virtual_size
= cxx_sizeof (current_class_type
);
13699 At the point of definition of a virtual destructor (including
13700 an implicit definition), non-placement operator delete shall
13701 be looked up in the scope of the destructor's class and if
13702 found shall be accessible and unambiguous. */
13703 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13705 /*global_p=*/false,
13706 /*placement=*/NULL_TREE
,
13707 /*alloc_fn=*/NULL_TREE
,
13708 tf_warning_or_error
);
13710 if_stmt
= begin_if_stmt ();
13711 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13712 current_in_charge_parm
,
13715 finish_expr_stmt (exprstmt
);
13716 finish_then_clause (if_stmt
);
13717 finish_if_stmt (if_stmt
);
13720 if (targetm
.cxx
.cdtor_returns_this ())
13724 val
= DECL_ARGUMENTS (current_function_decl
);
13725 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13726 DECL_RESULT (current_function_decl
), val
);
13727 /* Return the address of the object. */
13728 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13729 add_stmt (exprstmt
);
13733 /* Do the necessary processing for the beginning of a function body, which
13734 in this case includes member-initializers, but not the catch clauses of
13735 a function-try-block. Currently, this means opening a binding level
13736 for the member-initializers (in a ctor), member cleanups (in a dtor),
13737 and capture proxies (in a lambda operator()). */
13740 begin_function_body (void)
13744 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13747 if (processing_template_decl
)
13748 /* Do nothing now. */;
13750 /* Always keep the BLOCK node associated with the outermost pair of
13751 curly braces of a function. These are needed for correct
13752 operation of dwarfout.c. */
13753 keep_next_level (true);
13755 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13757 if (processing_template_decl
)
13758 /* Do nothing now. */;
13759 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13760 begin_destructor_body ();
13765 /* Do the processing for the end of a function body. Currently, this means
13766 closing out the cleanups for fully-constructed bases and members, and in
13767 the case of the destructor, deleting the object if desired. Again, this
13768 is only meaningful for [cd]tors, since they are the only functions where
13769 there is a significant distinction between the main body and any
13770 function catch clauses. Handling, say, main() return semantics here
13771 would be wrong, as flowing off the end of a function catch clause for
13772 main() would also need to return 0. */
13775 finish_function_body (tree compstmt
)
13777 if (compstmt
== NULL_TREE
)
13780 /* Close the block. */
13781 finish_compound_stmt (compstmt
);
13783 if (processing_template_decl
)
13784 /* Do nothing now. */;
13785 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
13786 finish_constructor_body ();
13787 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13788 finish_destructor_body ();
13791 /* Given a function, returns the BLOCK corresponding to the outermost level
13792 of curly braces, skipping the artificial block created for constructor
13796 outer_curly_brace_block (tree fndecl
)
13798 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
13799 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13800 /* Skip the artificial function body block. */
13801 block
= BLOCK_SUBBLOCKS (block
);
13805 /* If FNDECL is a class's key method, add the class to the list of
13806 keyed classes that should be emitted. */
13809 record_key_method_defined (tree fndecl
)
13811 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
13812 && DECL_VIRTUAL_P (fndecl
)
13813 && !processing_template_decl
)
13815 tree fnclass
= DECL_CONTEXT (fndecl
);
13816 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
13817 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
13821 /* Subroutine of finish_function.
13822 Save the body of constexpr functions for possible
13823 future compile time evaluation. */
13826 maybe_save_function_definition (tree fun
)
13828 if (!processing_template_decl
13829 && DECL_DECLARED_CONSTEXPR_P (fun
)
13830 && !DECL_CLONED_FUNCTION_P (fun
))
13831 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
13834 /* Finish up a function declaration and compile that function
13835 all the way to assembler language output. The free the storage
13836 for the function definition.
13838 FLAGS is a bitwise or of the following values:
13840 We just finished processing the body of an in-class inline
13841 function definition. (This processing will have taken place
13842 after the class definition is complete.) */
13845 finish_function (int flags
)
13847 tree fndecl
= current_function_decl
;
13848 tree fntype
, ctype
= NULL_TREE
;
13849 int inclass_inline
= (flags
& 2) != 0;
13851 /* When we get some parse errors, we can end up without a
13852 current_function_decl, so cope. */
13853 if (fndecl
== NULL_TREE
)
13854 return error_mark_node
;
13856 if (c_dialect_objc ())
13857 objc_finish_function ();
13859 gcc_assert (!defer_mark_used_calls
);
13860 defer_mark_used_calls
= true;
13862 record_key_method_defined (fndecl
);
13864 fntype
= TREE_TYPE (fndecl
);
13866 /* TREE_READONLY (fndecl) = 1;
13867 This caused &foo to be of type ptr-to-const-function
13868 which then got a warning when stored in a ptr-to-function variable. */
13870 gcc_assert (building_stmt_list_p ());
13871 /* The current function is being defined, so its DECL_INITIAL should
13872 be set, and unless there's a multiple definition, it should be
13873 error_mark_node. */
13874 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
13876 /* For a cloned function, we've already got all the code we need;
13877 there's no need to add any extra bits. */
13878 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13880 /* Make it so that `main' always returns 0 by default. */
13881 if (DECL_MAIN_P (current_function_decl
))
13882 finish_return_stmt (integer_zero_node
);
13884 if (use_eh_spec_block (current_function_decl
))
13885 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13886 (TREE_TYPE (current_function_decl
)),
13887 current_eh_spec_block
);
13890 /* If we're saving up tree structure, tie off the function now. */
13891 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
13893 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
13894 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
13896 finish_fname_decls ();
13898 /* If this function can't throw any exceptions, remember that. */
13899 if (!processing_template_decl
13900 && !cp_function_chain
->can_throw
13901 && !flag_non_call_exceptions
13902 && !decl_replaceable_p (fndecl
))
13903 TREE_NOTHROW (fndecl
) = 1;
13905 /* This must come after expand_function_end because cleanups might
13906 have declarations (from inline functions) that need to go into
13907 this function's blocks. */
13909 /* If the current binding level isn't the outermost binding level
13910 for this function, either there is a bug, or we have experienced
13911 syntax errors and the statement tree is malformed. */
13912 if (current_binding_level
->kind
!= sk_function_parms
)
13914 /* Make sure we have already experienced errors. */
13915 gcc_assert (errorcount
);
13917 /* Throw away the broken statement tree and extra binding
13919 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
13921 while (current_binding_level
->kind
!= sk_function_parms
)
13923 if (current_binding_level
->kind
== sk_class
)
13924 pop_nested_class ();
13926 poplevel (0, 0, 0);
13929 poplevel (1, 0, 1);
13931 /* Statements should always be full-expressions at the outermost set
13932 of curly braces for a function. */
13933 gcc_assert (stmts_are_full_exprs_p ());
13935 /* If there are no return statements in a function with auto return type,
13936 the return type is void. But if the declared type is something like
13937 auto*, this is an error. */
13938 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
13939 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
13941 if (!is_auto (current_function_auto_return_pattern
)
13942 && !current_function_returns_value
&& !current_function_returns_null
)
13944 error ("no return statements in function returning %qT",
13945 current_function_auto_return_pattern
);
13946 inform (input_location
, "only plain %<auto%> return type can be "
13947 "deduced to %<void%>");
13949 apply_deduced_return_type (fndecl
, void_type_node
);
13950 fntype
= TREE_TYPE (fndecl
);
13953 /* Save constexpr function body before it gets munged by
13954 the NRV transformation. */
13955 maybe_save_function_definition (fndecl
);
13957 /* Set up the named return value optimization, if we can. Candidate
13958 variables are selected in check_return_expr. */
13959 if (current_function_return_value
)
13961 tree r
= current_function_return_value
;
13964 if (r
!= error_mark_node
13965 /* This is only worth doing for fns that return in memory--and
13966 simpler, since we don't have to worry about promoted modes. */
13967 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
13968 /* Only allow this for variables declared in the outer scope of
13969 the function so we know that their lifetime always ends with a
13970 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13971 we were to do this optimization in tree-ssa. */
13972 && (outer
= outer_curly_brace_block (fndecl
))
13973 && chain_member (r
, BLOCK_VARS (outer
)))
13974 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
13976 current_function_return_value
= NULL_TREE
;
13979 /* Remember that we were in class scope. */
13980 if (current_class_name
)
13981 ctype
= current_class_type
;
13983 /* Must mark the RESULT_DECL as being in this function. */
13984 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13986 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13987 to the FUNCTION_DECL node itself. */
13988 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13990 /* Save away current state, if appropriate. */
13991 if (!processing_template_decl
)
13992 save_function_data (fndecl
);
13994 /* Complain if there's just no return statement. */
13995 if (warn_return_type
13996 && !VOID_TYPE_P (TREE_TYPE (fntype
))
13997 && !dependent_type_p (TREE_TYPE (fntype
))
13998 && !current_function_returns_value
&& !current_function_returns_null
13999 /* Don't complain if we abort or throw. */
14000 && !current_function_returns_abnormally
14001 /* Don't complain if we are declared noreturn. */
14002 && !TREE_THIS_VOLATILE (fndecl
)
14003 && !DECL_NAME (DECL_RESULT (fndecl
))
14004 && !TREE_NO_WARNING (fndecl
)
14005 /* Structor return values (if any) are set by the compiler. */
14006 && !DECL_CONSTRUCTOR_P (fndecl
)
14007 && !DECL_DESTRUCTOR_P (fndecl
)
14008 && targetm
.warn_func_return (fndecl
))
14010 warning (OPT_Wreturn_type
,
14011 "no return statement in function returning non-void");
14012 TREE_NO_WARNING (fndecl
) = 1;
14015 /* Store the end of the function, so that we get good line number
14016 info for the epilogue. */
14017 cfun
->function_end_locus
= input_location
;
14019 /* Complain about parameters that are only set, but never otherwise used. */
14020 if (warn_unused_but_set_parameter
14021 && !processing_template_decl
14022 && errorcount
== unused_but_set_errorcount
14023 && !DECL_CLONED_FUNCTION_P (fndecl
))
14027 for (decl
= DECL_ARGUMENTS (fndecl
);
14029 decl
= DECL_CHAIN (decl
))
14030 if (TREE_USED (decl
)
14031 && TREE_CODE (decl
) == PARM_DECL
14032 && !DECL_READ_P (decl
)
14033 && DECL_NAME (decl
)
14034 && !DECL_ARTIFICIAL (decl
)
14035 && !TREE_NO_WARNING (decl
)
14036 && !DECL_IN_SYSTEM_HEADER (decl
)
14037 && TREE_TYPE (decl
) != error_mark_node
14038 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14039 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14040 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14041 warning (OPT_Wunused_but_set_parameter
,
14042 "parameter %q+D set but not used", decl
);
14043 unused_but_set_errorcount
= errorcount
;
14046 /* Complain about locally defined typedefs that are not used in this
14048 maybe_warn_unused_local_typedefs ();
14050 /* Genericize before inlining. */
14051 if (!processing_template_decl
)
14053 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14054 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14055 cp_genericize (fndecl
);
14056 /* Clear out the bits we don't need. */
14057 f
->x_current_class_ptr
= NULL
;
14058 f
->x_current_class_ref
= NULL
;
14059 f
->x_eh_spec_block
= NULL
;
14060 f
->x_in_charge_parm
= NULL
;
14061 f
->x_vtt_parm
= NULL
;
14062 f
->x_return_value
= NULL
;
14063 f
->bindings
= NULL
;
14064 f
->extern_decl_map
= NULL
;
14066 /* Clear out the bits we don't need. */
14067 local_names
= NULL
;
14069 /* We're leaving the context of this function, so zap cfun. It's still in
14070 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14072 current_function_decl
= NULL
;
14074 /* If this is an in-class inline definition, we may have to pop the
14075 bindings for the template parameters that we added in
14076 maybe_begin_member_template_processing when start_function was
14078 if (inclass_inline
)
14079 maybe_end_member_template_processing ();
14081 /* Leave the scope of the class. */
14083 pop_nested_class ();
14088 current_function_decl
= NULL_TREE
;
14090 defer_mark_used_calls
= false;
14091 if (deferred_mark_used_calls
)
14096 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14098 vec_free (deferred_mark_used_calls
);
14104 /* Create the FUNCTION_DECL for a function definition.
14105 DECLSPECS and DECLARATOR are the parts of the declaration;
14106 they describe the return type and the name of the function,
14107 but twisted together in a fashion that parallels the syntax of C.
14109 This function creates a binding context for the function body
14110 as well as setting up the FUNCTION_DECL in current_function_decl.
14112 Returns a FUNCTION_DECL on success.
14114 If the DECLARATOR is not suitable for a function (it defines a datum
14115 instead), we return 0, which tells yyparse to report a parse error.
14117 May return void_type_node indicating that this method is actually
14118 a friend. See grokfield for more details.
14120 Came here with a `.pushlevel' .
14122 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14123 CHANGES TO CODE IN `grokfield'. */
14126 grokmethod (cp_decl_specifier_seq
*declspecs
,
14127 const cp_declarator
*declarator
, tree attrlist
)
14129 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14132 if (fndecl
== error_mark_node
)
14133 return error_mark_node
;
14135 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14137 error ("invalid member function declaration");
14138 return error_mark_node
;
14142 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14144 /* Pass friends other than inline friend functions back. */
14145 if (fndecl
== void_type_node
)
14148 if (DECL_IN_AGGR_P (fndecl
))
14150 if (DECL_CLASS_SCOPE_P (fndecl
))
14151 error ("%qD is already defined in class %qT", fndecl
,
14152 DECL_CONTEXT (fndecl
));
14153 return error_mark_node
;
14156 check_template_shadow (fndecl
);
14158 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14159 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14161 /* We process method specializations in finish_struct_1. */
14162 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14164 fndecl
= push_template_decl (fndecl
);
14165 if (fndecl
== error_mark_node
)
14169 if (! DECL_FRIEND_P (fndecl
))
14171 if (DECL_CHAIN (fndecl
))
14173 fndecl
= copy_node (fndecl
);
14174 TREE_CHAIN (fndecl
) = NULL_TREE
;
14178 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14180 DECL_IN_AGGR_P (fndecl
) = 1;
14185 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14186 we can lay it out later, when and if its type becomes complete.
14188 Also handle constexpr pointer to member variables where the initializer
14189 is an unlowered PTRMEM_CST because the class isn't complete yet. */
14192 maybe_register_incomplete_var (tree var
)
14194 gcc_assert (VAR_P (var
));
14196 /* Keep track of variables with incomplete types. */
14197 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14198 && DECL_EXTERNAL (var
))
14200 tree inner_type
= TREE_TYPE (var
);
14202 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14203 inner_type
= TREE_TYPE (inner_type
);
14204 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14206 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14207 /* RTTI TD entries are created while defining the type_info. */
14208 || (TYPE_LANG_SPECIFIC (inner_type
)
14209 && TYPE_BEING_DEFINED (inner_type
)))
14211 incomplete_var iv
= {var
, inner_type
};
14212 vec_safe_push (incomplete_vars
, iv
);
14214 else if (TYPE_PTRMEM_P (inner_type
)
14215 && DECL_INITIAL (var
)
14216 && TREE_CODE (DECL_INITIAL (var
)) == PTRMEM_CST
)
14218 tree context
= TYPE_PTRMEM_CLASS_TYPE (inner_type
);
14219 gcc_assert (TYPE_BEING_DEFINED (context
));
14220 incomplete_var iv
= {var
, context
};
14221 vec_safe_push (incomplete_vars
, iv
);
14226 /* Called when a class type (given by TYPE) is defined. If there are
14227 any existing VAR_DECLs whose type has been completed by this
14228 declaration, update them now. */
14231 complete_vars (tree type
)
14234 incomplete_var
*iv
;
14236 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14238 if (same_type_p (type
, iv
->incomplete_type
))
14240 tree var
= iv
->decl
;
14241 tree type
= TREE_TYPE (var
);
14243 if (TYPE_PTRMEM_P (type
))
14244 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14247 /* Complete the type of the variable. The VAR_DECL itself
14248 will be laid out in expand_expr. */
14249 complete_type (type
);
14250 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14253 /* Remove this entry from the list. */
14254 incomplete_vars
->unordered_remove (ix
);
14260 /* Check for pending declarations which may have abstract type. */
14261 complete_type_check_abstract (type
);
14264 /* If DECL is of a type which needs a cleanup, build and return an
14265 expression to perform that cleanup here. Return NULL_TREE if no
14266 cleanup need be done. */
14269 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14275 /* Assume no cleanup is required. */
14276 cleanup
= NULL_TREE
;
14278 if (error_operand_p (decl
))
14281 /* Handle "__attribute__((cleanup))". We run the cleanup function
14282 before the destructor since the destructor is what actually
14283 terminates the lifetime of the object. */
14284 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14291 /* Get the name specified by the user for the cleanup function. */
14292 id
= TREE_VALUE (TREE_VALUE (attr
));
14293 /* Look up the name to find the cleanup function to call. It is
14294 important to use lookup_name here because that is what is
14295 used in c-common.c:handle_cleanup_attribute when performing
14296 initial checks on the attribute. Note that those checks
14297 include ensuring that the function found is not an overloaded
14298 function, or an object with an overloaded call operator,
14299 etc.; we can rely on the fact that the function found is an
14300 ordinary FUNCTION_DECL. */
14301 fn
= lookup_name (id
);
14302 arg
= build_address (decl
);
14304 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14305 if (cleanup
== error_mark_node
)
14306 return error_mark_node
;
14308 /* Handle ordinary C++ destructors. */
14309 type
= TREE_TYPE (decl
);
14310 if (type_build_dtor_call (type
))
14312 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14316 if (TREE_CODE (type
) == ARRAY_TYPE
)
14319 addr
= build_address (decl
);
14321 call
= build_delete (TREE_TYPE (addr
), addr
,
14322 sfk_complete_destructor
, flags
, 0, complain
);
14323 if (call
== error_mark_node
)
14324 cleanup
= error_mark_node
;
14325 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14326 /* Discard the call. */;
14328 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14333 /* build_delete sets the location of the destructor call to the
14334 current location, even though the destructor is going to be
14335 called later, at the end of the current scope. This can lead to
14336 a "jumpy" behaviour for users of debuggers when they step around
14337 the end of the block. So let's unset the location of the
14338 destructor call instead. */
14339 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14340 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14345 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14346 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14347 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14350 static_fn_type (tree memfntype
)
14355 if (TYPE_PTRMEMFUNC_P (memfntype
))
14356 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14357 if (POINTER_TYPE_P (memfntype
)
14358 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14359 memfntype
= TREE_TYPE (memfntype
);
14360 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14362 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14363 args
= TYPE_ARG_TYPES (memfntype
);
14364 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14365 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14366 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14367 fntype
= (cp_build_type_attribute_variant
14368 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14369 fntype
= (build_exception_variant
14370 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14374 /* DECL was originally constructed as a non-static member function,
14375 but turned out to be static. Update it accordingly. */
14378 revert_static_member_fn (tree decl
)
14380 tree stype
= static_fn_type (decl
);
14381 cp_cv_quals quals
= type_memfn_quals (stype
);
14382 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14384 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14385 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14387 TREE_TYPE (decl
) = stype
;
14389 if (DECL_ARGUMENTS (decl
))
14390 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14391 DECL_STATIC_FUNCTION_P (decl
) = 1;
14394 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14395 one of the language-independent trees. */
14397 enum cp_tree_node_structure_enum
14398 cp_tree_node_structure (union lang_tree_node
* t
)
14400 switch (TREE_CODE (&t
->generic
))
14402 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14403 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14404 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14405 case OVERLOAD
: return TS_CP_OVERLOAD
;
14406 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14407 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14408 case BASELINK
: return TS_CP_BASELINK
;
14409 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14410 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14411 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14412 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14413 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14414 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14415 default: return TS_CP_GENERIC
;
14419 /* Build the void_list_node (void_type_node having been created). */
14421 build_void_list_node (void)
14423 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14428 cp_missing_noreturn_ok_p (tree decl
)
14430 /* A missing noreturn is ok for the `main' function. */
14431 return DECL_MAIN_P (decl
);
14434 /* Return the COMDAT group into which DECL should be placed. */
14437 cxx_comdat_group (tree decl
)
14441 /* Virtual tables, construction virtual tables, and virtual table
14442 tables all go in a single COMDAT group, named after the primary
14444 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14445 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
14446 /* For all other DECLs, the COMDAT group is the mangled name of the
14447 declaration itself. */
14450 while (DECL_THUNK_P (decl
))
14452 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14453 into the same section as the target function. In that case
14454 we must return target's name. */
14455 tree target
= THUNK_TARGET (decl
);
14456 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14457 && DECL_SECTION_NAME (target
) != NULL
14458 && DECL_ONE_ONLY (target
))
14463 name
= DECL_ASSEMBLER_NAME (decl
);
14469 /* Returns the return type for FN as written by the user, which may include
14470 a placeholder for a deduced return type. */
14473 fndecl_declared_return_type (tree fn
)
14475 fn
= STRIP_TEMPLATE (fn
);
14476 if (FNDECL_USED_AUTO (fn
))
14478 struct language_function
*f
= NULL
;
14479 if (DECL_STRUCT_FUNCTION (fn
))
14480 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
14482 f
= DECL_SAVED_FUNCTION_DATA (fn
);
14483 return f
->x_auto_return_pattern
;
14485 return TREE_TYPE (TREE_TYPE (fn
));
14488 /* Returns true iff DECL was declared with an auto return type and it has
14489 not yet been deduced to a real type. */
14492 undeduced_auto_decl (tree decl
)
14494 if (cxx_dialect
< cxx1y
)
14496 return type_uses_auto (TREE_TYPE (decl
));
14499 /* Complain if DECL has an undeduced return type. */
14502 require_deduced_type (tree decl
)
14504 if (undeduced_auto_decl (decl
))
14505 error ("use of %qD before deduction of %<auto%>", decl
);
14508 #include "gt-cp-decl.h"