1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
38 #include "tree-iterator.h"
39 #include "tree-inline.h"
46 #include "c-family/c-common.h"
47 #include "c-family/c-objc.h"
48 #include "c-family/c-pragma.h"
49 #include "diagnostic.h"
53 #include "pointer-set.h"
54 #include "splay-tree.h"
58 /* Possible cases of bad specifiers type used by bad_specifiers. */
60 BSP_VAR
, /* variable */
61 BSP_PARM
, /* parameter */
66 static tree
grokparms (tree parmlist
, tree
*);
67 static const char *redeclaration_error_message (tree
, tree
);
69 static int decl_jump_unsafe (tree
);
70 static void require_complete_types_for_parms (tree
);
71 static int ambi_op_p (enum tree_code
);
72 static int unary_op_p (enum tree_code
);
73 static void push_local_name (tree
);
74 static tree
grok_reference_init (tree
, tree
, tree
, int);
75 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
77 static int check_static_variable_definition (tree
, tree
);
78 static void record_unknown_type (tree
, const char *);
79 static tree
builtin_function_1 (tree
, tree
, bool);
80 static tree
build_library_fn_1 (tree
, enum tree_code
, tree
);
81 static int member_function_or_else (tree
, tree
, enum overload_flags
);
82 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
84 static void check_for_uninitialized_const_var (tree
);
85 static hashval_t
typename_hash (const void *);
86 static int typename_compare (const void *, const void *);
87 static tree
local_variable_p_walkfn (tree
*, int *, void *);
88 static tree
record_builtin_java_type (const char *, int);
89 static const char *tag_name (enum tag_types
);
90 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
91 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
92 static void maybe_deduce_size_from_array_init (tree
, tree
);
93 static void layout_var_decl (tree
);
94 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
95 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
96 static void save_function_data (tree
);
97 static void copy_type_enum (tree
, tree
);
98 static void check_function_type (tree
, tree
);
99 static void finish_constructor_body (void);
100 static void begin_destructor_body (void);
101 static void finish_destructor_body (void);
102 static void record_key_method_defined (tree
);
103 static tree
create_array_type_for_decl (tree
, tree
, tree
);
104 static tree
get_atexit_node (void);
105 static tree
get_dso_handle_node (void);
106 static tree
start_cleanup_fn (void);
107 static void end_cleanup_fn (void);
108 static tree
cp_make_fname_decl (location_t
, tree
, int);
109 static void initialize_predefined_identifiers (void);
110 static tree check_special_function_return_type
111 (special_function_kind
, tree
, tree
);
112 static tree
push_cp_library_fn (enum tree_code
, tree
);
113 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
);
114 static void store_parm_decls (tree
);
115 static void initialize_local_var (tree
, tree
);
116 static void expand_static_init (tree
, tree
);
118 /* The following symbols are subsumed in the cp_global_trees array, and
119 listed here individually for documentation purposes.
122 tree wchar_decl_node;
124 tree vtable_entry_type;
125 tree delta_type_node;
126 tree __t_desc_type_node;
128 tree class_type_node;
129 tree unknown_type_node;
131 Array type `vtable_entry_type[]'
134 tree vtbl_ptr_type_node;
141 A FUNCTION_DECL which can call `abort'. Not necessarily the
142 one that the user will declare, but sufficient to be called
143 by routines that want to abort the program.
147 The FUNCTION_DECL for the default `::operator delete'.
149 tree global_delete_fndecl;
152 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
153 tree tinfo_var_id; */
155 tree cp_global_trees
[CPTI_MAX
];
157 /* Indicates that there is a type value in some namespace, although
158 that is not necessarily in scope at the moment. */
160 tree global_type_node
;
162 /* The node that holds the "name" of the global scope. */
163 tree global_scope_name
;
165 #define local_names cp_function_chain->x_local_names
167 /* A list of objects which have constructors or destructors
168 which reside in the global scope. The decl is stored in
169 the TREE_VALUE slot and the initializer is stored
170 in the TREE_PURPOSE slot. */
171 tree static_aggregates
;
173 /* Like static_aggregates, but for thread_local variables. */
178 /* A node for the integer constant 2. */
180 tree integer_two_node
;
182 /* Used only for jumps to as-yet undefined labels, since jumps to
183 defined labels can have their validity checked immediately. */
185 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
186 struct named_label_use_entry
*next
;
187 /* The binding level to which this entry is *currently* attached.
188 This is initially the binding level in which the goto appeared,
189 but is modified as scopes are closed. */
190 cp_binding_level
*binding_level
;
191 /* The head of the names list that was current when the goto appeared,
192 or the inner scope popped. These are the decls that will *not* be
193 skipped when jumping to the label. */
195 /* The location of the goto, for error reporting. */
196 location_t o_goto_locus
;
197 /* True if an OpenMP structured block scope has been closed since
198 the goto appeared. This means that the branch from the label will
199 illegally exit an OpenMP scope. */
203 /* A list of all LABEL_DECLs in the function that have names. Here so
204 we can clear out their names' definitions at the end of the
205 function, and so we can check the validity of jumps to these labels. */
207 struct GTY(()) named_label_entry
{
208 /* The decl itself. */
211 /* The binding level to which the label is *currently* attached.
212 This is initially set to the binding level in which the label
213 is defined, but is modified as scopes are closed. */
214 cp_binding_level
*binding_level
;
215 /* The head of the names list that was current when the label was
216 defined, or the inner scope popped. These are the decls that will
217 be skipped when jumping to the label. */
219 /* A vector of all decls from all binding levels that would be
220 crossed by a backward branch to the label. */
221 vec
<tree
, va_gc
> *bad_decls
;
223 /* A list of uses of the label, before the label is defined. */
224 struct named_label_use_entry
*uses
;
226 /* The following bits are set after the label is defined, and are
227 updated as scopes are popped. They indicate that a backward jump
228 to the label will illegally enter a scope of the given flavor. */
234 #define named_labels cp_function_chain->x_named_labels
236 /* The number of function bodies which we are currently processing.
237 (Zero if we are at namespace scope, one inside the body of a
238 function, two inside the body of a function in a local class, etc.) */
241 /* To avoid unwanted recursion, finish_function defers all mark_used calls
242 encountered during its execution until it finishes. */
243 bool defer_mark_used_calls
;
244 vec
<tree
, va_gc
> *deferred_mark_used_calls
;
246 /* States indicating how grokdeclarator() should handle declspecs marked
247 with __attribute__((deprecated)). An object declared as
248 __attribute__((deprecated)) suppresses warnings of uses of other
250 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
253 /* A list of VAR_DECLs whose type was incomplete at the time the
254 variable was declared. */
256 typedef struct GTY(()) incomplete_var_d
{
258 tree incomplete_type
;
262 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
264 /* Returns the kind of template specialization we are currently
265 processing, given that it's declaration contained N_CLASS_SCOPES
266 explicit scope qualifications. */
269 current_tmpl_spec_kind (int n_class_scopes
)
271 int n_template_parm_scopes
= 0;
272 int seen_specialization_p
= 0;
273 int innermost_specialization_p
= 0;
276 /* Scan through the template parameter scopes. */
277 for (b
= current_binding_level
;
278 b
->kind
== sk_template_parms
;
281 /* If we see a specialization scope inside a parameter scope,
282 then something is wrong. That corresponds to a declaration
285 template <class T> template <> ...
287 which is always invalid since [temp.expl.spec] forbids the
288 specialization of a class member template if the enclosing
289 class templates are not explicitly specialized as well. */
290 if (b
->explicit_spec_p
)
292 if (n_template_parm_scopes
== 0)
293 innermost_specialization_p
= 1;
295 seen_specialization_p
= 1;
297 else if (seen_specialization_p
== 1)
298 return tsk_invalid_member_spec
;
300 ++n_template_parm_scopes
;
303 /* Handle explicit instantiations. */
304 if (processing_explicit_instantiation
)
306 if (n_template_parm_scopes
!= 0)
307 /* We've seen a template parameter list during an explicit
308 instantiation. For example:
310 template <class T> template void f(int);
312 This is erroneous. */
313 return tsk_invalid_expl_inst
;
315 return tsk_expl_inst
;
318 if (n_template_parm_scopes
< n_class_scopes
)
319 /* We've not seen enough template headers to match all the
320 specialized classes present. For example:
322 template <class T> void R<T>::S<T>::f(int);
324 This is invalid; there needs to be one set of template
325 parameters for each class. */
326 return tsk_insufficient_parms
;
327 else if (n_template_parm_scopes
== n_class_scopes
)
328 /* We're processing a non-template declaration (even though it may
329 be a member of a template class.) For example:
331 template <class T> void S<T>::f(int);
333 The `class T' matches the `S<T>', leaving no template headers
334 corresponding to the `f'. */
336 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
337 /* We've got too many template headers. For example:
339 template <> template <class T> void f (T);
341 There need to be more enclosing classes. */
342 return tsk_excessive_parms
;
344 /* This must be a template. It's of the form:
346 template <class T> template <class U> void S<T>::f(U);
348 This is a specialization if the innermost level was a
349 specialization; otherwise it's just a definition of the
351 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
354 /* Exit the current scope. */
362 /* When a label goes out of scope, check to see if that label was used
363 in a valid manner, and issue any appropriate warnings or errors. */
366 pop_label (tree label
, tree old_value
)
368 if (!processing_template_decl
)
370 if (DECL_INITIAL (label
) == NULL_TREE
)
374 error ("label %q+D used but not defined", label
);
375 location
= input_location
; /* FIXME want (input_filename, (line)0) */
376 /* Avoid crashing later. */
377 define_label (location
, DECL_NAME (label
));
380 warn_for_unused_label (label
);
383 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
386 /* At the end of a function, all labels declared within the function
387 go out of scope. BLOCK is the top-level block for the
391 pop_labels_1 (void **slot
, void *data
)
393 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
394 tree block
= (tree
) data
;
396 pop_label (ent
->label_decl
, NULL_TREE
);
398 /* Put the labels into the "variables" of the top-level block,
399 so debugger can see them. */
400 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
401 BLOCK_VARS (block
) = ent
->label_decl
;
403 htab_clear_slot (named_labels
, slot
);
409 pop_labels (tree block
)
413 htab_traverse (named_labels
, pop_labels_1
, block
);
418 /* At the end of a block with local labels, restore the outer definition. */
421 pop_local_label (tree label
, tree old_value
)
423 struct named_label_entry dummy
;
426 pop_label (label
, old_value
);
428 dummy
.label_decl
= label
;
429 slot
= htab_find_slot (named_labels
, &dummy
, NO_INSERT
);
430 htab_clear_slot (named_labels
, slot
);
433 /* The following two routines are used to interface to Objective-C++.
434 The binding level is purposely treated as an opaque type. */
437 objc_get_current_scope (void)
439 return current_binding_level
;
442 /* The following routine is used by the NeXT-style SJLJ exceptions;
443 variables get marked 'volatile' so as to not be clobbered by
444 _setjmp()/_longjmp() calls. All variables in the current scope,
445 as well as parent scopes up to (but not including) ENCLOSING_BLK
446 shall be thusly marked. */
449 objc_mark_locals_volatile (void *enclosing_blk
)
451 cp_binding_level
*scope
;
453 for (scope
= current_binding_level
;
454 scope
&& scope
!= enclosing_blk
;
455 scope
= scope
->level_chain
)
459 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
460 objc_volatilize_decl (decl
);
462 /* Do not climb up past the current function. */
463 if (scope
->kind
== sk_function_parms
)
468 /* Update data for defined and undefined labels when leaving a scope. */
471 poplevel_named_label_1 (void **slot
, void *data
)
473 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
474 cp_binding_level
*bl
= (cp_binding_level
*) data
;
475 cp_binding_level
*obl
= bl
->level_chain
;
477 if (ent
->binding_level
== bl
)
481 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
482 TREE_LISTs representing OVERLOADs, so be careful. */
483 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
485 : TREE_CHAIN (decl
)))
486 if (decl_jump_unsafe (decl
))
487 vec_safe_push (ent
->bad_decls
, decl
);
489 ent
->binding_level
= obl
;
490 ent
->names_in_scope
= obl
->names
;
494 ent
->in_try_scope
= true;
497 ent
->in_catch_scope
= true;
500 ent
->in_omp_scope
= true;
508 struct named_label_use_entry
*use
;
510 for (use
= ent
->uses
; use
; use
= use
->next
)
511 if (use
->binding_level
== bl
)
513 use
->binding_level
= obl
;
514 use
->names_in_scope
= obl
->names
;
515 if (bl
->kind
== sk_omp
)
516 use
->in_omp_scope
= true;
523 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
524 when errors were reported, except for -Werror-unused-but-set-*. */
525 static int unused_but_set_errorcount
;
527 /* Exit a binding level.
528 Pop the level off, and restore the state of the identifier-decl mappings
529 that were in effect when this level was entered.
531 If KEEP == 1, this level had explicit declarations, so
532 and create a "block" (a BLOCK node) for the level
533 to record its declarations and subblocks for symbol table output.
535 If FUNCTIONBODY is nonzero, this level is the body of a function,
536 so create a block as if KEEP were set and also clear out all
539 If REVERSE is nonzero, reverse the order of decls before putting
540 them into the BLOCK. */
543 poplevel (int keep
, int reverse
, int functionbody
)
546 /* The chain of decls was accumulated in reverse order.
547 Put it into forward order, just for cleanliness. */
552 int leaving_for_scope
;
555 cp_label_binding
*label_bind
;
557 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
562 gcc_assert (current_binding_level
->kind
!= sk_class
);
564 if (current_binding_level
->kind
== sk_cleanup
)
566 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
568 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
570 /* We used to use KEEP == 2 to indicate that the new block should go
571 at the beginning of the list of blocks at this binding level,
572 rather than the end. This hack is no longer used. */
573 gcc_assert (keep
== 0 || keep
== 1);
575 if (current_binding_level
->keep
)
578 /* Any uses of undefined labels, and any defined labels, now operate
579 under constraints of next binding contour. */
580 if (cfun
&& !functionbody
&& named_labels
)
581 htab_traverse (named_labels
, poplevel_named_label_1
,
582 current_binding_level
);
584 /* Get the decls in the order they were written.
585 Usually current_binding_level->names is in reverse order.
586 But parameter decls were previously put in forward order. */
589 current_binding_level
->names
590 = decls
= nreverse (current_binding_level
->names
);
592 decls
= current_binding_level
->names
;
594 /* If there were any declarations or structure tags in that level,
595 or if this level is a function body,
596 create a BLOCK to record them for the life of this function. */
598 if (keep
== 1 || functionbody
)
599 block
= make_node (BLOCK
);
600 if (block
!= NULL_TREE
)
602 BLOCK_VARS (block
) = decls
;
603 BLOCK_SUBBLOCKS (block
) = subblocks
;
606 /* In each subblock, record that this is its superior. */
608 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
609 BLOCK_SUPERCONTEXT (link
) = block
;
611 /* We still support the old for-scope rules, whereby the variables
612 in a for-init statement were in scope after the for-statement
613 ended. We only use the new rules if flag_new_for_scope is
616 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
618 /* Before we remove the declarations first check for unused variables. */
619 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
620 && !processing_template_decl
)
621 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
623 /* There are cases where D itself is a TREE_LIST. See in
624 push_local_binding where the list of decls returned by
625 getdecls is built. */
626 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
627 if (TREE_CODE (decl
) == VAR_DECL
628 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
629 && ! DECL_IN_SYSTEM_HEADER (decl
)
630 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
631 && TREE_TYPE (decl
) != error_mark_node
632 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
633 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
635 if (! TREE_USED (decl
))
636 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
637 else if (DECL_CONTEXT (decl
) == current_function_decl
638 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
639 && errorcount
== unused_but_set_errorcount
)
641 warning (OPT_Wunused_but_set_variable
,
642 "variable %q+D set but not used", decl
);
643 unused_but_set_errorcount
= errorcount
;
648 /* Remove declarations for all the DECLs in this level. */
649 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
651 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
652 /* It's hard to make this ARM compatibility hack play nicely with
653 lambdas, and it really isn't necessary in C++11 mode. */
654 && cxx_dialect
< cxx0x
657 tree name
= DECL_NAME (link
);
661 ob
= outer_binding (name
,
662 IDENTIFIER_BINDING (name
),
665 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
667 ns_binding
= NULL_TREE
;
669 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
670 /* We have something like:
675 and we are leaving the `for' scope. There's no reason to
676 keep the binding of the inner `i' in this case. */
677 pop_binding (name
, link
);
678 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
679 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
680 /* Here, we have something like:
688 We must pop the for-scope binding so we know what's a
689 type and what isn't. */
690 pop_binding (name
, link
);
693 /* Mark this VAR_DECL as dead so that we can tell we left it
694 there only for backward compatibility. */
695 DECL_DEAD_FOR_LOCAL (link
) = 1;
697 /* Keep track of what should have happened when we
698 popped the binding. */
701 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
702 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
705 /* Add it to the list of dead variables in the next
706 outermost binding to that we can remove these when we
707 leave that binding. */
709 current_binding_level
->level_chain
->dead_vars_from_for
,
712 /* Although we don't pop the cxx_binding, we do clear
713 its SCOPE since the scope is going away now. */
714 IDENTIFIER_BINDING (name
)->scope
715 = current_binding_level
->level_chain
;
722 /* Remove the binding. */
725 if (TREE_CODE (decl
) == TREE_LIST
)
726 decl
= TREE_VALUE (decl
);
729 if (TREE_CODE (name
) == OVERLOAD
)
730 name
= OVL_FUNCTION (name
);
732 gcc_assert (DECL_P (name
));
733 pop_binding (DECL_NAME (name
), decl
);
737 /* Remove declarations for any `for' variables from inner scopes
738 that we kept around. */
739 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
741 pop_binding (DECL_NAME (decl
), decl
);
743 /* Restore the IDENTIFIER_TYPE_VALUEs. */
744 for (link
= current_binding_level
->type_shadowed
;
745 link
; link
= TREE_CHAIN (link
))
746 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
748 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
749 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
751 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
753 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
754 list if a `using' declaration put them there. The debugging
755 back ends won't understand OVERLOAD, so we remove them here.
756 Because the BLOCK_VARS are (temporarily) shared with
757 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
758 popped all the bindings. */
763 for (d
= &BLOCK_VARS (block
); *d
; )
765 if (TREE_CODE (*d
) == TREE_LIST
)
766 *d
= TREE_CHAIN (*d
);
768 d
= &DECL_CHAIN (*d
);
772 /* If the level being exited is the top level of a function,
773 check over all the labels. */
776 /* Since this is the top level block of a function, the vars are
777 the function's parameters. Don't leave them in the BLOCK
778 because they are found in the FUNCTION_DECL instead. */
779 BLOCK_VARS (block
) = 0;
783 kind
= current_binding_level
->kind
;
784 if (kind
== sk_cleanup
)
788 /* If this is a temporary binding created for a cleanup, then we'll
789 have pushed a statement list level. Pop that, create a new
790 BIND_EXPR for the block, and insert it into the stream. */
791 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
792 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
799 /* The current function is being defined, so its DECL_INITIAL
800 should be error_mark_node. */
801 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
802 DECL_INITIAL (current_function_decl
) = block
;
805 current_binding_level
->blocks
806 = block_chainon (current_binding_level
->blocks
, block
);
808 /* If we did not make a block for the level just exited,
809 any blocks made for inner levels
810 (since they cannot be recorded as subblocks in that level)
811 must be carried forward so they will later become subblocks
812 of something else. */
814 current_binding_level
->blocks
815 = block_chainon (current_binding_level
->blocks
, subblocks
);
817 /* Each and every BLOCK node created here in `poplevel' is important
818 (e.g. for proper debugging information) so if we created one
819 earlier, mark it as "used". */
821 TREE_USED (block
) = 1;
823 /* All temporary bindings created for cleanups are popped silently. */
824 if (kind
== sk_cleanup
)
827 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
831 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
832 itself, calling F for each. The DATA is passed to F as well. */
835 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
838 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
840 result
|= (*f
) (name_space
, data
);
842 for (; current
; current
= DECL_CHAIN (current
))
843 result
|= walk_namespaces_r (current
, f
, data
);
848 /* Walk all the namespaces, calling F for each. The DATA is passed to
852 walk_namespaces (walk_namespaces_fn f
, void* data
)
854 return walk_namespaces_r (global_namespace
, f
, data
);
857 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
858 DATA is non-NULL, this is the last time we will call
859 wrapup_global_declarations for this NAMESPACE. */
862 wrapup_globals_for_namespace (tree name_space
, void* data
)
864 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
865 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
866 tree
*vec
= statics
->address ();
867 int len
= statics
->length ();
868 int last_time
= (data
!= 0);
872 check_global_declarations (vec
, len
);
873 emit_debug_global_declarations (vec
, len
);
877 /* Write out any globals that need to be output. */
878 return wrapup_global_declarations (vec
, len
);
882 /* In C++, you don't have to write `struct S' to refer to `S'; you
883 can just use `S'. We accomplish this by creating a TYPE_DECL as
884 if the user had written `typedef struct S S'. Create and return
885 the TYPE_DECL for TYPE. */
888 create_implicit_typedef (tree name
, tree type
)
892 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
893 DECL_ARTIFICIAL (decl
) = 1;
894 /* There are other implicit type declarations, like the one *within*
895 a class that allows you to write `S::S'. We must distinguish
897 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
898 TYPE_NAME (type
) = decl
;
899 TYPE_STUB_DECL (type
) = decl
;
904 /* Remember a local name for name-mangling purposes. */
907 push_local_name (tree decl
)
912 timevar_start (TV_NAME_LOOKUP
);
914 name
= DECL_NAME (decl
);
916 nelts
= vec_safe_length (local_names
);
917 for (i
= 0; i
< nelts
; i
++)
919 t
= (*local_names
)[i
];
920 if (DECL_NAME (t
) == name
)
922 if (!DECL_LANG_SPECIFIC (decl
))
923 retrofit_lang_decl (decl
);
924 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
925 if (DECL_LANG_SPECIFIC (t
))
926 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
928 DECL_DISCRIMINATOR (decl
) = 1;
930 (*local_names
)[i
] = decl
;
931 timevar_stop (TV_NAME_LOOKUP
);
936 vec_safe_push (local_names
, decl
);
937 timevar_stop (TV_NAME_LOOKUP
);
940 /* Subroutine of duplicate_decls: return truthvalue of whether
941 or not types of these decls match.
943 For C++, we must compare the parameter list so that `int' can match
944 `int&' in a parameter position, but `int&' is not confused with
948 decls_match (tree newdecl
, tree olddecl
)
952 if (newdecl
== olddecl
)
955 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
956 /* If the two DECLs are not even the same kind of thing, we're not
957 interested in their types. */
960 gcc_assert (DECL_P (newdecl
));
962 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
964 tree f1
= TREE_TYPE (newdecl
);
965 tree f2
= TREE_TYPE (olddecl
);
966 tree p1
= TYPE_ARG_TYPES (f1
);
967 tree p2
= TYPE_ARG_TYPES (f2
);
970 /* Specializations of different templates are different functions
971 even if they have the same type. */
972 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
973 ? DECL_TI_TEMPLATE (newdecl
)
975 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
976 ? DECL_TI_TEMPLATE (olddecl
)
981 /* The decls dont match if they correspond to two different versions
982 of the same function. Disallow extern "C" functions to be
984 if (compparms (p1
, p2
)
985 && same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
))
986 && !DECL_EXTERN_C_P (newdecl
)
987 && !DECL_EXTERN_C_P (olddecl
)
988 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
990 /* Mark functions as versions if necessary. Modify the mangled decl
991 name if necessary. */
992 if (DECL_FUNCTION_VERSIONED (newdecl
)
993 && DECL_FUNCTION_VERSIONED (olddecl
))
995 if (!DECL_FUNCTION_VERSIONED (newdecl
))
997 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
998 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
999 mangle_decl (newdecl
);
1001 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1003 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1004 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1005 mangle_decl (olddecl
);
1007 record_function_versions (olddecl
, newdecl
);
1011 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1012 && ! (DECL_EXTERN_C_P (newdecl
)
1013 && DECL_EXTERN_C_P (olddecl
)))
1016 /* A new declaration doesn't match a built-in one unless it
1017 is also extern "C". */
1018 if (DECL_IS_BUILTIN (olddecl
)
1019 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1022 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1025 /* A declaration with deduced return type should use its pre-deduction
1026 type for declaration matching. */
1027 if (FNDECL_USED_AUTO (olddecl
))
1028 r2
= DECL_STRUCT_FUNCTION (olddecl
)->language
->x_auto_return_pattern
;
1030 r2
= TREE_TYPE (f2
);
1032 if (same_type_p (TREE_TYPE (f1
), r2
))
1034 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1035 && (DECL_BUILT_IN (olddecl
)
1036 #ifndef NO_IMPLICIT_EXTERN_C
1037 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1038 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1042 types_match
= self_promoting_args_p (p1
);
1043 if (p1
== void_list_node
)
1044 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1046 #ifndef NO_IMPLICIT_EXTERN_C
1047 else if (!prototype_p (f1
)
1048 && (DECL_EXTERN_C_P (olddecl
)
1049 && DECL_IN_SYSTEM_HEADER (olddecl
)
1050 && !DECL_CLASS_SCOPE_P (olddecl
))
1051 && (DECL_EXTERN_C_P (newdecl
)
1052 && DECL_IN_SYSTEM_HEADER (newdecl
)
1053 && !DECL_CLASS_SCOPE_P (newdecl
)))
1055 types_match
= self_promoting_args_p (p2
);
1056 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1062 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1063 || comp_type_attributes (TREE_TYPE (newdecl
),
1064 TREE_TYPE (olddecl
)) != 0);
1069 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1071 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1072 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1075 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1076 DECL_TEMPLATE_PARMS (olddecl
)))
1079 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1080 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1081 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1083 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1084 DECL_TEMPLATE_RESULT (newdecl
));
1088 /* Need to check scope for variable declaration (VAR_DECL).
1089 For typedef (TYPE_DECL), scope is ignored. */
1090 if (TREE_CODE (newdecl
) == VAR_DECL
1091 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1093 Two declarations for an object with C language linkage
1094 with the same name (ignoring the namespace that qualify
1095 it) that appear in different namespace scopes refer to
1097 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1100 if (TREE_TYPE (newdecl
) == error_mark_node
)
1101 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1102 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1103 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1104 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1107 types_match
= comptypes (TREE_TYPE (newdecl
),
1108 TREE_TYPE (olddecl
),
1109 COMPARE_REDECLARATION
);
1115 /* If NEWDECL is `static' and an `extern' was seen previously,
1116 warn about it. OLDDECL is the previous declaration.
1118 Note that this does not apply to the C++ case of declaring
1119 a variable `extern const' and then later `const'.
1121 Don't complain about built-in functions, since they are beyond
1122 the user's control. */
1125 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1127 if (TREE_CODE (newdecl
) == TYPE_DECL
1128 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1129 || TREE_CODE (newdecl
) == CONST_DECL
1130 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1133 /* Don't get confused by static member functions; that's a different
1135 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1136 && DECL_STATIC_FUNCTION_P (newdecl
))
1139 /* If the old declaration was `static', or the new one isn't, then
1140 everything is OK. */
1141 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1144 /* It's OK to declare a builtin function as `static'. */
1145 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1146 && DECL_ARTIFICIAL (olddecl
))
1149 permerror (input_location
, "%qD was declared %<extern%> and later %<static%>", newdecl
);
1150 permerror (input_location
, "previous declaration of %q+D", olddecl
);
1153 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1154 function templates. If their exception specifications do not
1155 match, issue a diagnostic. */
1158 check_redeclaration_exception_specification (tree new_decl
,
1163 tree new_exceptions
;
1164 tree old_exceptions
;
1166 new_type
= TREE_TYPE (new_decl
);
1167 new_exceptions
= TYPE_RAISES_EXCEPTIONS (new_type
);
1168 old_type
= TREE_TYPE (old_decl
);
1169 old_exceptions
= TYPE_RAISES_EXCEPTIONS (old_type
);
1173 If any declaration of a function has an exception-specification,
1174 all declarations, including the definition and an explicit
1175 specialization, of that function shall have an
1176 exception-specification with the same set of type-ids. */
1177 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1178 && ! DECL_IS_BUILTIN (old_decl
)
1180 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1182 error ("declaration of %qF has a different exception specifier",
1184 error ("from previous declaration %q+F", old_decl
);
1188 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1189 Otherwise issue diagnostics. */
1192 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1194 old_decl
= STRIP_TEMPLATE (old_decl
);
1195 new_decl
= STRIP_TEMPLATE (new_decl
);
1196 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1197 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1199 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1200 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1202 if (TREE_CODE (old_decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (old_decl
))
1204 /* Hide a built-in declaration. */
1205 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1206 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1209 error ("redeclaration %qD differs in %<constexpr%>", new_decl
);
1210 error ("from previous declaration %q+D", old_decl
);
1214 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1215 && lookup_attribute ("gnu_inline", \
1216 DECL_ATTRIBUTES (fn)))
1218 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1219 If the redeclaration is invalid, a diagnostic is issued, and the
1220 error_mark_node is returned. Otherwise, OLDDECL is returned.
1222 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1225 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1228 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1230 unsigned olddecl_uid
= DECL_UID (olddecl
);
1231 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1232 int new_defines_function
= 0;
1233 tree new_template_info
;
1235 if (newdecl
== olddecl
)
1238 types_match
= decls_match (newdecl
, olddecl
);
1240 /* If either the type of the new decl or the type of the old decl is an
1241 error_mark_node, then that implies that we have already issued an
1242 error (earlier) for some bogus type specification, and in that case,
1243 it is rather pointless to harass the user with yet more error message
1244 about the same declaration, so just pretend the types match here. */
1245 if (TREE_TYPE (newdecl
) == error_mark_node
1246 || TREE_TYPE (olddecl
) == error_mark_node
)
1247 return error_mark_node
;
1249 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1250 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1252 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1253 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1254 && check_raw_literal_operator (olddecl
))
1255 error ("literal operator template %q+D conflicts with"
1256 " raw literal operator %qD", newdecl
, olddecl
);
1257 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1258 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1259 && check_raw_literal_operator (newdecl
))
1260 error ("raw literal operator %q+D conflicts with"
1261 " literal operator template %qD", newdecl
, olddecl
);
1264 if (DECL_P (olddecl
)
1265 && TREE_CODE (newdecl
) == FUNCTION_DECL
1266 && TREE_CODE (olddecl
) == FUNCTION_DECL
1267 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1269 if (DECL_DECLARED_INLINE_P (newdecl
)
1270 && DECL_UNINLINABLE (newdecl
)
1271 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1272 /* Already warned elsewhere. */;
1273 else if (DECL_DECLARED_INLINE_P (olddecl
)
1274 && DECL_UNINLINABLE (olddecl
)
1275 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1276 /* Already warned. */;
1277 else if (DECL_DECLARED_INLINE_P (newdecl
)
1278 && DECL_UNINLINABLE (olddecl
)
1279 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1281 warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1283 warning (OPT_Wattributes
, "previous declaration of %q+D "
1284 "with attribute noinline", olddecl
);
1286 else if (DECL_DECLARED_INLINE_P (olddecl
)
1287 && DECL_UNINLINABLE (newdecl
)
1288 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1290 warning (OPT_Wattributes
, "function %q+D redeclared with "
1291 "attribute noinline", newdecl
);
1292 warning (OPT_Wattributes
, "previous declaration of %q+D was inline",
1297 /* Check for redeclaration and other discrepancies. */
1298 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1299 && DECL_ARTIFICIAL (olddecl
))
1301 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1302 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1304 /* Avoid warnings redeclaring built-ins which have not been
1305 explicitly declared. */
1306 if (DECL_ANTICIPATED (olddecl
))
1309 /* If you declare a built-in or predefined function name as static,
1310 the old definition is overridden, but optionally warn this was a
1311 bad choice of name. */
1312 if (! TREE_PUBLIC (newdecl
))
1314 warning (OPT_Wshadow
,
1315 DECL_BUILT_IN (olddecl
)
1316 ? G_("shadowing built-in function %q#D")
1317 : G_("shadowing library function %q#D"), olddecl
);
1318 /* Discard the old built-in function. */
1321 /* If the built-in is not ansi, then programs can override
1322 it even globally without an error. */
1323 else if (! DECL_BUILT_IN (olddecl
))
1324 warning (0, "library function %q#D redeclared as non-function %q#D",
1328 error ("declaration of %q#D", newdecl
);
1329 error ("conflicts with built-in declaration %q#D",
1334 else if (!types_match
)
1336 /* Avoid warnings redeclaring built-ins which have not been
1337 explicitly declared. */
1338 if (DECL_ANTICIPATED (olddecl
))
1340 /* Deal with fileptr_type_node. FILE type is not known
1341 at the time we create the builtins. */
1344 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1345 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1347 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1350 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1352 tree t
= TREE_VALUE (t1
);
1354 if (TREE_CODE (t
) == POINTER_TYPE
1355 && TYPE_NAME (TREE_TYPE (t
))
1356 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1357 == get_identifier ("FILE")
1358 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1360 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1362 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1363 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1364 types_match
= decls_match (newdecl
, olddecl
);
1366 return duplicate_decls (newdecl
, olddecl
,
1368 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1371 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1374 else if ((DECL_EXTERN_C_P (newdecl
)
1375 && DECL_EXTERN_C_P (olddecl
))
1376 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1377 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1379 /* A near match; override the builtin. */
1381 if (TREE_PUBLIC (newdecl
))
1383 warning (0, "new declaration %q#D", newdecl
);
1384 warning (0, "ambiguates built-in declaration %q#D",
1388 warning (OPT_Wshadow
,
1389 DECL_BUILT_IN (olddecl
)
1390 ? G_("shadowing built-in function %q#D")
1391 : G_("shadowing library function %q#D"), olddecl
);
1394 /* Discard the old built-in function. */
1397 /* Replace the old RTL to avoid problems with inlining. */
1398 COPY_DECL_RTL (newdecl
, olddecl
);
1400 /* Even if the types match, prefer the new declarations type for
1401 built-ins which have not been explicitly declared, for
1402 exception lists, etc... */
1403 else if (DECL_IS_BUILTIN (olddecl
))
1405 tree type
= TREE_TYPE (newdecl
);
1406 tree attribs
= (*targetm
.merge_type_attributes
)
1407 (TREE_TYPE (olddecl
), type
);
1409 type
= cp_build_type_attribute_variant (type
, attribs
);
1410 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1413 /* If a function is explicitly declared "throw ()", propagate that to
1414 the corresponding builtin. */
1415 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1416 && DECL_ANTICIPATED (olddecl
)
1417 && TREE_NOTHROW (newdecl
)
1418 && !TREE_NOTHROW (olddecl
))
1420 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1421 tree tmpdecl
= builtin_decl_explicit (fncode
);
1422 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1423 TREE_NOTHROW (tmpdecl
) = 1;
1426 /* Whether or not the builtin can throw exceptions has no
1427 bearing on this declarator. */
1428 TREE_NOTHROW (olddecl
) = 0;
1430 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1432 /* If a builtin function is redeclared as `static', merge
1433 the declarations, but make the original one static. */
1434 DECL_THIS_STATIC (olddecl
) = 1;
1435 TREE_PUBLIC (olddecl
) = 0;
1437 /* Make the old declaration consistent with the new one so
1438 that all remnants of the builtin-ness of this function
1439 will be banished. */
1440 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1441 COPY_DECL_RTL (newdecl
, olddecl
);
1444 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1446 /* C++ Standard, 3.3, clause 4:
1447 "[Note: a namespace name or a class template name must be unique
1448 in its declarative region (7.3.2, clause 14). ]" */
1449 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1450 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1451 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1452 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1453 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1454 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1456 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1457 && TREE_CODE (newdecl
) != TYPE_DECL
)
1458 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1459 && TREE_CODE (olddecl
) != TYPE_DECL
))
1461 /* We do nothing special here, because C++ does such nasty
1462 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1463 get shadowed, and know that if we need to find a TYPE_DECL
1464 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1465 slot of the identifier. */
1469 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1470 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1471 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1472 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1476 error ("%q#D redeclared as different kind of symbol", newdecl
);
1477 if (TREE_CODE (olddecl
) == TREE_LIST
)
1478 olddecl
= TREE_VALUE (olddecl
);
1479 error ("previous declaration of %q+#D", olddecl
);
1481 return error_mark_node
;
1483 else if (!types_match
)
1485 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1486 /* These are certainly not duplicate declarations; they're
1487 from different scopes. */
1490 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1492 /* The name of a class template may not be declared to refer to
1493 any other template, class, function, object, namespace, value,
1494 or type in the same scope. */
1495 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1496 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1498 error ("declaration of template %q#D", newdecl
);
1499 error ("conflicts with previous declaration %q+#D", olddecl
);
1500 return error_mark_node
;
1502 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1503 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1504 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1505 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1506 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1507 DECL_TEMPLATE_PARMS (olddecl
))
1508 /* Template functions can be disambiguated by
1510 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1511 TREE_TYPE (TREE_TYPE (olddecl
))))
1513 error ("new declaration %q#D", newdecl
);
1514 error ("ambiguates old declaration %q+#D", olddecl
);
1518 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1520 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1522 error ("declaration of C function %q#D conflicts with",
1524 error ("previous declaration %q+#D here", olddecl
);
1527 /* For function versions, params and types match, but they
1528 are not ambiguous. */
1529 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1530 && !DECL_FUNCTION_VERSIONED (olddecl
))
1531 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1532 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1534 error ("new declaration %q#D", newdecl
);
1535 if (FNDECL_USED_AUTO (olddecl
))
1536 error_at (DECL_SOURCE_LOCATION (olddecl
), "ambiguates old "
1537 "declaration with deduced return type");
1539 error ("ambiguates old declaration %q+#D", olddecl
);
1540 return error_mark_node
;
1547 error ("conflicting declaration %q#D", newdecl
);
1548 error ("%q+D has a previous declaration as %q#D", olddecl
, olddecl
);
1549 return error_mark_node
;
1552 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1553 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1554 && (!DECL_TEMPLATE_INFO (newdecl
)
1555 || (DECL_TI_TEMPLATE (newdecl
)
1556 != DECL_TI_TEMPLATE (olddecl
))))
1557 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1558 && (!DECL_TEMPLATE_INFO (olddecl
)
1559 || (DECL_TI_TEMPLATE (olddecl
)
1560 != DECL_TI_TEMPLATE (newdecl
))))))
1561 /* It's OK to have a template specialization and a non-template
1562 with the same type, or to have specializations of two
1563 different templates with the same type. Note that if one is a
1564 specialization, and the other is an instantiation of the same
1565 template, that we do not exit at this point. That situation
1566 can occur if we instantiate a template class, and then
1567 specialize one of its methods. This situation is valid, but
1568 the declarations must be merged in the usual way. */
1570 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1571 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1572 && !DECL_USE_TEMPLATE (newdecl
))
1573 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1574 && !DECL_USE_TEMPLATE (olddecl
))))
1575 /* One of the declarations is a template instantiation, and the
1576 other is not a template at all. That's OK. */
1578 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1580 /* In [namespace.alias] we have:
1582 In a declarative region, a namespace-alias-definition can be
1583 used to redefine a namespace-alias declared in that declarative
1584 region to refer only to the namespace to which it already
1587 Therefore, if we encounter a second alias directive for the same
1588 alias, we can just ignore the second directive. */
1589 if (DECL_NAMESPACE_ALIAS (newdecl
)
1590 && (DECL_NAMESPACE_ALIAS (newdecl
)
1591 == DECL_NAMESPACE_ALIAS (olddecl
)))
1593 /* [namespace.alias]
1595 A namespace-name or namespace-alias shall not be declared as
1596 the name of any other entity in the same declarative region.
1597 A namespace-name defined at global scope shall not be
1598 declared as the name of any other entity in any global scope
1600 error ("declaration of namespace %qD conflicts with", newdecl
);
1601 error ("previous declaration of namespace %q+D here", olddecl
);
1602 return error_mark_node
;
1606 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1609 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1610 if (DECL_NAME (olddecl
) != NULL_TREE
)
1611 error ((DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1612 ? G_("%q+#D previously defined here")
1613 : G_("%q+#D previously declared here"), olddecl
);
1614 return error_mark_node
;
1616 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1617 && DECL_INITIAL (olddecl
) != NULL_TREE
1618 && !prototype_p (TREE_TYPE (olddecl
))
1619 && prototype_p (TREE_TYPE (newdecl
)))
1621 /* Prototype decl follows defn w/o prototype. */
1622 warning_at (input_location
, 0, "prototype for %q+#D", newdecl
);
1623 warning_at (DECL_SOURCE_LOCATION (olddecl
), 0,
1624 "follows non-prototype definition here");
1626 else if ((TREE_CODE (olddecl
) == FUNCTION_DECL
1627 || TREE_CODE (olddecl
) == VAR_DECL
)
1628 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1631 If two declarations of the same function or object
1632 specify different linkage-specifications ..., the program
1633 is ill-formed.... Except for functions with C++ linkage,
1634 a function declaration without a linkage specification
1635 shall not precede the first linkage specification for
1636 that function. A function can be declared without a
1637 linkage specification after an explicit linkage
1638 specification has been seen; the linkage explicitly
1639 specified in the earlier declaration is not affected by
1640 such a function declaration.
1642 DR 563 raises the question why the restrictions on
1643 functions should not also apply to objects. Older
1644 versions of G++ silently ignore the linkage-specification
1652 which is clearly wrong. Therefore, we now treat objects
1654 if (current_lang_depth () == 0)
1656 /* There is no explicit linkage-specification, so we use
1657 the linkage from the previous declaration. */
1658 if (!DECL_LANG_SPECIFIC (newdecl
))
1659 retrofit_lang_decl (newdecl
);
1660 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1664 error ("previous declaration of %q+#D with %qL linkage",
1665 olddecl
, DECL_LANGUAGE (olddecl
));
1666 error ("conflicts with new declaration with %qL linkage",
1667 DECL_LANGUAGE (newdecl
));
1671 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1673 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1675 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1676 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1679 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1680 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1682 for (; t1
&& t1
!= void_list_node
;
1683 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1684 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1686 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1689 permerror (input_location
, "default argument given for parameter %d of %q#D",
1691 permerror (input_location
, "after previous specification in %q+#D", olddecl
);
1695 error ("default argument given for parameter %d of %q#D",
1697 error ("after previous specification in %q+#D",
1704 /* Do not merge an implicit typedef with an explicit one. In:
1708 typedef class A A __attribute__ ((foo));
1710 the attribute should apply only to the typedef. */
1711 if (TREE_CODE (olddecl
) == TYPE_DECL
1712 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1713 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1716 /* If new decl is `static' and an `extern' was seen previously,
1718 warn_extern_redeclared_static (newdecl
, olddecl
);
1720 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1721 return error_mark_node
;
1723 /* We have committed to returning 1 at this point. */
1724 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1726 /* Now that functions must hold information normally held
1727 by field decls, there is extra work to do so that
1728 declaration information does not get destroyed during
1730 if (DECL_VINDEX (olddecl
))
1731 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1732 if (DECL_CONTEXT (olddecl
))
1733 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1734 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1735 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1736 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1737 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1738 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1739 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1740 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1741 SET_OVERLOADED_OPERATOR_CODE
1742 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1743 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1745 /* Optionally warn about more than one declaration for the same
1746 name, but don't warn about a function declaration followed by a
1748 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1749 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1750 /* Don't warn about extern decl followed by definition. */
1751 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1752 /* Don't warn about friends, let add_friend take care of it. */
1753 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1754 /* Don't warn about declaration followed by specialization. */
1755 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1756 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1758 warning (OPT_Wredundant_decls
, "redundant redeclaration of %qD in same scope", newdecl
);
1759 warning (OPT_Wredundant_decls
, "previous declaration of %q+D", olddecl
);
1762 if (DECL_DELETED_FN (newdecl
))
1764 error ("deleted definition of %qD", newdecl
);
1765 error ("after previous declaration %q+D", olddecl
);
1767 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1770 /* Deal with C++: must preserve virtual function table size. */
1771 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1773 tree newtype
= TREE_TYPE (newdecl
);
1774 tree oldtype
= TREE_TYPE (olddecl
);
1776 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1777 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1778 CLASSTYPE_FRIEND_CLASSES (newtype
)
1779 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1781 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1784 /* Copy all the DECL_... slots specified in the new decl
1785 except for any that we copy here from the old type. */
1786 DECL_ATTRIBUTES (newdecl
)
1787 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1789 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1793 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1794 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1795 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1796 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1797 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1798 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1800 DECL_ATTRIBUTES (old_result
)
1801 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1803 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1805 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1806 && DECL_INITIAL (new_result
))
1808 if (DECL_INITIAL (old_result
))
1809 DECL_UNINLINABLE (old_result
) = 1;
1811 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1812 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1813 DECL_NOT_REALLY_EXTERN (old_result
)
1814 = DECL_NOT_REALLY_EXTERN (new_result
);
1815 DECL_INTERFACE_KNOWN (old_result
)
1816 = DECL_INTERFACE_KNOWN (new_result
);
1817 DECL_DECLARED_INLINE_P (old_result
)
1818 = DECL_DECLARED_INLINE_P (new_result
);
1819 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1820 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1825 DECL_DECLARED_INLINE_P (old_result
)
1826 |= DECL_DECLARED_INLINE_P (new_result
);
1827 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1828 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1829 check_redeclaration_exception_specification (newdecl
, olddecl
);
1833 /* If the new declaration is a definition, update the file and
1834 line information on the declaration, and also make
1835 the old declaration the same definition. */
1836 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1838 DECL_SOURCE_LOCATION (olddecl
)
1839 = DECL_SOURCE_LOCATION (old_result
)
1840 = DECL_SOURCE_LOCATION (newdecl
);
1841 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1842 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1845 DECL_ARGUMENTS (old_result
)
1846 = DECL_ARGUMENTS (new_result
);
1847 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1848 parm
= DECL_CHAIN (parm
))
1849 DECL_CONTEXT (parm
) = old_result
;
1858 /* Automatically handles default parameters. */
1859 tree oldtype
= TREE_TYPE (olddecl
);
1862 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1863 maybe_instantiate_noexcept (olddecl
);
1865 /* Merge the data types specified in the two decls. */
1866 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1868 /* If merge_types produces a non-typedef type, just use the old type. */
1869 if (TREE_CODE (newdecl
) == TYPE_DECL
1870 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1873 if (TREE_CODE (newdecl
) == VAR_DECL
)
1875 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1876 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1877 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1878 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1879 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1880 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1882 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1883 if (DECL_LANG_SPECIFIC (olddecl
)
1884 && CP_DECL_THREADPRIVATE_P (olddecl
))
1886 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1887 if (!DECL_LANG_SPECIFIC (newdecl
))
1888 retrofit_lang_decl (newdecl
);
1890 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1891 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1895 /* Do this after calling `merge_types' so that default
1896 parameters don't confuse us. */
1897 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1898 check_redeclaration_exception_specification (newdecl
, olddecl
);
1899 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1901 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1902 check_default_args (newdecl
);
1904 /* Lay the type out, unless already done. */
1905 if (! same_type_p (newtype
, oldtype
)
1906 && TREE_TYPE (newdecl
) != error_mark_node
1907 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1908 layout_type (TREE_TYPE (newdecl
));
1910 if ((TREE_CODE (newdecl
) == VAR_DECL
1911 || TREE_CODE (newdecl
) == PARM_DECL
1912 || TREE_CODE (newdecl
) == RESULT_DECL
1913 || TREE_CODE (newdecl
) == FIELD_DECL
1914 || TREE_CODE (newdecl
) == TYPE_DECL
)
1915 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1916 layout_decl (newdecl
, 0);
1918 /* Merge the type qualifiers. */
1919 if (TREE_READONLY (newdecl
))
1920 TREE_READONLY (olddecl
) = 1;
1921 if (TREE_THIS_VOLATILE (newdecl
))
1922 TREE_THIS_VOLATILE (olddecl
) = 1;
1923 if (TREE_NOTHROW (newdecl
))
1924 TREE_NOTHROW (olddecl
) = 1;
1926 /* Merge deprecatedness. */
1927 if (TREE_DEPRECATED (newdecl
))
1928 TREE_DEPRECATED (olddecl
) = 1;
1930 /* Preserve function specific target and optimization options */
1931 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1933 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
1934 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
1935 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
1936 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
1938 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
1939 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
1940 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
1941 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
1944 /* Merge the initialization information. */
1945 if (DECL_INITIAL (newdecl
) == NULL_TREE
1946 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1948 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1949 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1950 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1952 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1953 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1957 /* Merge the section attribute.
1958 We want to issue an error if the sections conflict but that must be
1959 done later in decl_attributes since we are called before attributes
1961 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1962 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1964 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1966 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1967 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1968 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1969 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1970 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1971 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1972 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
1973 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
1974 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1975 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
1976 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
1977 /* Keep the old RTL. */
1978 COPY_DECL_RTL (olddecl
, newdecl
);
1980 else if (TREE_CODE (newdecl
) == VAR_DECL
1981 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
1983 /* Keep the old RTL. We cannot keep the old RTL if the old
1984 declaration was for an incomplete object and the new
1985 declaration is not since many attributes of the RTL will
1987 COPY_DECL_RTL (olddecl
, newdecl
);
1990 /* If cannot merge, then use the new type and qualifiers,
1991 and don't preserve the old rtl. */
1994 /* Clean out any memory we had of the old declaration. */
1995 tree oldstatic
= value_member (olddecl
, static_aggregates
);
1997 TREE_VALUE (oldstatic
) = error_mark_node
;
1999 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2000 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2001 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2002 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2005 /* Merge the storage class information. */
2006 merge_weak (newdecl
, olddecl
);
2008 if (DECL_ONE_ONLY (olddecl
))
2009 DECL_COMDAT_GROUP (newdecl
) = DECL_COMDAT_GROUP (olddecl
);
2011 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2012 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2013 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2014 if (! DECL_EXTERNAL (olddecl
))
2015 DECL_EXTERNAL (newdecl
) = 0;
2017 new_template_info
= NULL_TREE
;
2018 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2020 bool new_redefines_gnu_inline
= false;
2022 if (new_defines_function
2023 && ((DECL_INTERFACE_KNOWN (olddecl
)
2024 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2025 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2026 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2027 == FUNCTION_DECL
))))
2031 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2032 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2034 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2037 if (!new_redefines_gnu_inline
)
2039 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2040 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2041 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2043 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2044 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2045 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2047 /* If the OLDDECL is an instantiation and/or specialization,
2048 then the NEWDECL must be too. But, it may not yet be marked
2049 as such if the caller has created NEWDECL, but has not yet
2050 figured out that it is a redeclaration. */
2051 if (!DECL_USE_TEMPLATE (newdecl
))
2052 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2054 /* Don't really know how much of the language-specific
2055 values we should copy from old to new. */
2056 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2057 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2058 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2059 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2061 if (LANG_DECL_HAS_MIN (newdecl
))
2063 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2064 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2065 if (DECL_TEMPLATE_INFO (newdecl
))
2066 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2067 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2069 /* Only functions have these fields. */
2070 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2071 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
2073 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2074 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2075 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2076 && DECL_HIDDEN_FRIEND_P (olddecl
)
2077 && newdecl_is_friend
);
2078 DECL_BEFRIENDING_CLASSES (newdecl
)
2079 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2080 DECL_BEFRIENDING_CLASSES (olddecl
));
2081 /* DECL_THUNKS is only valid for virtual functions,
2082 otherwise it is a DECL_FRIEND_CONTEXT. */
2083 if (DECL_VIRTUAL_P (newdecl
))
2084 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2086 /* Only variables have this field. */
2087 else if (TREE_CODE (newdecl
) == VAR_DECL
2088 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2089 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2092 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2096 /* Merge parameter attributes. */
2097 tree oldarg
, newarg
;
2098 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2099 newarg
= DECL_ARGUMENTS(newdecl
);
2101 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2102 DECL_ATTRIBUTES (newarg
)
2103 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2104 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2107 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2108 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2110 /* If newdecl is not a specialization, then it is not a
2111 template-related function at all. And that means that we
2112 should have exited above, returning 0. */
2113 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2115 if (DECL_ODR_USED (olddecl
))
2116 /* From [temp.expl.spec]:
2118 If a template, a member template or the member of a class
2119 template is explicitly specialized then that
2120 specialization shall be declared before the first use of
2121 that specialization that would cause an implicit
2122 instantiation to take place, in every translation unit in
2123 which such a use occurs. */
2124 error ("explicit specialization of %qD after first use",
2127 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2129 /* Don't propagate visibility from the template to the
2130 specialization here. We'll do that in determine_visibility if
2132 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2134 /* [temp.expl.spec/14] We don't inline explicit specialization
2135 just because the primary template says so. */
2137 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2138 the always_inline attribute. */
2139 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2140 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2142 if (DECL_DECLARED_INLINE_P (newdecl
))
2143 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2145 DECL_ATTRIBUTES (newdecl
)
2146 = remove_attribute ("always_inline",
2147 DECL_ATTRIBUTES (newdecl
));
2150 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2152 /* Never inline re-defined extern inline functions.
2153 FIXME: this could be better handled by keeping both
2154 function as separate declarations. */
2155 DECL_UNINLINABLE (newdecl
) = 1;
2159 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2160 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2162 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2164 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2165 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2167 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2168 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2169 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2170 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2173 /* Preserve abstractness on cloned [cd]tors. */
2174 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
2176 /* Update newdecl's parms to point at olddecl. */
2177 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2178 parm
= DECL_CHAIN (parm
))
2179 DECL_CONTEXT (parm
) = olddecl
;
2183 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2184 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2185 COPY_DECL_RTL (newdecl
, olddecl
);
2187 if (! types_match
|| new_defines_function
)
2189 /* These need to be copied so that the names are available.
2190 Note that if the types do match, we'll preserve inline
2191 info and other bits, but if not, we won't. */
2192 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2193 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2195 /* If redeclaring a builtin function, it stays built in
2196 if newdecl is a gnu_inline definition, or if newdecl is just
2198 if (DECL_BUILT_IN (olddecl
)
2199 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2201 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2202 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2203 /* If we're keeping the built-in definition, keep the rtl,
2204 regardless of declaration matches. */
2205 COPY_DECL_RTL (olddecl
, newdecl
);
2206 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2208 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2211 /* If a compatible prototype of these builtin functions
2212 is seen, assume the runtime implements it with the
2213 expected semantics. */
2214 case BUILT_IN_STPCPY
:
2215 if (builtin_decl_explicit_p (fncode
))
2216 set_builtin_decl_implicit_p (fncode
, true);
2223 if (new_defines_function
)
2224 /* If defining a function declared with other language
2225 linkage, use the previously declared language linkage. */
2226 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2227 else if (types_match
)
2229 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2230 /* Don't clear out the arguments if we're just redeclaring a
2232 if (DECL_ARGUMENTS (olddecl
))
2233 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2236 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2237 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2239 /* Now preserve various other info from the definition. */
2240 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2241 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2242 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2243 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2245 /* Warn about conflicting visibility specifications. */
2246 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2247 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2248 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2250 warning_at (input_location
, OPT_Wattributes
,
2251 "%q+D: visibility attribute ignored because it", newdecl
);
2252 warning_at (DECL_SOURCE_LOCATION (olddecl
), OPT_Wattributes
,
2253 "conflicts with previous declaration here");
2255 /* Choose the declaration which specified visibility. */
2256 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2258 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2259 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2261 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2262 so keep this behavior. */
2263 if (TREE_CODE (newdecl
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (newdecl
))
2265 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2266 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2268 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2269 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2271 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2272 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2274 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2275 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2276 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2278 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2279 with that from NEWDECL below. */
2280 if (DECL_LANG_SPECIFIC (olddecl
))
2282 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2283 != DECL_LANG_SPECIFIC (newdecl
));
2284 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2287 /* Merge the USED information. */
2288 if (TREE_USED (olddecl
))
2289 TREE_USED (newdecl
) = 1;
2290 else if (TREE_USED (newdecl
))
2291 TREE_USED (olddecl
) = 1;
2292 if (TREE_CODE (newdecl
) == VAR_DECL
)
2294 if (DECL_READ_P (olddecl
))
2295 DECL_READ_P (newdecl
) = 1;
2296 else if (DECL_READ_P (newdecl
))
2297 DECL_READ_P (olddecl
) = 1;
2299 if (DECL_PRESERVE_P (olddecl
))
2300 DECL_PRESERVE_P (newdecl
) = 1;
2301 else if (DECL_PRESERVE_P (newdecl
))
2302 DECL_PRESERVE_P (olddecl
) = 1;
2304 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2305 to olddecl and deleted. */
2306 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2307 && DECL_FUNCTION_VERSIONED (olddecl
))
2309 /* Set the flag for newdecl so that it gets copied to olddecl. */
2310 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2311 /* newdecl will be purged after copying to olddecl and is no longer
2313 delete_function_version (newdecl
);
2316 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2320 function_size
= sizeof (struct tree_decl_common
);
2322 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2323 (char *) newdecl
+ sizeof (struct tree_common
),
2324 function_size
- sizeof (struct tree_common
));
2326 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2327 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2328 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2329 if (new_template_info
)
2330 /* If newdecl is a template instantiation, it is possible that
2331 the following sequence of events has occurred:
2333 o A friend function was declared in a class template. The
2334 class template was instantiated.
2336 o The instantiation of the friend declaration was
2337 recorded on the instantiation list, and is newdecl.
2339 o Later, however, instantiate_class_template called pushdecl
2340 on the newdecl to perform name injection. But, pushdecl in
2341 turn called duplicate_decls when it discovered that another
2342 declaration of a global function with the same name already
2345 o Here, in duplicate_decls, we decided to clobber newdecl.
2347 If we're going to do that, we'd better make sure that
2348 olddecl, and not newdecl, is on the list of
2349 instantiations so that if we try to do the instantiation
2350 again we won't get the clobbered declaration. */
2351 reregister_specialization (newdecl
,
2357 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2358 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2359 (char *) newdecl
+ sizeof (struct tree_common
),
2360 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2361 switch (TREE_CODE (olddecl
))
2371 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2372 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2373 size
- sizeof (struct tree_decl_common
)
2374 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2378 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2379 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2380 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2381 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2385 DECL_UID (olddecl
) = olddecl_uid
;
2387 DECL_FRIEND_P (olddecl
) = 1;
2390 DECL_ANTICIPATED (olddecl
) = 1;
2391 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2394 /* NEWDECL contains the merged attribute lists.
2395 Update OLDDECL to be the same. */
2396 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2398 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2399 so that encode_section_info has a chance to look at the new decl
2400 flags and attributes. */
2401 if (DECL_RTL_SET_P (olddecl
)
2402 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2403 || (TREE_CODE (olddecl
) == VAR_DECL
2404 && TREE_STATIC (olddecl
))))
2405 make_decl_rtl (olddecl
);
2407 /* The NEWDECL will no longer be needed. Because every out-of-class
2408 declaration of a member results in a call to duplicate_decls,
2409 freeing these nodes represents in a significant savings. */
2415 /* Return zero if the declaration NEWDECL is valid
2416 when the declaration OLDDECL (assumed to be for the same name)
2417 has already been seen.
2418 Otherwise return an error message format string with a %s
2419 where the identifier should go. */
2422 redeclaration_error_message (tree newdecl
, tree olddecl
)
2424 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2426 /* Because C++ can put things into name space for free,
2427 constructs like "typedef struct foo { ... } foo"
2428 would look like an erroneous redeclaration. */
2429 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2432 return G_("redefinition of %q#D");
2434 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2436 /* If this is a pure function, its olddecl will actually be
2437 the original initialization to `0' (which we force to call
2438 abort()). Don't complain about redefinition in this case. */
2439 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2440 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2443 /* If both functions come from different namespaces, this is not
2444 a redeclaration - this is a conflict with a used function. */
2445 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2446 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2447 && ! decls_match (olddecl
, newdecl
))
2448 return G_("%qD conflicts with used function");
2450 /* We'll complain about linkage mismatches in
2451 warn_extern_redeclared_static. */
2453 /* Defining the same name twice is no good. */
2454 if (DECL_INITIAL (olddecl
) != NULL_TREE
2455 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2457 if (DECL_NAME (olddecl
) == NULL_TREE
)
2458 return G_("%q#D not declared in class");
2459 else if (!GNU_INLINE_P (olddecl
)
2460 || GNU_INLINE_P (newdecl
))
2461 return G_("redefinition of %q#D");
2464 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2466 bool olda
= GNU_INLINE_P (olddecl
);
2467 bool newa
= GNU_INLINE_P (newdecl
);
2472 return G_("%q+D redeclared inline with "
2473 "%<gnu_inline%> attribute");
2475 return G_("%q+D redeclared inline without "
2476 "%<gnu_inline%> attribute");
2480 check_abi_tag_redeclaration
2481 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2482 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2486 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2490 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2492 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2493 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2494 return G_("redefinition of %q#D");
2498 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2499 || (DECL_TEMPLATE_RESULT (newdecl
)
2500 == DECL_TEMPLATE_RESULT (olddecl
)))
2503 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2504 if (DECL_TEMPLATE_INFO (nt
))
2505 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2506 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2507 if (DECL_TEMPLATE_INFO (ot
))
2508 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2509 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2510 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2511 return G_("redefinition of %q#D");
2513 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2515 bool olda
= GNU_INLINE_P (ot
);
2516 bool newa
= GNU_INLINE_P (nt
);
2521 return G_("%q+D redeclared inline with "
2522 "%<gnu_inline%> attribute");
2524 return G_("%q+D redeclared inline without "
2525 "%<gnu_inline%> attribute");
2529 /* Core issue #226 (C++0x):
2531 If a friend function template declaration specifies a
2532 default template-argument, that declaration shall be a
2533 definition and shall be the only declaration of the
2534 function template in the translation unit. */
2535 if ((cxx_dialect
!= cxx98
)
2536 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2537 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2538 /*is_primary=*/true,
2539 /*is_partial=*/false,
2540 /*is_friend_decl=*/2))
2541 return G_("redeclaration of friend %q#D "
2542 "may not have default template arguments");
2546 else if (TREE_CODE (newdecl
) == VAR_DECL
2547 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2548 && (! DECL_LANG_SPECIFIC (olddecl
)
2549 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2550 || DECL_THREAD_LOCAL_P (newdecl
)))
2552 /* Only variables can be thread-local, and all declarations must
2553 agree on this property. */
2554 if (DECL_THREAD_LOCAL_P (newdecl
))
2555 return G_("thread-local declaration of %q#D follows "
2556 "non-thread-local declaration");
2558 return G_("non-thread-local declaration of %q#D follows "
2559 "thread-local declaration");
2561 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2563 /* The objects have been declared at namespace scope. If either
2564 is a member of an anonymous union, then this is an invalid
2565 redeclaration. For example:
2571 if ((TREE_CODE (newdecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (newdecl
))
2572 || (TREE_CODE (olddecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (olddecl
)))
2573 return G_("redeclaration of %q#D");
2574 /* If at least one declaration is a reference, there is no
2575 conflict. For example:
2581 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2583 /* Reject two definitions. */
2584 return G_("redefinition of %q#D");
2588 /* Objects declared with block scope: */
2589 /* Reject two definitions, and reject a definition
2590 together with an external reference. */
2591 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2592 return G_("redeclaration of %q#D");
2597 /* Hash and equality functions for the named_label table. */
2600 named_label_entry_hash (const void *data
)
2602 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2603 return DECL_UID (ent
->label_decl
);
2607 named_label_entry_eq (const void *a
, const void *b
)
2609 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2610 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2611 return ent_a
->label_decl
== ent_b
->label_decl
;
2614 /* Create a new label, named ID. */
2617 make_label_decl (tree id
, int local_p
)
2619 struct named_label_entry
*ent
;
2623 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2625 DECL_CONTEXT (decl
) = current_function_decl
;
2626 DECL_MODE (decl
) = VOIDmode
;
2627 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2629 /* Say where one reference is to the label, for the sake of the
2630 error if it is not defined. */
2631 DECL_SOURCE_LOCATION (decl
) = input_location
;
2633 /* Record the fact that this identifier is bound to this label. */
2634 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2636 /* Create the label htab for the function on demand. */
2638 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2639 named_label_entry_eq
, NULL
);
2641 /* Record this label on the list of labels used in this function.
2642 We do this before calling make_label_decl so that we get the
2643 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2644 ent
= ggc_alloc_cleared_named_label_entry ();
2645 ent
->label_decl
= decl
;
2647 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2648 gcc_assert (*slot
== NULL
);
2654 /* Look for a label named ID in the current function. If one cannot
2655 be found, create one. (We keep track of used, but undefined,
2656 labels, and complain about them at the end of a function.) */
2659 lookup_label_1 (tree id
)
2663 /* You can't use labels at global scope. */
2664 if (current_function_decl
== NULL_TREE
)
2666 error ("label %qE referenced outside of any function", id
);
2670 /* See if we've already got this label. */
2671 decl
= IDENTIFIER_LABEL_VALUE (id
);
2672 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2675 decl
= make_label_decl (id
, /*local_p=*/0);
2679 /* Wrapper for lookup_label_1. */
2682 lookup_label (tree id
)
2685 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2686 ret
= lookup_label_1 (id
);
2687 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2691 /* Declare a local label named ID. */
2694 declare_local_label (tree id
)
2697 cp_label_binding bind
;
2699 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2700 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2701 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2703 decl
= make_label_decl (id
, /*local_p=*/1);
2705 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2710 /* Returns nonzero if it is ill-formed to jump past the declaration of
2711 DECL. Returns 2 if it's also a real problem. */
2714 decl_jump_unsafe (tree decl
)
2716 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2717 with automatic storage duration is not in scope to a point where it is
2718 in scope is ill-formed unless the variable has scalar type, class type
2719 with a trivial default constructor and a trivial destructor, a
2720 cv-qualified version of one of these types, or an array of one of the
2721 preceding types and is declared without an initializer (8.5). */
2722 tree type
= TREE_TYPE (decl
);
2724 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
)
2725 || type
== error_mark_node
)
2728 type
= strip_array_types (type
);
2730 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2733 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
2739 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2742 identify_goto (tree decl
, const location_t
*locus
)
2745 permerror (input_location
, "jump to label %qD", decl
);
2747 permerror (input_location
, "jump to case label");
2749 permerror (*locus
, " from here");
2752 /* Check that a single previously seen jump to a newly defined label
2753 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2754 the jump context; NAMES are the names in scope in LEVEL at the jump
2755 context; LOCUS is the source position of the jump or 0. Returns
2756 true if all is well. */
2759 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2760 bool exited_omp
, const location_t
*locus
)
2762 cp_binding_level
*b
;
2763 bool identified
= false, saw_eh
= false, saw_omp
= false;
2767 identify_goto (decl
, locus
);
2768 error (" exits OpenMP structured block");
2769 identified
= saw_omp
= true;
2772 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2774 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2776 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2777 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2778 : TREE_CHAIN (new_decls
)))
2780 int problem
= decl_jump_unsafe (new_decls
);
2786 identify_goto (decl
, locus
);
2790 error (" crosses initialization of %q+#D", new_decls
);
2792 permerror (input_location
, " enters scope of %q+#D which has "
2793 "non-trivial destructor", new_decls
);
2798 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2802 identify_goto (decl
, locus
);
2805 if (b
->kind
== sk_try
)
2806 error (" enters try block");
2808 error (" enters catch block");
2811 if (b
->kind
== sk_omp
&& !saw_omp
)
2815 identify_goto (decl
, locus
);
2818 error (" enters OpenMP structured block");
2827 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2829 check_previous_goto_1 (decl
, use
->binding_level
,
2830 use
->names_in_scope
, use
->in_omp_scope
,
2831 &use
->o_goto_locus
);
2835 check_switch_goto (cp_binding_level
* level
)
2837 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2840 /* Check that a new jump to a label DECL is OK. Called by
2841 finish_goto_stmt. */
2844 check_goto (tree decl
)
2846 struct named_label_entry
*ent
, dummy
;
2847 bool saw_catch
= false, identified
= false;
2851 /* We can't know where a computed goto is jumping.
2852 So we assume that it's OK. */
2853 if (TREE_CODE (decl
) != LABEL_DECL
)
2856 /* We didn't record any information about this label when we created it,
2857 and there's not much point since it's trivial to analyze as a return. */
2858 if (decl
== cdtor_label
)
2861 dummy
.label_decl
= decl
;
2862 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2863 gcc_assert (ent
!= NULL
);
2865 /* If the label hasn't been defined yet, defer checking. */
2866 if (! DECL_INITIAL (decl
))
2868 struct named_label_use_entry
*new_use
;
2870 /* Don't bother creating another use if the last goto had the
2871 same data, and will therefore create the same set of errors. */
2873 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2876 new_use
= ggc_alloc_named_label_use_entry ();
2877 new_use
->binding_level
= current_binding_level
;
2878 new_use
->names_in_scope
= current_binding_level
->names
;
2879 new_use
->o_goto_locus
= input_location
;
2880 new_use
->in_omp_scope
= false;
2882 new_use
->next
= ent
->uses
;
2883 ent
->uses
= new_use
;
2887 if (ent
->in_try_scope
|| ent
->in_catch_scope
2888 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
2890 permerror (input_location
, "jump to label %q+D", decl
);
2891 permerror (input_location
, " from here");
2895 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
2897 int u
= decl_jump_unsafe (bad
);
2899 if (u
> 1 && DECL_ARTIFICIAL (bad
))
2901 /* Can't skip init of __exception_info. */
2902 error_at (DECL_SOURCE_LOCATION (bad
), " enters catch block");
2906 error (" skips initialization of %q+#D", bad
);
2908 permerror (input_location
, " enters scope of %q+#D which has "
2909 "non-trivial destructor", bad
);
2912 if (ent
->in_try_scope
)
2913 error (" enters try block");
2914 else if (ent
->in_catch_scope
&& !saw_catch
)
2915 error (" enters catch block");
2917 if (ent
->in_omp_scope
)
2918 error (" enters OpenMP structured block");
2919 else if (flag_openmp
)
2921 cp_binding_level
*b
;
2922 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2924 if (b
== ent
->binding_level
)
2926 if (b
->kind
== sk_omp
)
2930 permerror (input_location
, "jump to label %q+D", decl
);
2931 permerror (input_location
, " from here");
2934 error (" exits OpenMP structured block");
2941 /* Check that a return is ok wrt OpenMP structured blocks.
2942 Called by finish_return_stmt. Returns true if all is well. */
2945 check_omp_return (void)
2947 cp_binding_level
*b
;
2948 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2949 if (b
->kind
== sk_omp
)
2951 error ("invalid exit from OpenMP structured block");
2954 else if (b
->kind
== sk_function_parms
)
2959 /* Define a label, specifying the location in the source file.
2960 Return the LABEL_DECL node for the label. */
2963 define_label_1 (location_t location
, tree name
)
2965 struct named_label_entry
*ent
, dummy
;
2966 cp_binding_level
*p
;
2969 decl
= lookup_label (name
);
2971 dummy
.label_decl
= decl
;
2972 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2973 gcc_assert (ent
!= NULL
);
2975 /* After labels, make any new cleanups in the function go into their
2976 own new (temporary) binding contour. */
2977 for (p
= current_binding_level
;
2978 p
->kind
!= sk_function_parms
;
2980 p
->more_cleanups_ok
= 0;
2982 if (name
== get_identifier ("wchar_t"))
2983 permerror (input_location
, "label named wchar_t");
2985 if (DECL_INITIAL (decl
) != NULL_TREE
)
2987 error ("duplicate label %qD", decl
);
2988 return error_mark_node
;
2992 struct named_label_use_entry
*use
;
2994 /* Mark label as having been defined. */
2995 DECL_INITIAL (decl
) = error_mark_node
;
2996 /* Say where in the source. */
2997 DECL_SOURCE_LOCATION (decl
) = location
;
2999 ent
->binding_level
= current_binding_level
;
3000 ent
->names_in_scope
= current_binding_level
->names
;
3002 for (use
= ent
->uses
; use
; use
= use
->next
)
3003 check_previous_goto (decl
, use
);
3010 /* Wrapper for define_label_1. */
3013 define_label (location_t location
, tree name
)
3016 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3017 ret
= define_label_1 (location
, name
);
3018 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3025 cp_binding_level
*level
;
3026 struct cp_switch
*next
;
3027 /* The SWITCH_STMT being built. */
3029 /* A splay-tree mapping the low element of a case range to the high
3030 element, or NULL_TREE if there is no high element. Used to
3031 determine whether or not a new case label duplicates an old case
3032 label. We need a tree, rather than simply a hash table, because
3033 of the GNU case range extension. */
3037 /* A stack of the currently active switch statements. The innermost
3038 switch statement is on the top of the stack. There is no need to
3039 mark the stack for garbage collection because it is only active
3040 during the processing of the body of a function, and we never
3041 collect at that point. */
3043 static struct cp_switch
*switch_stack
;
3045 /* Called right after a switch-statement condition is parsed.
3046 SWITCH_STMT is the switch statement being parsed. */
3049 push_switch (tree switch_stmt
)
3051 struct cp_switch
*p
= XNEW (struct cp_switch
);
3052 p
->level
= current_binding_level
;
3053 p
->next
= switch_stack
;
3054 p
->switch_stmt
= switch_stmt
;
3055 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3062 struct cp_switch
*cs
= switch_stack
;
3063 location_t switch_location
;
3065 /* Emit warnings as needed. */
3066 switch_location
= EXPR_LOC_OR_HERE (cs
->switch_stmt
);
3067 if (!processing_template_decl
)
3068 c_do_switch_warnings (cs
->cases
, switch_location
,
3069 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3070 SWITCH_STMT_COND (cs
->switch_stmt
));
3072 splay_tree_delete (cs
->cases
);
3073 switch_stack
= switch_stack
->next
;
3077 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3078 condition. Note that if TYPE and VALUE are already integral we don't
3079 really do the conversion because the language-independent
3080 warning/optimization code will work better that way. */
3083 case_conversion (tree type
, tree value
)
3085 if (value
== NULL_TREE
)
3088 if (cxx_dialect
>= cxx0x
3089 && (SCOPED_ENUM_P (type
)
3090 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3092 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3093 type
= type_promotes_to (type
);
3094 value
= perform_implicit_conversion (type
, value
, tf_warning_or_error
);
3096 return cxx_constant_value (value
);
3099 /* Note that we've seen a definition of a case label, and complain if this
3100 is a bad place for one. */
3103 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3106 cp_binding_level
*p
;
3109 if (processing_template_decl
)
3113 /* For templates, just add the case label; we'll do semantic
3114 analysis at instantiation-time. */
3115 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3116 return add_stmt (build_case_label (low_value
, high_value
, label
));
3119 /* Find the condition on which this switch statement depends. */
3120 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3121 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3122 cond
= TREE_VALUE (cond
);
3124 if (!check_switch_goto (switch_stack
->level
))
3125 return error_mark_node
;
3127 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3129 low_value
= case_conversion (type
, low_value
);
3130 high_value
= case_conversion (type
, high_value
);
3132 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3133 low_value
, high_value
);
3135 /* After labels, make any new cleanups in the function go into their
3136 own new (temporary) binding contour. */
3137 for (p
= current_binding_level
;
3138 p
->kind
!= sk_function_parms
;
3140 p
->more_cleanups_ok
= 0;
3145 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3148 typename_hash (const void* k
)
3151 const_tree
const t
= (const_tree
) k
;
3153 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3154 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
3159 typedef struct typename_info
{
3167 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3168 really of type `typename_info*' */
3171 typename_compare (const void * k1
, const void * k2
)
3173 const_tree
const t1
= (const_tree
) k1
;
3174 const typename_info
*const t2
= (const typename_info
*) k2
;
3176 return (DECL_NAME (TYPE_NAME (t1
)) == t2
->name
3177 && TYPE_CONTEXT (t1
) == t2
->scope
3178 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3179 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3180 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3183 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3184 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3186 Returns the new TYPENAME_TYPE. */
3188 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
3191 build_typename_type (tree context
, tree name
, tree fullname
,
3192 enum tag_types tag_type
)
3200 if (typename_htab
== NULL
)
3201 typename_htab
= htab_create_ggc (61, &typename_hash
,
3202 &typename_compare
, NULL
);
3204 ti
.scope
= FROB_CONTEXT (context
);
3206 ti
.template_id
= fullname
;
3207 ti
.enum_p
= tag_type
== enum_type
;
3208 ti
.class_p
= (tag_type
== class_type
3209 || tag_type
== record_type
3210 || tag_type
== union_type
);
3211 hash
= (htab_hash_pointer (ti
.scope
)
3212 ^ htab_hash_pointer (ti
.name
));
3214 /* See if we already have this type. */
3215 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
3220 /* Build the TYPENAME_TYPE. */
3221 t
= cxx_make_type (TYPENAME_TYPE
);
3222 TYPE_CONTEXT (t
) = ti
.scope
;
3223 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3224 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3225 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3227 /* Build the corresponding TYPE_DECL. */
3228 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3229 TYPE_NAME (TREE_TYPE (d
)) = d
;
3230 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3231 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3232 DECL_ARTIFICIAL (d
) = 1;
3234 /* Store it in the hash table. */
3237 /* TYPENAME_TYPEs must always be compared structurally, because
3238 they may or may not resolve down to another type depending on
3239 the currently open classes. */
3240 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3246 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3247 provided to name the type. Returns an appropriate type, unless an
3248 error occurs, in which case error_mark_node is returned. If we
3249 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3250 return that, rather than the _TYPE it corresponds to, in other
3251 cases we look through the type decl. If TF_ERROR is set, complain
3252 about errors, otherwise be quiet. */
3255 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3256 tsubst_flags_t complain
)
3262 if (name
== error_mark_node
3263 || context
== NULL_TREE
3264 || context
== error_mark_node
)
3265 return error_mark_node
;
3269 if (!(TYPE_LANG_SPECIFIC (name
)
3270 && (CLASSTYPE_IS_TEMPLATE (name
)
3271 || CLASSTYPE_USE_TEMPLATE (name
))))
3272 name
= TYPE_IDENTIFIER (name
);
3274 /* Create a TEMPLATE_ID_EXPR for the type. */
3275 name
= build_nt (TEMPLATE_ID_EXPR
,
3276 CLASSTYPE_TI_TEMPLATE (name
),
3277 CLASSTYPE_TI_ARGS (name
));
3279 else if (TREE_CODE (name
) == TYPE_DECL
)
3280 name
= DECL_NAME (name
);
3284 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3286 name
= TREE_OPERAND (name
, 0);
3287 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3288 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3289 else if (TREE_CODE (name
) == OVERLOAD
)
3291 if (complain
& tf_error
)
3292 error ("%qD is not a type", name
);
3293 return error_mark_node
;
3296 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3298 if (complain
& tf_error
)
3299 error ("%qD used without template parameters", name
);
3300 return error_mark_node
;
3302 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3303 gcc_assert (TYPE_P (context
));
3305 if (!MAYBE_CLASS_TYPE_P (context
))
3307 if (complain
& tf_error
)
3308 error ("%q#T is not a class", context
);
3309 return error_mark_node
;
3312 /* When the CONTEXT is a dependent type, NAME could refer to a
3313 dependent base class of CONTEXT. But look inside it anyway
3314 if CONTEXT is a currently open scope, in case it refers to a
3315 member of the current instantiation or a non-dependent base;
3316 lookup will stop when we hit a dependent base. */
3317 if (!dependent_scope_p (context
))
3318 /* We should only set WANT_TYPE when we're a nested typename type.
3319 Then we can give better diagnostics if we find a non-type. */
3320 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3324 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3325 return build_typename_type (context
, name
, fullname
, tag_type
);
3327 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3331 if (complain
& tf_error
)
3332 error (want_template
? G_("no class template named %q#T in %q#T")
3333 : G_("no type named %q#T in %q#T"), name
, context
);
3334 return error_mark_node
;
3337 /* Pull out the template from an injected-class-name (or multiple). */
3339 t
= maybe_get_template_decl_from_type_decl (t
);
3341 if (TREE_CODE (t
) == TREE_LIST
)
3343 if (complain
& tf_error
)
3345 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3346 print_candidates (t
);
3348 return error_mark_node
;
3351 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3353 if (complain
& tf_error
)
3354 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3356 return error_mark_node
;
3358 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3360 if (complain
& tf_error
)
3361 error ("%<typename %T::%D%> names %q#T, which is not a type",
3363 return error_mark_node
;
3366 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3367 return error_mark_node
;
3369 /* If we are currently parsing a template and if T is a typedef accessed
3370 through CONTEXT then we need to remember and check access of T at
3371 template instantiation time. */
3372 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3375 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3377 /*entering_scope=*/0,
3378 tf_warning_or_error
| tf_user
);
3380 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3383 maybe_record_typedef_use (t
);
3388 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3389 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3390 in which case error_mark_node is returned.
3392 If PARM_LIST is non-NULL, also make sure that the template parameter
3393 list of TEMPLATE_DECL matches.
3395 If COMPLAIN zero, don't complain about any errors that occur. */
3398 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3399 tsubst_flags_t complain
)
3405 name
= TYPE_IDENTIFIER (name
);
3406 else if (DECL_P (name
))
3407 name
= DECL_NAME (name
);
3408 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3410 if (!dependent_type_p (context
)
3411 || currently_open_class (context
))
3413 tree tmpl
= NULL_TREE
;
3415 if (MAYBE_CLASS_TYPE_P (context
))
3416 tmpl
= lookup_field (context
, name
, 0, false);
3418 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3419 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3421 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3423 if (complain
& tf_error
)
3424 error ("no class template named %q#T in %q#T", name
, context
);
3425 return error_mark_node
;
3429 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3431 if (complain
& tf_error
)
3433 error ("template parameters do not match template");
3434 error ("%q+D declared here", tmpl
);
3436 return error_mark_node
;
3439 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3441 return error_mark_node
;
3446 /* Build the UNBOUND_CLASS_TEMPLATE. */
3447 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3448 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3449 TREE_TYPE (t
) = NULL_TREE
;
3450 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3452 /* Build the corresponding TEMPLATE_DECL. */
3453 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3454 TYPE_NAME (TREE_TYPE (d
)) = d
;
3455 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3456 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3457 DECL_ARTIFICIAL (d
) = 1;
3458 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3465 /* Push the declarations of builtin types into the namespace.
3466 RID_INDEX is the index of the builtin type in the array
3467 RID_POINTERS. NAME is the name used when looking up the builtin
3468 type. TYPE is the _TYPE node for the builtin type. */
3471 record_builtin_type (enum rid rid_index
,
3475 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3476 tree tdecl
= NULL_TREE
;
3478 if ((int) rid_index
< (int) RID_MAX
)
3479 rname
= ridpointers
[(int) rid_index
];
3481 tname
= get_identifier (name
);
3483 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3484 eliminated. Built-in types should not be looked up name; their
3485 names are keywords that the parser can recognize. However, there
3486 is code in c-common.c that uses identifier_global_value to look
3487 up built-in types by name. */
3490 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3491 DECL_ARTIFICIAL (tdecl
) = 1;
3492 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3498 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3499 DECL_ARTIFICIAL (tdecl
) = 1;
3501 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3504 if (!TYPE_NAME (type
))
3505 TYPE_NAME (type
) = tdecl
;
3508 debug_hooks
->type_decl (tdecl
, 0);
3511 /* Record one of the standard Java types.
3512 * Declare it as having the given NAME.
3513 * If SIZE > 0, it is the size of one of the integral types;
3514 * otherwise it is the negative of the size of one of the other types. */
3517 record_builtin_java_type (const char* name
, int size
)
3522 type
= build_nonstandard_integer_type (size
, 0);
3523 type
= build_distinct_type_copy (type
);
3525 else if (size
> -32)
3528 /* "__java_char" or ""__java_boolean". */
3529 type
= build_nonstandard_integer_type (-size
, 1);
3530 type
= build_distinct_type_copy (type
);
3531 /* Get the signed type cached and attached to the unsigned type,
3532 so it doesn't get garbage-collected at "random" times,
3533 causing potential codegen differences out of different UIDs
3534 and different alias set numbers. */
3535 stype
= build_nonstandard_integer_type (-size
, 0);
3536 stype
= build_distinct_type_copy (stype
);
3537 TREE_CHAIN (type
) = stype
;
3538 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3541 { /* "__java_float" or ""__java_double". */
3542 type
= make_node (REAL_TYPE
);
3543 TYPE_PRECISION (type
) = - size
;
3546 record_builtin_type (RID_MAX
, name
, type
);
3547 decl
= TYPE_NAME (type
);
3549 /* Suppress generate debug symbol entries for these types,
3550 since for normal C++ they are just clutter.
3551 However, push_lang_context undoes this if extern "Java" is seen. */
3552 DECL_IGNORED_P (decl
) = 1;
3554 TYPE_FOR_JAVA (type
) = 1;
3558 /* Push a type into the namespace so that the back ends ignore it. */
3561 record_unknown_type (tree type
, const char* name
)
3563 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3564 TYPE_DECL
, get_identifier (name
), type
));
3565 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3566 DECL_IGNORED_P (decl
) = 1;
3567 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3568 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3569 TYPE_ALIGN (type
) = 1;
3570 TYPE_USER_ALIGN (type
) = 0;
3571 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3574 /* A string for which we should create an IDENTIFIER_NODE at
3577 typedef struct predefined_identifier
3579 /* The name of the identifier. */
3580 const char *const name
;
3581 /* The place where the IDENTIFIER_NODE should be stored. */
3583 /* Nonzero if this is the name of a constructor or destructor. */
3584 const int ctor_or_dtor_p
;
3585 } predefined_identifier
;
3587 /* Create all the predefined identifiers. */
3590 initialize_predefined_identifiers (void)
3592 const predefined_identifier
*pid
;
3594 /* A table of identifiers to create at startup. */
3595 static const predefined_identifier predefined_identifiers
[] = {
3596 { "C++", &lang_name_cplusplus
, 0 },
3597 { "C", &lang_name_c
, 0 },
3598 { "Java", &lang_name_java
, 0 },
3599 /* Some of these names have a trailing space so that it is
3600 impossible for them to conflict with names written by users. */
3601 { "__ct ", &ctor_identifier
, 1 },
3602 { "__base_ctor ", &base_ctor_identifier
, 1 },
3603 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3604 { "__dt ", &dtor_identifier
, 1 },
3605 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3606 { "__base_dtor ", &base_dtor_identifier
, 1 },
3607 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3608 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3609 { "nelts", &nelts_identifier
, 0 },
3610 { THIS_NAME
, &this_identifier
, 0 },
3611 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3612 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3613 { "_vptr", &vptr_identifier
, 0 },
3614 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3615 { "::", &global_scope_name
, 0 },
3616 { "std", &std_identifier
, 0 },
3620 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3622 *pid
->node
= get_identifier (pid
->name
);
3623 if (pid
->ctor_or_dtor_p
)
3624 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3628 /* Create the predefined scalar types of C,
3629 and some nodes representing standard constants (0, 1, (void *)0).
3630 Initialize the global binding level.
3631 Make definitions for built-in primitive functions. */
3634 cxx_init_decl_processing (void)
3637 tree void_ftype_ptr
;
3639 /* Create all the identifiers we need. */
3640 initialize_predefined_identifiers ();
3642 /* Create the global variables. */
3643 push_to_top_level ();
3645 current_function_decl
= NULL_TREE
;
3646 current_binding_level
= NULL
;
3647 /* Enter the global namespace. */
3648 gcc_assert (global_namespace
== NULL_TREE
);
3649 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3651 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3652 TREE_PUBLIC (global_namespace
) = 1;
3653 begin_scope (sk_namespace
, global_namespace
);
3655 if (flag_visibility_ms_compat
)
3656 default_visibility
= VISIBILITY_HIDDEN
;
3659 current_lang_name
= lang_name_c
;
3661 /* Create the `std' namespace. */
3662 push_namespace (std_identifier
);
3663 std_node
= current_namespace
;
3666 c_common_nodes_and_builtins ();
3668 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3669 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3670 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3671 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3672 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3673 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3674 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3675 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3677 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3679 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3680 truthvalue_type_node
= boolean_type_node
;
3681 truthvalue_false_node
= boolean_false_node
;
3682 truthvalue_true_node
= boolean_true_node
;
3684 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3685 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3686 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3689 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3692 delta_type_node
= ptrdiff_type_node
;
3693 vtable_index_type
= ptrdiff_type_node
;
3695 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3696 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3697 void_ftype_ptr
= build_function_type_list (void_type_node
,
3698 ptr_type_node
, NULL_TREE
);
3700 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3702 /* C++ extensions */
3704 unknown_type_node
= make_node (LANG_TYPE
);
3705 record_unknown_type (unknown_type_node
, "unknown type");
3707 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3708 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3710 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3712 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3713 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3715 init_list_type_node
= make_node (LANG_TYPE
);
3716 record_unknown_type (init_list_type_node
, "init list");
3719 /* Make sure we get a unique function type, so we can give
3720 its pointer type a name. (This wins for gdb.) */
3721 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3722 TREE_TYPE (vfunc_type
) = integer_type_node
;
3723 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3724 layout_type (vfunc_type
);
3726 vtable_entry_type
= build_pointer_type (vfunc_type
);
3728 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3731 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3732 layout_type (vtbl_type_node
);
3733 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3734 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3735 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3736 layout_type (vtbl_ptr_type_node
);
3737 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3739 push_namespace (get_identifier ("__cxxabiv1"));
3740 abi_node
= current_namespace
;
3743 global_type_node
= make_node (LANG_TYPE
);
3744 record_unknown_type (global_type_node
, "global type");
3747 current_lang_name
= lang_name_cplusplus
;
3750 tree newattrs
, extvisattr
;
3751 tree newtype
, deltype
;
3752 tree ptr_ftype_sizetype
;
3756 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3757 if (cxx_dialect
== cxx98
)
3760 tree bad_alloc_type_node
;
3761 tree bad_alloc_decl
;
3763 push_namespace (std_identifier
);
3764 bad_alloc_id
= get_identifier ("bad_alloc");
3765 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3766 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3768 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3769 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3773 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3776 new_eh_spec
= noexcept_false_spec
;
3778 /* Ensure attribs.c is initialized. */
3780 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3782 newattrs
= tree_cons (get_identifier ("alloc_size"),
3783 build_tree_list (NULL_TREE
, integer_one_node
),
3785 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3786 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3787 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3788 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3789 push_cp_library_fn (NEW_EXPR
, newtype
);
3790 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
3791 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
3792 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
3794 nullptr_type_node
= make_node (NULLPTR_TYPE
);
3795 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
3796 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
3797 TYPE_UNSIGNED (nullptr_type_node
) = 1;
3798 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
3799 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
3800 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
3801 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
3805 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
3807 /* Perform other language dependent initializations. */
3808 init_class_processing ();
3809 init_rtti_processing ();
3810 init_template_processing ();
3812 if (flag_exceptions
)
3813 init_exception_processing ();
3815 if (! supports_one_only ())
3818 make_fname_decl
= cp_make_fname_decl
;
3819 start_fname_decls ();
3821 /* Show we use EH for cleanups. */
3822 if (flag_exceptions
)
3823 using_eh_for_cleanups ();
3826 /* Generate an initializer for a function naming variable from
3827 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3828 filled in with the type of the init. */
3831 cp_fname_init (const char* name
, tree
*type_p
)
3833 tree domain
= NULL_TREE
;
3835 tree init
= NULL_TREE
;
3840 length
= strlen (name
);
3841 domain
= build_index_type (size_int (length
));
3842 init
= build_string (length
+ 1, name
);
3845 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3846 type
= build_cplus_array_type (type
, domain
);
3851 TREE_TYPE (init
) = type
;
3853 init
= error_mark_node
;
3858 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3859 the decl, LOC is the location to give the decl, NAME is the
3860 initialization string and TYPE_DEP indicates whether NAME depended
3861 on the type of the function. We make use of that to detect
3862 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3863 at the point of first use, so we mustn't push the decl now. */
3866 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3868 const char *const name
= (type_dep
&& processing_template_decl
3869 ? NULL
: fname_as_string (type_dep
));
3871 tree init
= cp_fname_init (name
, &type
);
3872 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3875 free (CONST_CAST (char *, name
));
3877 /* As we're using pushdecl_with_scope, we must set the context. */
3878 DECL_CONTEXT (decl
) = current_function_decl
;
3880 TREE_STATIC (decl
) = 1;
3881 TREE_READONLY (decl
) = 1;
3882 DECL_ARTIFICIAL (decl
) = 1;
3884 TREE_USED (decl
) = 1;
3886 if (current_function_decl
)
3888 cp_binding_level
*b
= current_binding_level
;
3889 if (b
->kind
== sk_function_parms
)
3890 return error_mark_node
;
3891 while (b
->level_chain
->kind
!= sk_function_parms
)
3893 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3894 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3895 LOOKUP_ONLYCONVERTING
);
3899 DECL_THIS_STATIC (decl
) = true;
3900 pushdecl_top_level_and_finish (decl
, init
);
3907 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3909 tree id
= DECL_NAME (decl
);
3910 const char *name
= IDENTIFIER_POINTER (id
);
3912 retrofit_lang_decl (decl
);
3914 DECL_ARTIFICIAL (decl
) = 1;
3915 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3916 SET_DECL_LANGUAGE (decl
, lang_c
);
3917 /* Runtime library routines are, by definition, available in an
3918 external shared object. */
3919 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3920 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3922 DECL_CONTEXT (decl
) = context
;
3925 pushdecl_top_level (decl
);
3929 /* A function in the user's namespace should have an explicit
3930 declaration before it is used. Mark the built-in function as
3931 anticipated but not actually declared. */
3932 if (name
[0] != '_' || name
[1] != '_')
3933 DECL_ANTICIPATED (decl
) = 1;
3934 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
3936 size_t len
= strlen (name
);
3938 /* Treat __*_chk fortification functions as anticipated as well,
3939 unless they are __builtin_*. */
3940 if (len
> strlen ("___chk")
3941 && memcmp (name
+ len
- strlen ("_chk"),
3942 "_chk", strlen ("_chk") + 1) == 0)
3943 DECL_ANTICIPATED (decl
) = 1;
3950 cxx_builtin_function (tree decl
)
3952 tree id
= DECL_NAME (decl
);
3953 const char *name
= IDENTIFIER_POINTER (id
);
3954 /* All builtins that don't begin with an '_' should additionally
3955 go in the 'std' namespace. */
3958 tree decl2
= copy_node(decl
);
3959 push_namespace (std_identifier
);
3960 builtin_function_1 (decl2
, std_node
, false);
3964 return builtin_function_1 (decl
, NULL_TREE
, false);
3967 /* Like cxx_builtin_function, but guarantee the function is added to the global
3968 scope. This is to allow function specific options to add new machine
3969 dependent builtins when the target ISA changes via attribute((target(...)))
3970 which saves space on program startup if the program does not use non-generic
3974 cxx_builtin_function_ext_scope (tree decl
)
3977 tree id
= DECL_NAME (decl
);
3978 const char *name
= IDENTIFIER_POINTER (id
);
3979 /* All builtins that don't begin with an '_' should additionally
3980 go in the 'std' namespace. */
3983 tree decl2
= copy_node(decl
);
3984 push_namespace (std_identifier
);
3985 builtin_function_1 (decl2
, std_node
, true);
3989 return builtin_function_1 (decl
, NULL_TREE
, true);
3992 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3993 function. Not called directly. */
3996 build_library_fn_1 (tree name
, enum tree_code operator_code
, tree type
)
3998 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
3999 DECL_EXTERNAL (fn
) = 1;
4000 TREE_PUBLIC (fn
) = 1;
4001 DECL_ARTIFICIAL (fn
) = 1;
4002 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4003 SET_DECL_LANGUAGE (fn
, lang_c
);
4004 /* Runtime library routines are, by definition, available in an
4005 external shared object. */
4006 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4007 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4011 /* Returns the _DECL for a library function with C linkage.
4012 We assume that such functions never throw; if this is incorrect,
4013 callers should unset TREE_NOTHROW. */
4016 build_library_fn (tree name
, tree type
)
4018 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
4019 TREE_NOTHROW (fn
) = 1;
4023 /* Returns the _DECL for a library function with C++ linkage. */
4026 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
)
4028 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
4029 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
4030 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4031 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4035 /* Like build_library_fn, but takes a C string instead of an
4039 build_library_fn_ptr (const char* name
, tree type
)
4041 return build_library_fn (get_identifier (name
), type
);
4044 /* Like build_cp_library_fn, but takes a C string instead of an
4048 build_cp_library_fn_ptr (const char* name
, tree type
)
4050 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
4053 /* Like build_library_fn, but also pushes the function so that we will
4054 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4055 may throw exceptions listed in RAISES. */
4058 push_library_fn (tree name
, tree type
, tree raises
)
4063 type
= build_exception_variant (type
, raises
);
4065 fn
= build_library_fn (name
, type
);
4066 pushdecl_top_level (fn
);
4070 /* Like build_cp_library_fn, but also pushes the function so that it
4071 will be found by normal lookup. */
4074 push_cp_library_fn (enum tree_code operator_code
, tree type
)
4076 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4081 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4085 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4089 push_void_library_fn (tree name
, tree parmtypes
)
4091 tree type
= build_function_type (void_type_node
, parmtypes
);
4092 return push_library_fn (name
, type
, NULL_TREE
);
4095 /* Like push_library_fn, but also note that this function throws
4096 and does not return. Used for __throw_foo and the like. */
4099 push_throw_library_fn (tree name
, tree type
)
4101 tree fn
= push_library_fn (name
, type
, NULL_TREE
);
4102 TREE_THIS_VOLATILE (fn
) = 1;
4103 TREE_NOTHROW (fn
) = 0;
4107 /* When we call finish_struct for an anonymous union, we create
4108 default copy constructors and such. But, an anonymous union
4109 shouldn't have such things; this function undoes the damage to the
4110 anonymous union type T.
4112 (The reason that we create the synthesized methods is that we don't
4113 distinguish `union { int i; }' from `typedef union { int i; } U'.
4114 The first is an anonymous union; the second is just an ordinary
4118 fixup_anonymous_aggr (tree t
)
4122 /* Wipe out memory of synthesized methods. */
4123 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4124 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4125 TYPE_HAS_COPY_CTOR (t
) = 0;
4126 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4127 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4128 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4130 /* Splice the implicitly generated functions out of the TYPE_METHODS
4132 q
= &TYPE_METHODS (t
);
4135 if (DECL_ARTIFICIAL (*q
))
4136 *q
= TREE_CHAIN (*q
);
4138 q
= &DECL_CHAIN (*q
);
4141 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4142 if (TYPE_METHODS (t
))
4144 tree decl
= TYPE_MAIN_DECL (t
);
4146 if (TREE_CODE (t
) != UNION_TYPE
)
4147 error_at (DECL_SOURCE_LOCATION (decl
),
4148 "an anonymous struct cannot have function members");
4150 error_at (DECL_SOURCE_LOCATION (decl
),
4151 "an anonymous union cannot have function members");
4154 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4155 assignment operators (because they cannot have these methods themselves).
4156 For anonymous unions this is already checked because they are not allowed
4157 in any union, otherwise we have to check it. */
4158 if (TREE_CODE (t
) != UNION_TYPE
)
4162 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4163 if (TREE_CODE (field
) == FIELD_DECL
)
4165 type
= TREE_TYPE (field
);
4166 if (CLASS_TYPE_P (type
))
4168 if (TYPE_NEEDS_CONSTRUCTING (type
))
4169 error ("member %q+#D with constructor not allowed "
4170 "in anonymous aggregate", field
);
4171 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4172 error ("member %q+#D with destructor not allowed "
4173 "in anonymous aggregate", field
);
4174 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4175 error ("member %q+#D with copy assignment operator "
4176 "not allowed in anonymous aggregate", field
);
4182 /* Warn for an attribute located at LOCATION that appertains to the
4183 class type CLASS_TYPE that has not been properly placed after its
4184 class-key, in it class-specifier. */
4187 warn_misplaced_attr_for_class_type (source_location location
,
4190 gcc_assert (TAGGED_TYPE_P (class_type
));
4192 warning_at (location
, OPT_Wattributes
,
4193 "attribute ignored in declaration "
4194 "of %q#T", class_type
);
4196 "attribute for %q#T must follow the %qs keyword",
4197 class_type
, class_key_or_enum_as_string (class_type
));
4200 /* Make sure that a declaration with no declarator is well-formed, i.e.
4201 just declares a tagged type or anonymous union.
4203 Returns the type declared; or NULL_TREE if none. */
4206 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4207 bool explicit_type_instantiation_p
)
4209 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4210 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4211 /* If a class, struct, or enum type is declared by the DECLSPECS
4212 (i.e, if a class-specifier, enum-specifier, or non-typename
4213 elaborated-type-specifier appears in the DECLSPECS),
4214 DECLARED_TYPE is set to the corresponding type. */
4215 tree declared_type
= NULL_TREE
;
4216 bool error_p
= false;
4218 if (declspecs
->multiple_types_p
)
4219 error ("multiple types in one declaration");
4220 else if (declspecs
->redefined_builtin_type
)
4222 if (!in_system_header
)
4223 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4224 "redeclaration of C++ built-in type %qT",
4225 declspecs
->redefined_builtin_type
);
4230 && TYPE_P (declspecs
->type
)
4231 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4232 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4233 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4234 declared_type
= declspecs
->type
;
4235 else if (declspecs
->type
== error_mark_node
)
4237 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4238 permerror (input_location
, "declaration does not declare anything");
4239 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4241 error ("%<auto%> can only be specified for variables "
4242 "or function declarations");
4243 return error_mark_node
;
4245 /* Check for an anonymous union. */
4246 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4247 && TYPE_ANONYMOUS_P (declared_type
))
4249 /* 7/3 In a simple-declaration, the optional init-declarator-list
4250 can be omitted only when declaring a class (clause 9) or
4251 enumeration (7.2), that is, when the decl-specifier-seq contains
4252 either a class-specifier, an elaborated-type-specifier with
4253 a class-key (9.1), or an enum-specifier. In these cases and
4254 whenever a class-specifier or enum-specifier is present in the
4255 decl-specifier-seq, the identifiers in these specifiers are among
4256 the names being declared by the declaration (as class-name,
4257 enum-names, or enumerators, depending on the syntax). In such
4258 cases, and except for the declaration of an unnamed bit-field (9.6),
4259 the decl-specifier-seq shall introduce one or more names into the
4260 program, or shall redeclare a name introduced by a previous
4261 declaration. [Example:
4262 enum { }; // ill-formed
4263 typedef class { }; // ill-formed
4267 error ("missing type-name in typedef-declaration");
4270 /* Anonymous unions are objects, so they can have specifiers. */;
4271 SET_ANON_AGGR_TYPE_P (declared_type
);
4273 if (TREE_CODE (declared_type
) != UNION_TYPE
&& !in_system_header
)
4274 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4279 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4280 || decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4281 error ("%qs can only be specified for functions",
4282 decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4283 ? "inline" : "virtual");
4285 && (!current_class_type
4286 || current_scope () != current_class_type
))
4287 error ("%<friend%> can only be specified inside a class");
4288 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4289 error ("%<explicit%> can only be specified for constructors");
4290 else if (declspecs
->storage_class
)
4291 error ("a storage class can only be specified for objects "
4293 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
)
4294 || decl_spec_seq_has_spec_p (declspecs
, ds_volatile
)
4295 || decl_spec_seq_has_spec_p (declspecs
, ds_restrict
)
4296 || decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4297 error ("qualifiers can only be specified for objects "
4299 else if (saw_typedef
)
4300 warning (0, "%<typedef%> was ignored in this declaration");
4301 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4302 error ("%<constexpr%> cannot be used for type declarations");
4305 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4308 if (!CLASS_TYPE_P (declared_type
)
4309 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4310 /* For a non-template class, use the name location. */
4311 loc
= location_of (declared_type
);
4313 /* For a template class (an explicit instantiation), use the
4314 current location. */
4315 loc
= input_location
;
4317 if (explicit_type_instantiation_p
)
4318 /* [dcl.attr.grammar]/4:
4320 No attribute-specifier-seq shall appertain to an explicit
4323 warning_at (loc
, OPT_Wattributes
,
4324 "attribute ignored in explicit instantiation %q#T",
4327 "no attribute can be applied to "
4328 "an explicit instantiation");
4331 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4334 return declared_type
;
4337 /* Called when a declaration is seen that contains no names to declare.
4338 If its type is a reference to a structure, union or enum inherited
4339 from a containing scope, shadow that tag name for the current scope
4340 with a forward reference.
4341 If its type defines a new named structure or union
4342 or defines an enum, it is valid but we need not do anything here.
4343 Otherwise, it is an error.
4345 C++: may have to grok the declspecs to learn about static,
4346 complain for anonymous unions.
4348 Returns the TYPE declared -- or NULL_TREE if none. */
4351 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4353 tree t
= check_tag_decl (declspecs
,
4354 /*explicit_type_instantiation_p=*/false);
4359 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4362 /* This is where the variables in an anonymous union are
4363 declared. An anonymous union declaration looks like:
4365 because there is no declarator after the union, the parser
4366 sends that declaration here. */
4367 if (ANON_AGGR_TYPE_P (t
))
4369 fixup_anonymous_aggr (t
);
4371 if (TYPE_FIELDS (t
))
4373 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4374 declspecs
, NORMAL
, 0, NULL
);
4375 finish_anon_union (decl
);
4382 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4385 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4386 const cp_declarator
*declarator
,
4387 bool is_template_arg
)
4391 enum decl_context context
4392 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4393 attrs
= type_specifiers
->attributes
;
4394 type_specifiers
->attributes
= NULL_TREE
;
4395 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4396 if (attrs
&& type
!= error_mark_node
)
4398 if (CLASS_TYPE_P (type
))
4399 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4400 "outside of definition", type
);
4401 else if (MAYBE_CLASS_TYPE_P (type
))
4402 /* A template type parameter or other dependent type. */
4403 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4404 "type %qT without an associated declaration", type
);
4406 cplus_decl_attributes (&type
, attrs
, 0);
4411 /* Process a DECLARATOR for a function-scope variable declaration,
4412 namespace-scope variable declaration, or function declaration.
4413 (Function definitions go through start_function; class member
4414 declarations appearing in the body of the class go through
4415 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4416 If an error occurs, the error_mark_node is returned instead.
4418 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4419 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4420 for an explicitly defaulted function, or SD_DELETED for an explicitly
4421 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4422 implicitly initialized via a default constructor. ATTRIBUTES and
4423 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4425 The scope represented by the context of the returned DECL is pushed
4426 (if it is not the global namespace) and is assigned to
4427 *PUSHED_SCOPE_P. The caller is then responsible for calling
4428 pop_scope on *PUSHED_SCOPE_P if it is set. */
4431 start_decl (const cp_declarator
*declarator
,
4432 cp_decl_specifier_seq
*declspecs
,
4435 tree prefix_attributes
,
4436 tree
*pushed_scope_p
)
4444 *pushed_scope_p
= NULL_TREE
;
4446 /* An object declared as __attribute__((deprecated)) suppresses
4447 warnings of uses of other deprecated items. */
4448 if (lookup_attribute ("deprecated", attributes
))
4449 deprecated_state
= DEPRECATED_SUPPRESS
;
4451 attributes
= chainon (attributes
, prefix_attributes
);
4453 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4456 deprecated_state
= DEPRECATED_NORMAL
;
4458 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
4459 || decl
== error_mark_node
)
4460 return error_mark_node
;
4462 context
= CP_DECL_CONTEXT (decl
);
4463 if (context
!= global_namespace
)
4464 *pushed_scope_p
= push_scope (context
);
4467 /* Is it valid for this decl to have an initializer at all?
4468 If not, set INITIALIZED to zero, which will indirectly
4469 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4470 switch (TREE_CODE (decl
))
4473 error ("typedef %qD is initialized (use decltype instead)", decl
);
4474 return error_mark_node
;
4477 if (initialized
== SD_DELETED
)
4478 /* We'll handle the rest of the semantics later, but we need to
4479 set this now so it's visible to duplicate_decls. */
4480 DECL_DELETED_FN (decl
) = 1;
4489 if (! toplevel_bindings_p ()
4490 && DECL_EXTERNAL (decl
))
4491 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4493 DECL_EXTERNAL (decl
) = 0;
4494 if (toplevel_bindings_p ())
4495 TREE_STATIC (decl
) = 1;
4497 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4499 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4500 record_key_method_defined (decl
);
4502 /* If this is a typedef that names the class for linkage purposes
4503 (7.1.3p8), apply any attributes directly to the type. */
4504 if (TREE_CODE (decl
) == TYPE_DECL
4505 && TAGGED_TYPE_P (TREE_TYPE (decl
))
4506 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4507 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4511 /* Set attributes here so if duplicate decl, will have proper attributes. */
4512 cplus_decl_attributes (&decl
, attributes
, flags
);
4514 /* Dllimported symbols cannot be defined. Static data members (which
4515 can be initialized in-class and dllimported) go through grokfield,
4516 not here, so we don't need to exclude those decls when checking for
4518 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4520 error ("definition of %q#D is marked %<dllimport%>", decl
);
4521 DECL_DLLIMPORT_P (decl
) = 0;
4524 /* If #pragma weak was used, mark the decl weak now. */
4525 if (!processing_template_decl
)
4526 maybe_apply_pragma_weak (decl
);
4528 if (TREE_CODE (decl
) == FUNCTION_DECL
4529 && DECL_DECLARED_INLINE_P (decl
)
4530 && DECL_UNINLINABLE (decl
)
4531 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4532 warning (0, "inline function %q+D given attribute noinline", decl
);
4534 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4536 if (TREE_CODE (decl
) == VAR_DECL
)
4538 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4539 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
4540 error ("%q#D is not a static member of %q#T", decl
, context
);
4543 if (DECL_CONTEXT (field
) != context
)
4545 if (!same_type_p (DECL_CONTEXT (field
), context
))
4546 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4547 "to be defined as %<%T::%D%>",
4548 DECL_CONTEXT (field
), DECL_NAME (decl
),
4549 context
, DECL_NAME (decl
));
4550 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4552 /* Static data member are tricky; an in-class initialization
4553 still doesn't provide a definition, so the in-class
4554 declaration will have DECL_EXTERNAL set, but will have an
4555 initialization. Thus, duplicate_decls won't warn
4556 about this situation, and so we check here. */
4557 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4558 error ("duplicate initialization of %qD", decl
);
4559 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4561 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4562 && !DECL_DECLARED_CONSTEXPR_P (field
))
4563 error ("%qD declared %<constexpr%> outside its class", field
);
4568 tree field
= check_classfn (context
, decl
,
4569 (processing_template_decl
4570 > template_class_depth (context
))
4571 ? current_template_parms
4573 if (field
&& field
!= error_mark_node
4574 && duplicate_decls (decl
, field
,
4575 /*newdecl_is_friend=*/false))
4579 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4580 DECL_IN_AGGR_P (decl
) = 0;
4581 /* Do not mark DECL as an explicit specialization if it was not
4582 already marked as an instantiation; a declaration should
4583 never be marked as a specialization unless we know what
4584 template is being specialized. */
4585 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4587 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4589 /* [temp.expl.spec] An explicit specialization of a static data
4590 member of a template is a definition if the declaration
4591 includes an initializer; otherwise, it is a declaration.
4593 We check for processing_specialization so this only applies
4594 to the new specialization syntax. */
4595 if (!initialized
&& processing_specialization
)
4596 DECL_EXTERNAL (decl
) = 1;
4599 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4600 /* Aliases are definitions. */
4602 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4606 was_public
= TREE_PUBLIC (decl
);
4608 /* Enter this declaration into the symbol table. */
4609 decl
= maybe_push_decl (decl
);
4611 if (processing_template_decl
)
4612 decl
= push_template_decl (decl
);
4613 if (decl
== error_mark_node
)
4614 return error_mark_node
;
4616 if (TREE_CODE (decl
) == VAR_DECL
4617 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4618 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4620 /* This is a const variable with implicit 'static'. Set
4621 DECL_THIS_STATIC so we can tell it from variables that are
4622 !TREE_PUBLIC because of the anonymous namespace. */
4623 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4624 DECL_THIS_STATIC (decl
) = 1;
4627 if (!processing_template_decl
&& TREE_CODE (decl
) == VAR_DECL
)
4628 start_decl_1 (decl
, initialized
);
4633 /* Process the declaration of a variable DECL. INITIALIZED is true
4634 iff DECL is explicitly initialized. (INITIALIZED is false if the
4635 variable is initialized via an implicitly-called constructor.)
4636 This function must be called for ordinary variables (including, for
4637 example, implicit instantiations of templates), but must not be
4638 called for template declarations. */
4641 start_decl_1 (tree decl
, bool initialized
)
4645 bool aggregate_definition_p
;
4647 gcc_assert (!processing_template_decl
);
4649 if (error_operand_p (decl
))
4652 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
4654 type
= TREE_TYPE (decl
);
4655 complete_p
= COMPLETE_TYPE_P (type
);
4656 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4658 /* If an explicit initializer is present, or if this is a definition
4659 of an aggregate, then we need a complete type at this point.
4660 (Scalars are always complete types, so there is nothing to
4661 check.) This code just sets COMPLETE_P; errors (if necessary)
4662 are issued below. */
4663 if ((initialized
|| aggregate_definition_p
)
4665 && COMPLETE_TYPE_P (complete_type (type
)))
4668 /* We will not yet have set TREE_READONLY on DECL if the type
4669 was "const", but incomplete, before this point. But, now, we
4670 have a complete type, so we can try again. */
4671 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4675 /* Is it valid for this decl to have an initializer at all? */
4677 /* Don't allow initializations for incomplete types except for
4678 arrays which might be completed by the initialization. */
4680 ; /* A complete type is ok. */
4681 else if (type_uses_auto (type
))
4682 ; /* An auto type is ok. */
4683 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4685 error ("variable %q#D has initializer but incomplete type", decl
);
4686 type
= TREE_TYPE (decl
) = error_mark_node
;
4688 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4690 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4691 error ("elements of array %q#D have incomplete type", decl
);
4692 /* else we already gave an error in start_decl. */
4695 else if (aggregate_definition_p
&& !complete_p
)
4697 if (type_uses_auto (type
))
4698 error ("declaration of %q#D has no initializer", decl
);
4700 error ("aggregate %q#D has incomplete type and cannot be defined",
4702 /* Change the type so that assemble_variable will give
4703 DECL an rtl we can live with: (mem (const_int 0)). */
4704 type
= TREE_TYPE (decl
) = error_mark_node
;
4707 /* Create a new scope to hold this declaration if necessary.
4708 Whether or not a new scope is necessary cannot be determined
4709 until after the type has been completed; if the type is a
4710 specialization of a class template it is not until after
4711 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4712 will be set correctly. */
4713 maybe_push_cleanup_level (type
);
4716 /* Handle initialization of references. DECL, TYPE, and INIT have the
4717 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4718 but will be set to a new CLEANUP_STMT if a temporary is created
4719 that must be destroyed subsequently.
4721 Returns an initializer expression to use to initialize DECL, or
4722 NULL if the initialization can be performed statically.
4724 Quotes on semantics can be found in ARM 8.4.3. */
4727 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4729 if (init
== NULL_TREE
)
4731 if ((DECL_LANG_SPECIFIC (decl
) == 0
4732 || DECL_IN_AGGR_P (decl
) == 0)
4733 && ! DECL_THIS_EXTERN (decl
))
4734 error ("%qD declared as reference but not initialized", decl
);
4738 if (TREE_CODE (init
) == TREE_LIST
)
4739 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4740 tf_warning_or_error
);
4742 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4743 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4744 /* Note: default conversion is only called in very special cases. */
4745 init
= decay_conversion (init
, tf_warning_or_error
);
4747 /* Convert INIT to the reference type TYPE. This may involve the
4748 creation of a temporary, whose lifetime must be the same as that
4749 of the reference. If so, a DECL_EXPR for the temporary will be
4750 added just after the DECL_EXPR for DECL. That's why we don't set
4751 DECL_INITIAL for local references (instead assigning to them
4752 explicitly); we need to allow the temporary to be initialized
4754 return initialize_reference (type
, init
, flags
,
4755 tf_warning_or_error
);
4758 /* Designated initializers in arrays are not supported in GNU C++.
4759 The parser cannot detect this error since it does not know whether
4760 a given brace-enclosed initializer is for a class type or for an
4761 array. This function checks that CE does not use a designated
4762 initializer. If it does, an error is issued. Returns true if CE
4763 is valid, i.e., does not have a designated initializer. */
4766 check_array_designated_initializer (const constructor_elt
*ce
,
4767 unsigned HOST_WIDE_INT index
)
4769 /* Designated initializers for array elements are not supported. */
4772 /* The parser only allows identifiers as designated
4774 if (ce
->index
== error_mark_node
)
4775 error ("name used in a GNU-style designated "
4776 "initializer for an array");
4777 else if (TREE_CODE (ce
->index
) == INTEGER_CST
)
4779 /* A C99 designator is OK if it matches the current index. */
4780 if (TREE_INT_CST_LOW (ce
->index
) == index
)
4783 sorry ("non-trivial designated initializers not supported");
4787 gcc_assert (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
4788 error ("name %qD used in a GNU-style designated "
4789 "initializer for an array", ce
->index
);
4797 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4798 array until we finish parsing the initializer. If that's the
4799 situation we're in, update DECL accordingly. */
4802 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4804 tree type
= TREE_TYPE (decl
);
4806 if (TREE_CODE (type
) == ARRAY_TYPE
4807 && TYPE_DOMAIN (type
) == NULL_TREE
4808 && TREE_CODE (decl
) != TYPE_DECL
)
4810 /* do_default is really a C-ism to deal with tentative definitions.
4811 But let's leave it here to ease the eventual merge. */
4812 int do_default
= !DECL_EXTERNAL (decl
);
4813 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4816 /* Check that there are no designated initializers in INIT, as
4817 those are not supported in GNU C++, and as the middle-end
4818 will crash if presented with a non-numeric designated
4820 if (initializer
&& TREE_CODE (initializer
) == CONSTRUCTOR
)
4822 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
4823 constructor_elt
*ce
;
4825 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
4826 if (!check_array_designated_initializer (ce
, i
))
4832 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4836 error ("initializer fails to determine size of %qD", decl
);
4837 TREE_TYPE (decl
) = error_mark_node
;
4839 else if (failure
== 2)
4843 error ("array size missing in %qD", decl
);
4844 TREE_TYPE (decl
) = error_mark_node
;
4846 /* If a `static' var's size isn't known, make it extern as
4847 well as static, so it does not get allocated. If it's not
4848 `static', then don't mark it extern; finish_incomplete_decl
4849 will give it a default size and it will get allocated. */
4850 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4851 DECL_EXTERNAL (decl
) = 1;
4853 else if (failure
== 3)
4855 error ("zero-size array %qD", decl
);
4856 TREE_TYPE (decl
) = error_mark_node
;
4860 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4862 relayout_decl (decl
);
4866 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4867 any appropriate error messages regarding the layout. */
4870 layout_var_decl (tree decl
)
4874 type
= TREE_TYPE (decl
);
4875 if (type
== error_mark_node
)
4878 /* If we haven't already layed out this declaration, do so now.
4879 Note that we must not call complete type for an external object
4880 because it's type might involve templates that we are not
4881 supposed to instantiate yet. (And it's perfectly valid to say
4882 `extern X x' for some incomplete type `X'.) */
4883 if (!DECL_EXTERNAL (decl
))
4884 complete_type (type
);
4885 if (!DECL_SIZE (decl
)
4886 && TREE_TYPE (decl
) != error_mark_node
4887 && (COMPLETE_TYPE_P (type
)
4888 || (TREE_CODE (type
) == ARRAY_TYPE
4889 && !TYPE_DOMAIN (type
)
4890 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4891 layout_decl (decl
, 0);
4893 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4895 /* An automatic variable with an incomplete type: that is an error.
4896 Don't talk about array types here, since we took care of that
4897 message in grokdeclarator. */
4898 error ("storage size of %qD isn%'t known", decl
);
4899 TREE_TYPE (decl
) = error_mark_node
;
4902 /* Keep this code around in case we later want to control debug info
4903 based on whether a type is "used". (jason 1999-11-11) */
4905 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4906 /* Let debugger know it should output info for this type. */
4907 note_debug_info_needed (ttype
);
4909 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4910 note_debug_info_needed (DECL_CONTEXT (decl
));
4913 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4914 && DECL_SIZE (decl
) != NULL_TREE
4915 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4917 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4918 constant_expression_warning (DECL_SIZE (decl
));
4921 error ("storage size of %qD isn%'t constant", decl
);
4922 TREE_TYPE (decl
) = error_mark_node
;
4927 /* If a local static variable is declared in an inline function, or if
4928 we have a weak definition, we must endeavor to create only one
4929 instance of the variable at link-time. */
4932 maybe_commonize_var (tree decl
)
4934 /* Static data in a function with comdat linkage also has comdat
4936 if (TREE_STATIC (decl
)
4937 /* Don't mess with __FUNCTION__. */
4938 && ! DECL_ARTIFICIAL (decl
)
4939 && DECL_FUNCTION_SCOPE_P (decl
)
4940 && vague_linkage_p (DECL_CONTEXT (decl
)))
4944 /* With weak symbols, we simply make the variable COMDAT;
4945 that will cause copies in multiple translations units to
4947 comdat_linkage (decl
);
4951 if (DECL_INITIAL (decl
) == NULL_TREE
4952 || DECL_INITIAL (decl
) == error_mark_node
)
4954 /* Without weak symbols, we can use COMMON to merge
4955 uninitialized variables. */
4956 TREE_PUBLIC (decl
) = 1;
4957 DECL_COMMON (decl
) = 1;
4961 /* While for initialized variables, we must use internal
4962 linkage -- which means that multiple copies will not
4964 TREE_PUBLIC (decl
) = 0;
4965 DECL_COMMON (decl
) = 0;
4966 warning_at (input_location
, 0,
4967 "sorry: semantics of inline function static "
4968 "data %q+#D are wrong (you%'ll wind up "
4969 "with multiple copies)", decl
);
4970 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4971 " you can work around this by removing "
4976 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4977 /* Set it up again; we might have set DECL_INITIAL since the last
4979 comdat_linkage (decl
);
4982 /* Issue an error message if DECL is an uninitialized const variable. */
4985 check_for_uninitialized_const_var (tree decl
)
4987 tree type
= strip_array_types (TREE_TYPE (decl
));
4989 /* ``Unless explicitly declared extern, a const object does not have
4990 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4992 if (TREE_CODE (decl
) == VAR_DECL
4993 && TREE_CODE (type
) != REFERENCE_TYPE
4994 && CP_TYPE_CONST_P (type
)
4995 && !DECL_INITIAL (decl
))
4997 tree field
= default_init_uninitialized_part (type
);
5001 permerror (DECL_SOURCE_LOCATION (decl
),
5002 "uninitialized const %qD", decl
);
5004 if (CLASS_TYPE_P (type
))
5006 tree defaulted_ctor
;
5008 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5009 "%q#T has no user-provided default constructor", type
);
5010 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5012 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5013 "constructor is not user-provided because it is "
5014 "explicitly defaulted in the class body");
5015 inform (0, "and the implicitly-defined constructor does not "
5016 "initialize %q+#D", field
);
5021 /* Structure holding the current initializer being processed by reshape_init.
5022 CUR is a pointer to the current element being processed, END is a pointer
5023 after the last element present in the initializer. */
5024 typedef struct reshape_iterator_t
5026 constructor_elt
*cur
;
5027 constructor_elt
*end
;
5030 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5032 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5033 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5034 initialized. If there are no more such fields, the return value
5038 next_initializable_field (tree field
)
5041 && (TREE_CODE (field
) != FIELD_DECL
5042 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5043 || DECL_ARTIFICIAL (field
)))
5044 field
= DECL_CHAIN (field
);
5049 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5050 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5051 INTEGER_CST representing the size of the array minus one (the maximum index),
5052 or NULL_TREE if the array was declared without specifying the size. D is
5053 the iterator within the constructor. */
5056 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5057 tsubst_flags_t complain
)
5060 bool sized_array_p
= (max_index
!= NULL_TREE
);
5061 unsigned HOST_WIDE_INT max_index_cst
= 0;
5062 unsigned HOST_WIDE_INT index
;
5064 /* The initializer for an array is always a CONSTRUCTOR. */
5065 new_init
= build_constructor (init_list_type_node
, NULL
);
5069 /* Minus 1 is used for zero sized arrays. */
5070 if (integer_all_onesp (max_index
))
5073 if (host_integerp (max_index
, 1))
5074 max_index_cst
= tree_low_cst (max_index
, 1);
5075 /* sizetype is sign extended, not zero extended. */
5077 max_index_cst
= tree_low_cst (fold_convert (size_type_node
, max_index
),
5081 /* Loop until there are no more initializers. */
5083 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5087 constructor_elt
*old_cur
= d
->cur
;
5089 check_array_designated_initializer (d
->cur
, index
);
5090 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5092 if (elt_init
== error_mark_node
)
5093 return error_mark_node
;
5094 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5095 size_int (index
), elt_init
);
5096 if (!TREE_CONSTANT (elt_init
))
5097 TREE_CONSTANT (new_init
) = false;
5099 /* This can happen with an invalid initializer (c++/54501). */
5100 if (d
->cur
== old_cur
&& !sized_array_p
)
5107 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5108 Parameters are the same of reshape_init_r. */
5111 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5113 tree max_index
= NULL_TREE
;
5115 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5117 if (TYPE_DOMAIN (type
))
5118 max_index
= array_type_nelts (type
);
5120 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5123 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5124 Parameters are the same of reshape_init_r. */
5127 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5129 tree max_index
= NULL_TREE
;
5131 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
5133 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5135 tree value
= d
->cur
->value
;
5136 if (!same_type_p (TREE_TYPE (value
), type
))
5138 if (complain
& tf_error
)
5139 error ("invalid type %qT as initializer for a vector of type %qT",
5140 TREE_TYPE (d
->cur
->value
), type
);
5141 value
= error_mark_node
;
5147 /* For a vector, we initialize it as an array of the appropriate size. */
5148 if (TREE_CODE (type
) == VECTOR_TYPE
)
5149 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5151 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5154 /* Subroutine of reshape_init_r, processes the initializers for classes
5155 or union. Parameters are the same of reshape_init_r. */
5158 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5159 tsubst_flags_t complain
)
5164 gcc_assert (CLASS_TYPE_P (type
));
5166 /* The initializer for a class is always a CONSTRUCTOR. */
5167 new_init
= build_constructor (init_list_type_node
, NULL
);
5168 field
= next_initializable_field (TYPE_FIELDS (type
));
5174 An initializer for an aggregate member that is an
5175 empty class shall have the form of an empty
5176 initializer-list {}. */
5177 if (!first_initializer_p
)
5179 if (complain
& tf_error
)
5180 error ("initializer for %qT must be brace-enclosed", type
);
5181 return error_mark_node
;
5186 /* Loop through the initializable fields, gathering initializers. */
5187 while (d
->cur
!= d
->end
)
5190 constructor_elt
*old_cur
= d
->cur
;
5192 /* Handle designated initializers, as an extension. */
5195 if (TREE_CODE (d
->cur
->index
) == INTEGER_CST
)
5197 if (complain
& tf_error
)
5198 error ("%<[%E] =%> used in a GNU-style designated initializer"
5199 " for class %qT", d
->cur
->index
, type
);
5200 return error_mark_node
;
5203 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5204 /* We already reshaped this. */
5205 gcc_assert (d
->cur
->index
== field
);
5207 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5209 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5211 if (complain
& tf_error
)
5212 error ("%qT has no non-static data member named %qD", type
,
5214 return error_mark_node
;
5218 /* If we processed all the member of the class, we are done. */
5222 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5223 /*first_initializer_p=*/false, complain
);
5224 if (field_init
== error_mark_node
)
5225 return error_mark_node
;
5227 if (d
->cur
== old_cur
&& d
->cur
->index
)
5229 /* This can happen with an invalid initializer for a flexible
5230 array member (c++/54441). */
5231 if (complain
& tf_error
)
5232 error ("invalid initializer for %q#D", field
);
5233 return error_mark_node
;
5236 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5240 When a union is initialized with a brace-enclosed
5241 initializer, the braces shall only contain an
5242 initializer for the first member of the union. */
5243 if (TREE_CODE (type
) == UNION_TYPE
)
5246 field
= next_initializable_field (DECL_CHAIN (field
));
5252 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5253 designators are not valid; either complain or return true to indicate
5254 that reshape_init_r should return error_mark_node. */
5257 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5261 if (complain
& tf_error
)
5262 error ("C99 designator %qE outside aggregate initializer",
5270 /* Subroutine of reshape_init, which processes a single initializer (part of
5271 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5272 iterator within the CONSTRUCTOR which points to the initializer to process.
5273 FIRST_INITIALIZER_P is true if this is the first initializer of the
5274 outermost CONSTRUCTOR node. */
5277 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5278 tsubst_flags_t complain
)
5280 tree init
= d
->cur
->value
;
5282 if (error_operand_p (init
))
5283 return error_mark_node
;
5285 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5286 && has_designator_problem (d
, complain
))
5287 return error_mark_node
;
5289 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5291 /* A complex type can be initialized from one or two initializers,
5292 but braces are not elided. */
5294 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5296 if (CONSTRUCTOR_NELTS (init
) > 2)
5298 if (complain
& tf_error
)
5299 error ("too many initializers for %qT", type
);
5301 return error_mark_node
;
5304 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5306 vec
<constructor_elt
, va_gc
> *v
= 0;
5307 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5308 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5309 if (has_designator_problem (d
, complain
))
5310 return error_mark_node
;
5312 init
= build_constructor (init_list_type_node
, v
);
5317 /* A non-aggregate type is always initialized with a single
5319 if (!CP_AGGREGATE_TYPE_P (type
))
5321 /* It is invalid to initialize a non-aggregate type with a
5322 brace-enclosed initializer before C++0x.
5323 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5324 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5325 a CONSTRUCTOR (with a record type). */
5326 if (TREE_CODE (init
) == CONSTRUCTOR
5327 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5329 if (SCALAR_TYPE_P (type
))
5331 if (complain
& tf_error
)
5332 error ("braces around scalar initializer for type %qT", type
);
5333 init
= error_mark_node
;
5336 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5345 All implicit type conversions (clause _conv_) are considered when
5346 initializing the aggregate member with an initializer from an
5347 initializer-list. If the initializer can initialize a member,
5348 the member is initialized. Otherwise, if the member is itself a
5349 non-empty subaggregate, brace elision is assumed and the
5350 initializer is considered for the initialization of the first
5351 member of the subaggregate. */
5352 if (TREE_CODE (init
) != CONSTRUCTOR
5353 /* But don't try this for the first initializer, since that would be
5354 looking through the outermost braces; A a2 = { a1 }; is not a
5355 valid aggregate initialization. */
5356 && !first_initializer_p
5357 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5358 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5365 /* [dcl.init.string]
5367 A char array (whether plain char, signed char, or unsigned char)
5368 can be initialized by a string-literal (optionally enclosed in
5369 braces); a wchar_t array can be initialized by a wide
5370 string-literal (optionally enclosed in braces). */
5371 if (TREE_CODE (type
) == ARRAY_TYPE
5372 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5374 tree str_init
= init
;
5376 /* Strip one level of braces if and only if they enclose a single
5377 element (as allowed by [dcl.init.string]). */
5378 if (!first_initializer_p
5379 && TREE_CODE (str_init
) == CONSTRUCTOR
5380 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5382 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5385 /* If it's a string literal, then it's the initializer for the array
5386 as a whole. Otherwise, continue with normal initialization for
5387 array types (one value per array element). */
5388 if (TREE_CODE (str_init
) == STRING_CST
)
5390 if (has_designator_problem (d
, complain
))
5391 return error_mark_node
;
5397 /* The following cases are about aggregates. If we are not within a full
5398 initializer already, and there is not a CONSTRUCTOR, it means that there
5399 is a missing set of braces (that is, we are processing the case for
5400 which reshape_init exists). */
5401 if (!first_initializer_p
)
5403 if (TREE_CODE (init
) == CONSTRUCTOR
)
5405 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5406 /* There is no need to reshape pointer-to-member function
5407 initializers, as they are always constructed correctly
5408 by the front end. */
5410 else if (COMPOUND_LITERAL_P (init
))
5411 /* For a nested compound literal, there is no need to reshape since
5412 brace elision is not allowed. Even if we decided to allow it,
5413 we should add a call to reshape_init in finish_compound_literal,
5414 before calling digest_init, so changing this code would still
5415 not be necessary. */
5416 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5420 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5421 return reshape_init (type
, init
, complain
);
5425 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5429 /* Dispatch to specialized routines. */
5430 if (CLASS_TYPE_P (type
))
5431 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5432 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5433 return reshape_init_array (type
, d
, complain
);
5434 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5435 return reshape_init_vector (type
, d
, complain
);
5440 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5441 brace-enclosed aggregate initializer.
5443 INIT is the CONSTRUCTOR containing the list of initializers describing
5444 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5445 It may not presently match the shape of the TYPE; for example:
5447 struct S { int a; int b; };
5448 struct S a[] = { 1, 2, 3, 4 };
5450 Here INIT will hold a vector of four elements, rather than a
5451 vector of two elements, each itself a vector of two elements. This
5452 routine transforms INIT from the former form into the latter. The
5453 revised CONSTRUCTOR node is returned. */
5456 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5458 vec
<constructor_elt
, va_gc
> *v
;
5462 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5464 v
= CONSTRUCTOR_ELTS (init
);
5466 /* An empty constructor does not need reshaping, and it is always a valid
5468 if (vec_safe_is_empty (v
))
5471 /* Recurse on this CONSTRUCTOR. */
5473 d
.end
= d
.cur
+ v
->length ();
5475 new_init
= reshape_init_r (type
, &d
, true, complain
);
5476 if (new_init
== error_mark_node
)
5477 return error_mark_node
;
5479 /* Make sure all the element of the constructor were used. Otherwise,
5480 issue an error about exceeding initializers. */
5483 if (complain
& tf_error
)
5484 error ("too many initializers for %qT", type
);
5486 return error_mark_node
;
5492 /* Verify array initializer. Returns true if errors have been reported. */
5495 check_array_initializer (tree decl
, tree type
, tree init
)
5497 tree element_type
= TREE_TYPE (type
);
5499 /* The array type itself need not be complete, because the
5500 initializer may tell us how many elements are in the array.
5501 But, the elements of the array must be complete. */
5502 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5505 error ("elements of array %q#D have incomplete type", decl
);
5507 error ("elements of array %q#T have incomplete type", type
);
5510 /* It is not valid to initialize a VLA. */
5512 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5513 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5516 error ("variable-sized object %qD may not be initialized", decl
);
5518 error ("variable-sized compound literal");
5524 /* Subroutine of check_initializer; args are passed down from that function.
5525 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5528 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5531 gcc_assert (stmts_are_full_exprs_p ());
5532 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5535 /* Verify INIT (the initializer for DECL), and record the
5536 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5537 grok_reference_init.
5539 If the return value is non-NULL, it is an expression that must be
5540 evaluated dynamically to initialize DECL. */
5543 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5545 tree type
= TREE_TYPE (decl
);
5546 tree init_code
= NULL
;
5547 tree extra_init
= NULL_TREE
;
5550 /* Things that are going to be initialized need to have complete
5552 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5554 if (DECL_HAS_VALUE_EXPR_P (decl
))
5556 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5557 it doesn't have storage to be initialized. */
5558 gcc_assert (init
== NULL_TREE
);
5562 if (type
== error_mark_node
)
5563 /* We will have already complained. */
5566 if (TREE_CODE (type
) == ARRAY_TYPE
)
5568 if (check_array_initializer (decl
, type
, init
))
5571 else if (!COMPLETE_TYPE_P (type
))
5573 error ("%q#D has incomplete type", decl
);
5574 TREE_TYPE (decl
) = error_mark_node
;
5578 /* There is no way to make a variable-sized class type in GNU C++. */
5579 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5581 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5583 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5584 if (SCALAR_TYPE_P (type
))
5588 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5589 init
= build_zero_init (type
, NULL_TREE
, false);
5591 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5593 error ("scalar object %qD requires one element in initializer",
5595 TREE_TYPE (decl
) = error_mark_node
;
5601 if (TREE_CODE (decl
) == CONST_DECL
)
5603 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5605 DECL_INITIAL (decl
) = init
;
5607 gcc_assert (init
!= NULL_TREE
);
5610 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5612 else if (init
|| type_build_ctor_call (type
)
5613 || TREE_CODE (type
) == REFERENCE_TYPE
)
5615 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5617 init
= grok_reference_init (decl
, type
, init
, flags
);
5618 flags
|= LOOKUP_ALREADY_DIGESTED
;
5621 check_for_uninitialized_const_var (decl
);
5622 /* Do not reshape constructors of vectors (they don't need to be
5624 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5626 if (is_std_init_list (type
))
5628 init
= perform_implicit_conversion (type
, init
,
5629 tf_warning_or_error
);
5630 flags
|= LOOKUP_ALREADY_DIGESTED
;
5632 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5634 /* Don't reshape if the class has constructors. */
5635 if (cxx_dialect
== cxx98
)
5636 error ("in C++98 %qD must be initialized by constructor, "
5640 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5642 error ("opaque vector types cannot be initialized");
5643 init
= error_mark_node
;
5647 init
= reshape_init (type
, init
, tf_warning_or_error
);
5648 if (SCALAR_TYPE_P (type
))
5649 check_narrowing (type
, init
);
5653 /* If DECL has an array type without a specific bound, deduce the
5654 array size from the initializer. */
5655 maybe_deduce_size_from_array_init (decl
, init
);
5656 type
= TREE_TYPE (decl
);
5657 if (type
== error_mark_node
)
5660 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5661 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5662 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5663 && CP_AGGREGATE_TYPE_P (type
)))
5665 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5667 /* A constructor call is a non-trivial initializer even if
5668 it isn't explicitly written. */
5669 if (TREE_SIDE_EFFECTS (init_code
))
5670 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5672 /* If this is a constexpr initializer, expand_default_init will
5673 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5674 case, pull the initializer back out and pass it down into
5675 store_init_value. */
5676 while (TREE_CODE (init_code
) == EXPR_STMT
5677 || TREE_CODE (init_code
) == CONVERT_EXPR
)
5678 init_code
= TREE_OPERAND (init_code
, 0);
5679 if (TREE_CODE (init_code
) == INIT_EXPR
)
5681 init
= TREE_OPERAND (init_code
, 1);
5682 init_code
= NULL_TREE
;
5683 /* Don't call digest_init; it's unnecessary and will complain
5684 about aggregate initialization of non-aggregate classes. */
5685 flags
|= LOOKUP_ALREADY_DIGESTED
;
5687 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
5689 /* Declared constexpr, but no suitable initializer; massage
5690 init appropriately so we can pass it into store_init_value
5692 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5693 init
= finish_compound_literal (type
, init
,
5694 tf_warning_or_error
);
5695 else if (CLASS_TYPE_P (type
)
5696 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
5698 init
= build_functional_cast (type
, init
, tf_none
);
5699 if (init
!= error_mark_node
)
5700 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
5702 init_code
= NULL_TREE
;
5708 if (init
&& TREE_CODE (init
) != TREE_VEC
)
5710 /* In aggregate initialization of a variable, each element
5711 initialization is a full-expression because there is no
5712 enclosing expression. */
5713 gcc_assert (stmts_are_full_exprs_p ());
5715 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
5717 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5718 && DECL_INITIAL (decl
)
5719 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5720 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5721 warning (0, "array %qD initialized by parenthesized string literal %qE",
5722 decl
, DECL_INITIAL (decl
));
5728 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
5729 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
5730 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
5731 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
5734 check_for_uninitialized_const_var (decl
);
5737 if (init
&& init
!= error_mark_node
)
5738 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5741 init_code
= add_stmt_to_compound (extra_init
, init_code
);
5743 if (init_code
&& DECL_IN_AGGR_P (decl
))
5745 static int explained
= 0;
5747 if (cxx_dialect
< cxx0x
)
5748 error ("initializer invalid for static member with constructor");
5750 error ("non-constant in-class initialization invalid for static "
5751 "member %qD", decl
);
5754 error ("(an out of class initialization is required)");
5762 /* If DECL is not a local variable, give it RTL. */
5765 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5767 int toplev
= toplevel_bindings_p ();
5769 const char *filename
;
5771 /* Set the DECL_ASSEMBLER_NAME for the object. */
5774 /* The `register' keyword, when used together with an
5775 asm-specification, indicates that the variable should be
5776 placed in a particular register. */
5777 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
5779 set_user_assembler_name (decl
, asmspec
);
5780 DECL_HARD_REGISTER (decl
) = 1;
5784 if (TREE_CODE (decl
) == FUNCTION_DECL
5785 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5786 set_builtin_user_assembler_name (decl
, asmspec
);
5787 set_user_assembler_name (decl
, asmspec
);
5791 /* Handle non-variables up front. */
5792 if (TREE_CODE (decl
) != VAR_DECL
)
5794 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5798 /* If we see a class member here, it should be a static data
5800 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5802 gcc_assert (TREE_STATIC (decl
));
5803 /* An in-class declaration of a static data member should be
5804 external; it is only a declaration, and not a definition. */
5805 if (init
== NULL_TREE
)
5806 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5809 /* We don't create any RTL for local variables. */
5810 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5813 /* We defer emission of local statics until the corresponding
5814 DECL_EXPR is expanded. */
5815 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5817 /* We try to defer namespace-scope static constants so that they are
5818 not emitted into the object file unnecessarily. */
5819 filename
= input_filename
;
5820 if (!DECL_VIRTUAL_P (decl
)
5821 && TREE_READONLY (decl
)
5822 && DECL_INITIAL (decl
) != NULL_TREE
5823 && DECL_INITIAL (decl
) != error_mark_node
5825 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5827 && !TREE_PUBLIC (decl
))
5829 /* Fool with the linkage of static consts according to #pragma
5831 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5832 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5834 TREE_PUBLIC (decl
) = 1;
5835 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5840 /* Likewise for template instantiations. */
5841 else if (DECL_LANG_SPECIFIC (decl
)
5842 && DECL_IMPLICIT_INSTANTIATION (decl
))
5845 /* If we're not deferring, go ahead and assemble the variable. */
5847 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5850 /* walk_tree helper for wrap_temporary_cleanups, below. */
5853 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5855 /* Stop at types or full-expression boundaries. */
5856 if (TYPE_P (*stmt_p
)
5857 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
5863 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5865 tree guard
= (tree
)data
;
5866 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5868 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5869 /* Tell honor_protect_cleanup_actions to handle this as a separate
5871 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5873 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5879 /* We're initializing a local variable which has a cleanup GUARD. If there
5880 are any temporaries used in the initializer INIT of this variable, we
5881 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5882 variable will be cleaned up properly if one of them throws.
5884 Unfortunately, there's no way to express this properly in terms of
5885 nesting, as the regions for the temporaries overlap the region for the
5886 variable itself; if there are two temporaries, the variable needs to be
5887 the first thing destroyed if either of them throws. However, we only
5888 want to run the variable's cleanup if it actually got constructed. So
5889 we need to guard the temporary cleanups with the variable's cleanup if
5890 they are run on the normal path, but not if they are run on the
5891 exceptional path. We implement this by telling
5892 honor_protect_cleanup_actions to strip the variable cleanup from the
5893 exceptional path. */
5896 wrap_temporary_cleanups (tree init
, tree guard
)
5898 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5901 /* Generate code to initialize DECL (a local variable). */
5904 initialize_local_var (tree decl
, tree init
)
5906 tree type
= TREE_TYPE (decl
);
5910 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5911 || TREE_CODE (decl
) == RESULT_DECL
);
5912 gcc_assert (!TREE_STATIC (decl
));
5914 if (DECL_SIZE (decl
) == NULL_TREE
)
5916 /* If we used it already as memory, it must stay in memory. */
5917 DECL_INITIAL (decl
) = NULL_TREE
;
5918 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5922 if (type
== error_mark_node
)
5925 /* Compute and store the initial value. */
5926 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5927 if (TREE_USED (type
))
5928 DECL_READ_P (decl
) = 1;
5930 /* Generate a cleanup, if necessary. */
5931 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
5933 /* Perform the initialization. */
5936 if (TREE_CODE (init
) == INIT_EXPR
5937 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init
, 1)))
5939 /* Stick simple initializers in DECL_INITIAL so that
5940 -Wno-init-self works (c++/34772). */
5941 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
5942 DECL_INITIAL (decl
) = TREE_OPERAND (init
, 1);
5946 int saved_stmts_are_full_exprs_p
;
5948 /* If we're only initializing a single object, guard the
5949 destructors of any temporaries used in its initializer with
5950 its destructor. This isn't right for arrays because each
5951 element initialization is a full-expression. */
5952 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
5953 wrap_temporary_cleanups (init
, cleanup
);
5955 gcc_assert (building_stmt_list_p ());
5956 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5957 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5958 finish_expr_stmt (init
);
5959 current_stmt_tree ()->stmts_are_full_exprs_p
=
5960 saved_stmts_are_full_exprs_p
;
5964 /* Set this to 0 so we can tell whether an aggregate which was
5965 initialized was ever used. Don't do this if it has a
5966 destructor, so we don't complain about the 'resource
5967 allocation is initialization' idiom. Now set
5968 attribute((unused)) on types so decls of that type will be
5969 marked used. (see TREE_USED, above.) */
5970 if (TYPE_NEEDS_CONSTRUCTING (type
)
5972 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
5973 && DECL_NAME (decl
))
5974 TREE_USED (decl
) = 0;
5975 else if (already_used
)
5976 TREE_USED (decl
) = 1;
5979 finish_decl_cleanup (decl
, cleanup
);
5982 /* DECL is a VAR_DECL for a compiler-generated variable with static
5983 storage duration (like a virtual table) whose initializer is a
5984 compile-time constant. Initialize the variable and provide it to the
5988 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
5991 gcc_assert (DECL_ARTIFICIAL (decl
));
5992 init
= build_constructor (TREE_TYPE (decl
), v
);
5993 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
5994 DECL_INITIAL (decl
) = init
;
5995 DECL_INITIALIZED_P (decl
) = 1;
5996 determine_visibility (decl
);
5997 layout_var_decl (decl
);
5998 maybe_commonize_var (decl
);
5999 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6002 /* INIT is the initializer for a variable, as represented by the
6003 parser. Returns true iff INIT is type-dependent. */
6006 type_dependent_init_p (tree init
)
6008 if (TREE_CODE (init
) == TREE_LIST
)
6009 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6010 return any_type_dependent_elements_p (init
);
6011 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6012 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6014 vec
<constructor_elt
, va_gc
> *elts
;
6018 elts
= CONSTRUCTOR_ELTS (init
);
6019 nelts
= vec_safe_length (elts
);
6020 for (i
= 0; i
< nelts
; ++i
)
6021 if (type_dependent_init_p ((*elts
)[i
].value
))
6025 /* It must be a simple expression, e.g., int i = 3; */
6026 return type_dependent_expression_p (init
);
6031 /* INIT is the initializer for a variable, as represented by the
6032 parser. Returns true iff INIT is value-dependent. */
6035 value_dependent_init_p (tree init
)
6037 if (TREE_CODE (init
) == TREE_LIST
)
6038 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6039 return any_value_dependent_elements_p (init
);
6040 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6041 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6043 vec
<constructor_elt
, va_gc
> *elts
;
6047 elts
= CONSTRUCTOR_ELTS (init
);
6048 nelts
= vec_safe_length (elts
);
6049 for (i
= 0; i
< nelts
; ++i
)
6050 if (value_dependent_init_p ((*elts
)[i
].value
))
6054 /* It must be a simple expression, e.g., int i = 3; */
6055 return value_dependent_expression_p (init
);
6060 /* Finish processing of a declaration;
6061 install its line number and initial value.
6062 If the length of an array type is not known before,
6063 it must be determined now, from the initial value, or it is an error.
6065 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6066 true, then INIT is an integral constant expression.
6068 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6069 if the (init) syntax was used. */
6072 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6073 tree asmspec_tree
, int flags
)
6076 vec
<tree
, va_gc
> *cleanups
= NULL
;
6077 const char *asmspec
= NULL
;
6078 int was_readonly
= 0;
6079 bool var_definition_p
= false;
6082 if (decl
== error_mark_node
)
6087 error ("assignment (not initialization) in declaration");
6091 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6092 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6093 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6095 type
= TREE_TYPE (decl
);
6096 if (type
== error_mark_node
)
6099 /* If a name was specified, get the string. */
6100 if (at_namespace_scope_p ())
6101 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6102 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6103 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6105 if (current_class_type
6106 && CP_DECL_CONTEXT (decl
) == current_class_type
6107 && TYPE_BEING_DEFINED (current_class_type
)
6108 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6109 && (DECL_INITIAL (decl
) || init
))
6110 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6112 if (TREE_CODE (decl
) != FUNCTION_DECL
6113 && (auto_node
= type_uses_auto (type
)))
6116 if (init
== NULL_TREE
)
6118 error ("declaration of %q#D has no initializer", decl
);
6119 TREE_TYPE (decl
) = error_mark_node
;
6123 if (TREE_CODE (d_init
) == TREE_LIST
)
6124 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6125 tf_warning_or_error
);
6126 d_init
= resolve_nondeduced_context (d_init
);
6127 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6129 if (type
== error_mark_node
)
6133 if (!ensure_literal_type_for_constexpr_object (decl
))
6134 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6136 if (TREE_CODE (decl
) == VAR_DECL
6137 && DECL_CLASS_SCOPE_P (decl
)
6138 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6139 check_static_variable_definition (decl
, type
);
6141 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6144 if (init
== ridpointers
[(int)RID_DELETE
])
6146 /* FIXME check this is 1st decl. */
6147 DECL_DELETED_FN (decl
) = 1;
6148 DECL_DECLARED_INLINE_P (decl
) = 1;
6149 DECL_INITIAL (decl
) = error_mark_node
;
6150 FOR_EACH_CLONE (clone
, decl
)
6152 DECL_DELETED_FN (clone
) = 1;
6153 DECL_DECLARED_INLINE_P (clone
) = 1;
6154 DECL_INITIAL (clone
) = error_mark_node
;
6158 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6160 if (defaultable_fn_check (decl
))
6161 DECL_DEFAULTED_FN (decl
) = 1;
6163 DECL_INITIAL (decl
) = NULL_TREE
;
6167 if (init
&& TREE_CODE (decl
) == VAR_DECL
)
6169 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6170 /* If DECL is a reference, then we want to know whether init is a
6171 reference constant; init_const_expr_p as passed tells us whether
6172 it's an rvalue constant. */
6173 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6174 init_const_expr_p
= potential_constant_expression (init
);
6175 if (init_const_expr_p
)
6177 /* Set these flags now for templates. We'll update the flags in
6178 store_init_value for instantiations. */
6179 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6180 if (decl_maybe_constant_var_p (decl
))
6181 TREE_CONSTANT (decl
) = 1;
6185 if (processing_template_decl
)
6187 bool type_dependent_p
;
6189 /* Add this declaration to the statement-tree. */
6190 if (at_function_scope_p ())
6191 add_decl_expr (decl
);
6193 type_dependent_p
= dependent_type_p (type
);
6195 if (check_for_bare_parameter_packs (init
))
6198 DECL_INITIAL (decl
) = NULL_TREE
;
6201 /* Generally, initializers in templates are expanded when the
6202 template is instantiated. But, if DECL is a variable constant
6203 then it can be used in future constant expressions, so its value
6204 must be available. */
6206 if (TREE_CODE (decl
) != VAR_DECL
|| dependent_type_p (type
))
6207 /* We can't do anything if the decl has dependent type. */;
6209 && init_const_expr_p
6210 && !type_dependent_p
6211 && decl_maybe_constant_var_p (decl
)
6212 && !type_dependent_init_p (init
)
6213 && !value_dependent_init_p (init
))
6215 /* This variable seems to be a non-dependent constant, so process
6216 its initializer. If check_initializer returns non-null the
6217 initialization wasn't constant after all. */
6219 cleanups
= make_tree_vector ();
6220 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6221 if (init_code
== NULL_TREE
)
6223 release_tree_vector (cleanups
);
6225 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6227 /* Deduce array size even if the initializer is dependent. */
6228 maybe_deduce_size_from_array_init (decl
, init
);
6229 /* And complain about multiple initializers. */
6230 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6231 && !MAYBE_CLASS_TYPE_P (type
))
6232 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6233 tf_warning_or_error
);
6237 DECL_INITIAL (decl
) = init
;
6241 /* Just store non-static data member initializers for later. */
6242 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6243 DECL_INITIAL (decl
) = init
;
6245 /* Take care of TYPE_DECLs up front. */
6246 if (TREE_CODE (decl
) == TYPE_DECL
)
6248 if (type
!= error_mark_node
6249 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6251 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6252 warning (0, "shadowing previous type declaration of %q#D", decl
);
6253 set_identifier_type_value (DECL_NAME (decl
), decl
);
6256 /* If we have installed this as the canonical typedef for this
6257 type, and that type has not been defined yet, delay emitting
6258 the debug information for it, as we will emit it later. */
6259 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6260 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6261 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6263 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6268 /* A reference will be modified here, as it is initialized. */
6269 if (! DECL_EXTERNAL (decl
)
6270 && TREE_READONLY (decl
)
6271 && TREE_CODE (type
) == REFERENCE_TYPE
)
6274 TREE_READONLY (decl
) = 0;
6277 if (TREE_CODE (decl
) == VAR_DECL
)
6279 /* If this is a local variable that will need a mangled name,
6280 register it now. We must do this before processing the
6281 initializer for the variable, since the initialization might
6282 require a guard variable, and since the mangled name of the
6283 guard variable will depend on the mangled name of this
6285 if (DECL_FUNCTION_SCOPE_P (decl
)
6286 && TREE_STATIC (decl
)
6287 && !DECL_ARTIFICIAL (decl
))
6289 push_local_name (decl
);
6290 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6291 || DECL_DESTRUCTOR_P (current_function_decl
))
6292 /* Normally local_decls is populated during GIMPLE lowering,
6293 but [cd]tors are never actually compiled directly. We need
6294 to put statics on the list so we can deal with the label
6295 address extension. FIXME. */
6296 add_local_decl (cfun
, decl
);
6299 /* Convert the initializer to the type of DECL, if we have not
6300 already initialized DECL. */
6301 if (!DECL_INITIALIZED_P (decl
)
6302 /* If !DECL_EXTERNAL then DECL is being defined. In the
6303 case of a static data member initialized inside the
6304 class-specifier, there can be an initializer even if DECL
6305 is *not* defined. */
6306 && (!DECL_EXTERNAL (decl
) || init
))
6308 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6311 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6312 /* Allow libjava/prims.cc define primitive classes. */
6313 if (init
!= NULL_TREE
6314 || jclass
== NULL_TREE
6315 || TREE_CODE (jclass
) != TYPE_DECL
6316 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6317 || !same_type_ignoring_top_level_qualifiers_p
6318 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6319 error ("Java object %qD not allocated with %<new%>", decl
);
6322 cleanups
= make_tree_vector ();
6323 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6325 /* Check that the initializer for a static data member was a
6326 constant. Although we check in the parser that the
6327 initializer is an integral constant expression, we do not
6328 simplify division-by-zero at the point at which it
6329 occurs. Therefore, in:
6331 struct S { static const int i = 7 / 0; };
6333 we issue an error at this point. It would
6334 probably be better to forbid division by zero in
6335 integral constant expressions. */
6336 if (DECL_EXTERNAL (decl
) && init
)
6338 error ("%qD cannot be initialized by a non-constant expression"
6339 " when being declared", decl
);
6340 DECL_INITIALIZED_IN_CLASS_P (decl
) = 0;
6348 The memory occupied by any object of static storage
6349 duration is zero-initialized at program startup before
6350 any other initialization takes place.
6352 We cannot create an appropriate initializer until after
6353 the type of DECL is finalized. If DECL_INITIAL is set,
6354 then the DECL is statically initialized, and any
6355 necessary zero-initialization has already been performed. */
6356 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6357 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6358 /*nelts=*/NULL_TREE
,
6359 /*static_storage_p=*/true);
6360 /* Remember that the initialization for this variable has
6362 DECL_INITIALIZED_P (decl
) = 1;
6363 /* This declaration is the definition of this variable,
6364 unless we are initializing a static data member within
6365 the class specifier. */
6366 if (!DECL_EXTERNAL (decl
))
6367 var_definition_p
= true;
6369 /* If the variable has an array type, lay out the type, even if
6370 there is no initializer. It is valid to index through the
6371 array, and we must get TYPE_ALIGN set correctly on the array
6373 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6376 if (TREE_STATIC (decl
)
6377 && !at_function_scope_p ()
6378 && current_function_decl
== NULL
)
6379 /* So decl is a global variable or a static member of a
6380 non local class. Record the types it uses
6381 so that we can decide later to emit debug info for them. */
6382 record_types_used_by_current_var_decl (decl
);
6384 else if (TREE_CODE (decl
) == FIELD_DECL
6385 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6386 error ("non-static data member %qD has Java class type", decl
);
6388 /* Add this declaration to the statement-tree. This needs to happen
6389 after the call to check_initializer so that the DECL_EXPR for a
6390 reference temp is added before the DECL_EXPR for the reference itself. */
6391 if (DECL_FUNCTION_SCOPE_P (decl
))
6392 add_decl_expr (decl
);
6394 /* Let the middle end know about variables and functions -- but not
6395 static data members in uninstantiated class templates. */
6396 if (TREE_CODE (decl
) == VAR_DECL
6397 || TREE_CODE (decl
) == FUNCTION_DECL
)
6399 if (TREE_CODE (decl
) == VAR_DECL
)
6401 layout_var_decl (decl
);
6402 maybe_commonize_var (decl
);
6405 /* This needs to happen after the linkage is set. */
6406 determine_visibility (decl
);
6408 if (var_definition_p
&& TREE_STATIC (decl
))
6410 /* If a TREE_READONLY variable needs initialization
6411 at runtime, it is no longer readonly and we need to
6412 avoid MEM_READONLY_P being set on RTL created for it. */
6415 if (TREE_READONLY (decl
))
6416 TREE_READONLY (decl
) = 0;
6419 else if (was_readonly
)
6420 TREE_READONLY (decl
) = 1;
6423 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6425 /* Check for abstractness of the type. Notice that there is no
6426 need to strip array types here since the check for those types
6427 is already done within create_array_type_for_decl. */
6428 if (TREE_CODE (type
) == FUNCTION_TYPE
6429 || TREE_CODE (type
) == METHOD_TYPE
)
6430 abstract_virtuals_error (decl
, TREE_TYPE (type
));
6432 abstract_virtuals_error (decl
, type
);
6434 if (TREE_TYPE (decl
) == error_mark_node
)
6435 /* No initialization required. */
6437 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6441 if (init
== ridpointers
[(int)RID_DEFAULT
])
6443 /* An out-of-class default definition is defined at
6444 the point where it is explicitly defaulted. */
6445 if (DECL_DELETED_FN (decl
))
6446 maybe_explain_implicit_delete (decl
);
6447 else if (DECL_INITIAL (decl
) == error_mark_node
)
6448 synthesize_method (decl
);
6451 error ("function %q#D is initialized like a variable", decl
);
6453 /* else no initialization required. */
6455 else if (DECL_EXTERNAL (decl
)
6456 && ! (DECL_LANG_SPECIFIC (decl
)
6457 && DECL_NOT_REALLY_EXTERN (decl
)))
6460 DECL_INITIAL (decl
) = init
;
6462 /* A variable definition. */
6463 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6464 /* Initialize the local variable. */
6465 initialize_local_var (decl
, init
);
6467 /* If a variable is defined, and then a subsequent
6468 definition with external linkage is encountered, we will
6469 get here twice for the same variable. We want to avoid
6470 calling expand_static_init more than once. For variables
6471 that are not static data members, we can call
6472 expand_static_init only when we actually process the
6473 initializer. It is not legal to redeclare a static data
6474 member, so this issue does not arise in that case. */
6475 else if (var_definition_p
&& TREE_STATIC (decl
))
6476 expand_static_init (decl
, init
);
6479 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6480 reference, insert it in the statement-tree now. */
6484 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6485 push_cleanup (decl
, t
, false);
6486 release_tree_vector (cleanups
);
6490 TREE_READONLY (decl
) = 1;
6492 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6495 /* Returns a declaration for a VAR_DECL as if:
6497 extern "C" TYPE NAME;
6499 had been seen. Used to create compiler-generated global
6503 declare_global_var (tree name
, tree type
)
6507 push_to_top_level ();
6508 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6509 TREE_PUBLIC (decl
) = 1;
6510 DECL_EXTERNAL (decl
) = 1;
6511 DECL_ARTIFICIAL (decl
) = 1;
6512 /* If the user has explicitly declared this variable (perhaps
6513 because the code we are compiling is part of a low-level runtime
6514 library), then it is possible that our declaration will be merged
6515 with theirs by pushdecl. */
6516 decl
= pushdecl (decl
);
6517 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6518 pop_from_top_level ();
6523 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6524 if "__cxa_atexit" is not being used) corresponding to the function
6525 to be called when the program exits. */
6528 get_atexit_fn_ptr_type (void)
6532 if (!atexit_fn_ptr_type_node
)
6535 if (flag_use_cxa_atexit
6536 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6537 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6538 arg_type
= ptr_type_node
;
6540 /* The parameter to "atexit" is "void (*)(void)". */
6541 arg_type
= NULL_TREE
;
6543 fn_type
= build_function_type_list (void_type_node
,
6544 arg_type
, NULL_TREE
);
6545 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6548 return atexit_fn_ptr_type_node
;
6551 /* Returns a pointer to the `atexit' function. Note that if
6552 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6553 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6556 get_atexit_node (void)
6562 bool use_aeabi_atexit
;
6567 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6569 /* The declaration for `__cxa_atexit' is:
6571 int __cxa_atexit (void (*)(void *), void *, void *)
6573 We build up the argument types and then the function type
6575 tree argtype0
, argtype1
, argtype2
;
6577 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6578 /* First, build the pointer-to-function type for the first
6580 fn_ptr_type
= get_atexit_fn_ptr_type ();
6581 /* Then, build the rest of the argument types. */
6582 argtype2
= ptr_type_node
;
6583 if (use_aeabi_atexit
)
6585 argtype1
= fn_ptr_type
;
6586 argtype0
= ptr_type_node
;
6590 argtype1
= ptr_type_node
;
6591 argtype0
= fn_ptr_type
;
6593 /* And the final __cxa_atexit type. */
6594 fn_type
= build_function_type_list (integer_type_node
,
6595 argtype0
, argtype1
, argtype2
,
6597 if (use_aeabi_atexit
)
6598 name
= "__aeabi_atexit";
6600 name
= "__cxa_atexit";
6604 /* The declaration for `atexit' is:
6606 int atexit (void (*)());
6608 We build up the argument types and then the function type
6610 fn_ptr_type
= get_atexit_fn_ptr_type ();
6611 /* Build the final atexit type. */
6612 fn_type
= build_function_type_list (integer_type_node
,
6613 fn_ptr_type
, NULL_TREE
);
6617 /* Now, build the function declaration. */
6618 push_lang_context (lang_name_c
);
6619 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
6620 mark_used (atexit_fndecl
);
6621 pop_lang_context ();
6622 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6627 /* Like get_atexit_node, but for thread-local cleanups. */
6630 get_thread_atexit_node (void)
6632 /* The declaration for `__cxa_thread_atexit' is:
6634 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6635 tree fn_type
= build_function_type_list (integer_type_node
,
6636 get_atexit_fn_ptr_type (),
6637 ptr_type_node
, ptr_type_node
,
6640 /* Now, build the function declaration. */
6641 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
);
6642 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6645 /* Returns the __dso_handle VAR_DECL. */
6648 get_dso_handle_node (void)
6650 if (dso_handle_node
)
6651 return dso_handle_node
;
6653 /* Declare the variable. */
6654 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6657 #ifdef HAVE_GAS_HIDDEN
6658 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6659 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6662 return dso_handle_node
;
6665 /* Begin a new function with internal linkage whose job will be simply
6666 to destroy some particular variable. */
6668 static GTY(()) int start_cleanup_cnt
;
6671 start_cleanup_fn (void)
6676 bool use_cxa_atexit
= flag_use_cxa_atexit
6677 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6679 push_to_top_level ();
6681 /* No need to mangle this. */
6682 push_lang_context (lang_name_c
);
6684 /* Build the name of the function. */
6685 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6686 /* Build the function declaration. */
6687 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6688 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6689 /* It's a function with internal linkage, generated by the
6691 TREE_PUBLIC (fndecl
) = 0;
6692 DECL_ARTIFICIAL (fndecl
) = 1;
6693 /* Make the function `inline' so that it is only emitted if it is
6694 actually needed. It is unlikely that it will be inlined, since
6695 it is only called via a function pointer, but we avoid unnecessary
6696 emissions this way. */
6697 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6698 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6699 /* Build the parameter. */
6704 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6705 DECL_CONTEXT (parmdecl
) = fndecl
;
6706 TREE_USED (parmdecl
) = 1;
6707 DECL_READ_P (parmdecl
) = 1;
6708 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6712 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6714 pop_lang_context ();
6716 return current_function_decl
;
6719 /* Finish the cleanup function begun by start_cleanup_fn. */
6722 end_cleanup_fn (void)
6724 expand_or_defer_fn (finish_function (0));
6726 pop_from_top_level ();
6729 /* Generate code to handle the destruction of DECL, an object with
6730 static storage duration. */
6733 register_dtor_fn (tree decl
)
6740 bool ob_parm
, dso_parm
, use_dtor
;
6741 tree arg0
, arg1
, arg2
;
6744 type
= TREE_TYPE (decl
);
6745 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6746 return void_zero_node
;
6748 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
6749 "__aeabi_atexit"), and DECL is a class object, we can just pass the
6750 destructor to "__cxa_atexit"; we don't have to build a temporary
6751 function to do the cleanup. */
6752 ob_parm
= (DECL_THREAD_LOCAL_P (decl
)
6753 || (flag_use_cxa_atexit
6754 && !targetm
.cxx
.use_atexit_for_cxa_atexit ()));
6756 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
6761 /* Find the destructor. */
6762 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6763 gcc_assert (idx
>= 0);
6764 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
6765 /* Make sure it is accessible. */
6766 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
6767 tf_warning_or_error
);
6771 /* Call build_cleanup before we enter the anonymous function so
6772 that any access checks will be done relative to the current
6773 scope, rather than the scope of the anonymous function. */
6774 build_cleanup (decl
);
6776 /* Now start the function. */
6777 cleanup
= start_cleanup_fn ();
6779 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6780 to the original function, rather than the anonymous one. That
6781 will make the back end think that nested functions are in use,
6782 which causes confusion. */
6783 push_deferring_access_checks (dk_no_check
);
6784 fcall
= build_cleanup (decl
);
6785 pop_deferring_access_checks ();
6787 /* Create the body of the anonymous function. */
6788 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6789 finish_expr_stmt (fcall
);
6790 finish_compound_stmt (compound_stmt
);
6794 /* Call atexit with the cleanup function. */
6795 mark_used (cleanup
);
6796 cleanup
= build_address (cleanup
);
6798 if (DECL_THREAD_LOCAL_P (decl
))
6799 atex_node
= get_thread_atexit_node ();
6801 atex_node
= get_atexit_node ();
6805 /* We must convert CLEANUP to the type that "__cxa_atexit"
6807 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6808 /* "__cxa_atexit" will pass the address of DECL to the
6809 cleanup function. */
6811 addr
= build_address (decl
);
6812 /* The declared type of the parameter to "__cxa_atexit" is
6813 "void *". For plain "T*", we could just let the
6814 machinery in cp_build_function_call convert it -- but if the
6815 type is "cv-qualified T *", then we need to convert it
6816 before passing it in, to avoid spurious errors. */
6817 addr
= build_nop (ptr_type_node
, addr
);
6820 /* Since the cleanup functions we build ignore the address
6821 they're given, there's no reason to pass the actual address
6822 in, and, in general, it's cheaper to pass NULL than any
6824 addr
= null_pointer_node
;
6827 arg2
= cp_build_addr_expr (get_dso_handle_node (),
6828 tf_warning_or_error
);
6834 if (!DECL_THREAD_LOCAL_P (decl
)
6835 && targetm
.cxx
.use_aeabi_atexit ())
6851 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
6852 arg0
, arg1
, arg2
, NULL_TREE
);
6855 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6856 is its initializer. Generate code to handle the construction
6857 and destruction of DECL. */
6860 expand_static_init (tree decl
, tree init
)
6862 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
6863 gcc_assert (TREE_STATIC (decl
));
6865 /* Some variables require no dynamic initialization. */
6867 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6870 if (DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
6871 && !DECL_FUNCTION_SCOPE_P (decl
))
6874 error ("non-local variable %qD declared %<__thread%> "
6875 "needs dynamic initialization", decl
);
6877 error ("non-local variable %qD declared %<__thread%> "
6878 "has a non-trivial destructor", decl
);
6879 static bool informed
;
6882 inform (DECL_SOURCE_LOCATION (decl
),
6883 "C++11 %<thread_local%> allows dynamic initialization "
6890 if (DECL_FUNCTION_SCOPE_P (decl
))
6892 /* Emit code to perform this initialization but once. */
6893 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6894 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6895 tree guard
, guard_addr
;
6897 /* We don't need thread-safety code for thread-local vars. */
6898 bool thread_guard
= (flag_threadsafe_statics
6899 && !DECL_THREAD_LOCAL_P (decl
));
6901 /* Emit code to perform this initialization but once. This code
6904 static <type> guard;
6905 if (!guard.first_byte) {
6906 if (__cxa_guard_acquire (&guard)) {
6909 // Do initialization.
6910 flag = true; __cxa_guard_release (&guard);
6911 // Register variable for destruction at end of program.
6913 if (!flag) __cxa_guard_abort (&guard);
6917 Note that the `flag' variable is only set to 1 *after* the
6918 initialization is complete. This ensures that an exception,
6919 thrown during the construction, will cause the variable to
6920 reinitialized when we pass through this code again, as per:
6924 If the initialization exits by throwing an exception, the
6925 initialization is not complete, so it will be tried again
6926 the next time control enters the declaration.
6928 This process should be thread-safe, too; multiple threads
6929 should not be able to initialize the variable more than
6932 /* Create the guard variable. */
6933 guard
= get_guard (decl
);
6935 /* This optimization isn't safe on targets with relaxed memory
6936 consistency. On such targets we force synchronization in
6937 __cxa_guard_acquire. */
6938 if (!targetm
.relaxed_ordering
|| !thread_guard
)
6940 /* Begin the conditional initialization. */
6941 if_stmt
= begin_if_stmt ();
6942 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
6943 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6948 tree vfntype
= NULL_TREE
;
6949 tree acquire_name
, release_name
, abort_name
;
6950 tree acquire_fn
, release_fn
, abort_fn
;
6951 guard_addr
= build_address (guard
);
6953 acquire_name
= get_identifier ("__cxa_guard_acquire");
6954 release_name
= get_identifier ("__cxa_guard_release");
6955 abort_name
= get_identifier ("__cxa_guard_abort");
6956 acquire_fn
= identifier_global_value (acquire_name
);
6957 release_fn
= identifier_global_value (release_name
);
6958 abort_fn
= identifier_global_value (abort_name
);
6960 acquire_fn
= push_library_fn
6961 (acquire_name
, build_function_type_list (integer_type_node
,
6962 TREE_TYPE (guard_addr
),
6965 if (!release_fn
|| !abort_fn
)
6966 vfntype
= build_function_type_list (void_type_node
,
6967 TREE_TYPE (guard_addr
),
6970 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
);
6972 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
);
6974 inner_if_stmt
= begin_if_stmt ();
6975 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
6978 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6979 begin
= get_target_expr (boolean_false_node
);
6980 flag
= TARGET_EXPR_SLOT (begin
);
6982 TARGET_EXPR_CLEANUP (begin
)
6983 = build3 (COND_EXPR
, void_type_node
, flag
,
6985 build_call_n (abort_fn
, 1, guard_addr
));
6986 CLEANUP_EH_ONLY (begin
) = 1;
6988 /* Do the initialization itself. */
6989 init
= add_stmt_to_compound (begin
, init
);
6990 init
= add_stmt_to_compound
6991 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
6992 init
= add_stmt_to_compound
6993 (init
, build_call_n (release_fn
, 1, guard_addr
));
6996 init
= add_stmt_to_compound (init
, set_guard (guard
));
6998 /* Use atexit to register a function for destroying this static
7000 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7002 finish_expr_stmt (init
);
7006 finish_compound_stmt (inner_then_clause
);
7007 finish_then_clause (inner_if_stmt
);
7008 finish_if_stmt (inner_if_stmt
);
7011 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7013 finish_compound_stmt (then_clause
);
7014 finish_then_clause (if_stmt
);
7015 finish_if_stmt (if_stmt
);
7018 else if (DECL_THREAD_LOCAL_P (decl
))
7019 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7021 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7025 /* Make TYPE a complete type based on INITIAL_VALUE.
7026 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7027 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7028 3 if the initializer list is empty (in pedantic mode). */
7031 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7034 tree type
, elt_type
;
7038 unsigned HOST_WIDE_INT i
;
7041 /* An array of character type can be initialized from a
7042 brace-enclosed string constant.
7044 FIXME: this code is duplicated from reshape_init. Probably
7045 we should just call reshape_init here? */
7046 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7047 && TREE_CODE (initial_value
) == CONSTRUCTOR
7048 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7050 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7051 tree value
= (*v
)[0].value
;
7053 if (TREE_CODE (value
) == STRING_CST
7054 && v
->length () == 1)
7055 initial_value
= value
;
7058 /* If any of the elements are parameter packs, we can't actually
7059 complete this type now because the array size is dependent. */
7060 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7062 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7065 if (PACK_EXPANSION_P (value
))
7071 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7073 /* We can create the array before the element type is complete, which
7074 means that we didn't have these two bits set in the original type
7075 either. In completing the type, we are expected to propagate these
7076 bits. See also complete_type which does the same thing for arrays
7079 if (TYPE_DOMAIN (type
))
7081 elt_type
= TREE_TYPE (type
);
7082 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7083 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7084 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7090 /* As above, but either give an error or reject zero-size arrays, depending
7094 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7095 bool do_default
, tsubst_flags_t complain
)
7098 bool sfinae
= !(complain
& tf_error
);
7099 /* In SFINAE context we can't be lenient about zero-size arrays. */
7102 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7108 /* Not an error. */;
7109 else if (failure
== 1)
7110 error ("initializer fails to determine size of %qT", *ptype
);
7111 else if (failure
== 2)
7114 error ("array size missing in %qT", *ptype
);
7116 else if (failure
== 3)
7117 error ("zero-size array %qT", *ptype
);
7118 *ptype
= error_mark_node
;
7123 /* Return zero if something is declared to be a member of type
7124 CTYPE when in the context of CUR_TYPE. STRING is the error
7125 message to print in that case. Otherwise, quietly return 1. */
7128 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7130 if (ctype
&& ctype
!= cur_type
)
7132 if (flags
== DTOR_FLAG
)
7133 error ("destructor for alien class %qT cannot be a member", ctype
);
7135 error ("constructor for alien class %qT cannot be a member", ctype
);
7141 /* Subroutine of `grokdeclarator'. */
7143 /* Generate errors possibly applicable for a given set of specifiers.
7144 This is for ARM $7.1.2. */
7147 bad_specifiers (tree object
,
7148 enum bad_spec_place type
,
7159 error ("%qD declared as a %<virtual%> variable", object
);
7161 error ("%qD declared as an %<inline%> variable", object
);
7163 error ("%<const%> and %<volatile%> function specifiers on "
7164 "%qD invalid in variable declaration", object
);
7168 error ("%qD declared as a %<virtual%> parameter", object
);
7170 error ("%qD declared as an %<inline%> parameter", object
);
7172 error ("%<const%> and %<volatile%> function specifiers on "
7173 "%qD invalid in parameter declaration", object
);
7177 error ("%qD declared as a %<virtual%> type", object
);
7179 error ("%qD declared as an %<inline%> type", object
);
7181 error ("%<const%> and %<volatile%> function specifiers on "
7182 "%qD invalid in type declaration", object
);
7186 error ("%qD declared as a %<virtual%> field", object
);
7188 error ("%qD declared as an %<inline%> field", object
);
7190 error ("%<const%> and %<volatile%> function specifiers on "
7191 "%qD invalid in field declaration", object
);
7197 error ("%q+D declared as a friend", object
);
7199 && (TREE_CODE (object
) == TYPE_DECL
7200 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7201 && !TYPE_REFFN_P (TREE_TYPE (object
))
7202 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7203 error ("%q+D declared with an exception specification", object
);
7206 /* DECL is a member function or static data member and is presently
7207 being defined. Check that the definition is taking place in a
7211 check_class_member_definition_namespace (tree decl
)
7213 /* These checks only apply to member functions and static data
7215 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
7216 || TREE_CODE (decl
) == VAR_DECL
);
7217 /* We check for problems with specializations in pt.c in
7218 check_specialization_namespace, where we can issue better
7220 if (processing_specialization
)
7222 /* There are no restrictions on the placement of
7223 explicit instantiations. */
7224 if (processing_explicit_instantiation
)
7228 A member function definition that appears outside of the
7229 class definition shall appear in a namespace scope enclosing
7230 the class definition.
7234 The definition for a static data member shall appear in a
7235 namespace scope enclosing the member's class definition. */
7236 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7237 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7238 decl
, DECL_CONTEXT (decl
));
7241 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7242 METHOD_TYPE for a non-static member function; QUALS are the
7243 cv-qualifiers that apply to the function. */
7246 build_this_parm (tree type
, cp_cv_quals quals
)
7251 cp_cv_quals this_quals
;
7253 if (CLASS_TYPE_P (type
))
7256 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7257 this_type
= build_pointer_type (this_type
);
7260 this_type
= type_of_this_parm (type
);
7261 /* The `this' parameter is implicitly `const'; it cannot be
7263 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7264 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7265 parm
= build_artificial_parm (this_identifier
, qual_type
);
7266 cp_apply_type_quals_to_decl (this_quals
, parm
);
7270 /* DECL is a static member function. Complain if it was declared
7271 with function-cv-quals. */
7274 check_static_quals (tree decl
, cp_cv_quals quals
)
7276 if (quals
!= TYPE_UNQUALIFIED
)
7277 error ("static member function %q#D declared with type qualifiers",
7281 /* CTYPE is class type, or null if non-class.
7282 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7284 DECLARATOR is the function's name.
7285 PARMS is a chain of PARM_DECLs for the function.
7286 VIRTUALP is truthvalue of whether the function is virtual or not.
7287 FLAGS are to be passed through to `grokclassfn'.
7288 QUALS are qualifiers indicating whether the function is `const'
7290 RAISES is a list of exceptions that this function can raise.
7291 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7292 not look, and -1 if we should not call `grokclassfn' at all.
7294 SFK is the kind of special function (if any) for the new function.
7296 Returns `NULL_TREE' if something goes wrong, after issuing
7297 applicable error messages. */
7300 grokfndecl (tree ctype
,
7304 tree orig_declarator
,
7306 enum overload_flags flags
,
7313 special_function_kind sfk
,
7318 location_t location
)
7321 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7325 type
= build_exception_variant (type
, raises
);
7327 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7329 /* If we have an explicit location, use it, otherwise use whatever
7330 build_lang_decl used (probably input_location). */
7331 if (location
!= UNKNOWN_LOCATION
)
7332 DECL_SOURCE_LOCATION (decl
) = location
;
7334 if (TREE_CODE (type
) == METHOD_TYPE
)
7337 parm
= build_this_parm (type
, quals
);
7338 DECL_CHAIN (parm
) = parms
;
7341 DECL_ARGUMENTS (decl
) = parms
;
7342 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7343 DECL_CONTEXT (t
) = decl
;
7344 /* Propagate volatile out from type to decl. */
7345 if (TYPE_VOLATILE (type
))
7346 TREE_THIS_VOLATILE (decl
) = 1;
7348 /* Setup decl according to sfk. */
7351 case sfk_constructor
:
7352 case sfk_copy_constructor
:
7353 case sfk_move_constructor
:
7354 DECL_CONSTRUCTOR_P (decl
) = 1;
7356 case sfk_destructor
:
7357 DECL_DESTRUCTOR_P (decl
) = 1;
7363 /* If pointers to member functions use the least significant bit to
7364 indicate whether a function is virtual, ensure a pointer
7365 to this function will have that bit clear. */
7366 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7367 && TREE_CODE (type
) == METHOD_TYPE
7368 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7369 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7372 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7376 ("defining explicit specialization %qD in friend declaration",
7380 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7381 tree args
= TREE_OPERAND (orig_declarator
, 1);
7383 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7385 /* Something like `template <class T> friend void f<T>()'. */
7386 error ("invalid use of template-id %qD in declaration "
7387 "of primary template",
7393 /* A friend declaration of the form friend void f<>(). Record
7394 the information in the TEMPLATE_ID_EXPR. */
7395 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7397 if (TREE_CODE (fns
) == COMPONENT_REF
)
7399 /* Due to bison parser ickiness, we will have already looked
7400 up an operator_name or PFUNCNAME within the current class
7401 (see template_id in parse.y). If the current class contains
7402 such a name, we'll get a COMPONENT_REF here. Undo that. */
7404 gcc_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
7405 == current_class_type
);
7406 fns
= TREE_OPERAND (fns
, 1);
7408 gcc_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
7409 || TREE_CODE (fns
) == OVERLOAD
);
7410 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7412 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7413 if (TREE_PURPOSE (t
)
7414 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7416 error ("default arguments are not allowed in declaration "
7417 "of friend template specialization %qD",
7424 error ("%<inline%> is not allowed in declaration of friend "
7425 "template specialization %qD",
7432 /* If this decl has namespace scope, set that up. */
7434 set_decl_namespace (decl
, in_namespace
, friendp
);
7436 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7438 /* `main' and builtins have implicit 'C' linkage. */
7439 if ((MAIN_NAME_P (declarator
)
7440 || (IDENTIFIER_LENGTH (declarator
) > 10
7441 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7442 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7443 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
7444 && current_lang_name
== lang_name_cplusplus
7445 && ctype
== NULL_TREE
7446 && DECL_FILE_SCOPE_P (decl
))
7447 SET_DECL_LANGUAGE (decl
, lang_c
);
7449 /* Should probably propagate const out from type to decl I bet (mrs). */
7452 DECL_STATIC_FUNCTION_P (decl
) = 1;
7453 DECL_CONTEXT (decl
) = ctype
;
7458 DECL_CONTEXT (decl
) = ctype
;
7460 check_class_member_definition_namespace (decl
);
7463 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7465 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7466 error ("cannot declare %<::main%> to be a template");
7468 error ("cannot declare %<::main%> to be inline");
7470 error ("cannot declare %<::main%> to be static");
7475 /* Members of anonymous types and local classes have no linkage; make
7476 them internal. If a typedef is made later, this will be changed. */
7477 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
7478 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7481 if (publicp
&& cxx_dialect
== cxx98
)
7483 /* [basic.link]: A name with no linkage (notably, the name of a class
7484 or enumeration declared in a local scope) shall not be used to
7485 declare an entity with linkage.
7487 DR 757 relaxes this restriction for C++0x. */
7488 t
= no_linkage_check (TREE_TYPE (decl
),
7489 /*relaxed_p=*/false);
7492 if (TYPE_ANONYMOUS_P (t
))
7494 if (DECL_EXTERN_C_P (decl
))
7495 /* Allow this; it's pretty common in C. */;
7498 permerror (input_location
, "anonymous type with no linkage "
7499 "used to declare function %q#D with linkage",
7501 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7502 permerror (input_location
, "%q+#D does not refer to the unqualified "
7503 "type, so it is not used for linkage",
7508 permerror (input_location
, "type %qT with no linkage used to "
7509 "declare function %q#D with linkage", t
, decl
);
7513 TREE_PUBLIC (decl
) = publicp
;
7516 DECL_INTERFACE_KNOWN (decl
) = 1;
7517 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7520 /* If the declaration was declared inline, mark it as such. */
7522 DECL_DECLARED_INLINE_P (decl
) = 1;
7524 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7526 DECL_EXTERNAL (decl
) = 1;
7527 if (quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
7530 ? G_("static member function %qD cannot have cv-qualifier")
7531 : G_("non-member function %qD cannot have cv-qualifier"),
7533 quals
= TYPE_UNQUALIFIED
;
7536 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7537 && !grok_op_properties (decl
, /*complain=*/true))
7539 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7541 bool long_long_unsigned_p
;
7543 const char *suffix
= NULL
;
7544 /* [over.literal]/6: Literal operators shall not have C linkage. */
7545 if (DECL_LANGUAGE (decl
) == lang_c
)
7547 error ("literal operator with C linkage");
7551 if (DECL_NAMESPACE_SCOPE_P (decl
))
7553 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7556 error ("%qD has invalid argument list", decl
);
7560 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7561 if (long_long_unsigned_p
)
7563 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7564 warning (0, "integer suffix %<%s%>"
7565 " shadowed by implementation", suffix
);
7567 else if (long_double_p
)
7569 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7570 warning (0, "floating point suffix %<%s%>"
7571 " shadowed by implementation", suffix
);
7576 error ("%qD must be a non-member function", decl
);
7582 /* Make the init_value nonzero so pushdecl knows this is not
7583 tentative. error_mark_node is replaced later with the BLOCK. */
7584 DECL_INITIAL (decl
) = error_mark_node
;
7586 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7587 TREE_NOTHROW (decl
) = 1;
7589 /* Caller will do the rest of this. */
7593 if (ctype
!= NULL_TREE
)
7594 grokclassfn (ctype
, decl
, flags
);
7597 if (cxx_dialect
>= cxx0x
7598 && DECL_DESTRUCTOR_P (decl
)
7599 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7600 && !processing_template_decl
)
7601 deduce_noexcept_on_destructor (decl
);
7603 decl
= check_explicit_specialization (orig_declarator
, decl
,
7606 4 * (friendp
!= 0));
7607 if (decl
== error_mark_node
)
7610 if (DECL_STATIC_FUNCTION_P (decl
))
7611 check_static_quals (decl
, quals
);
7615 cplus_decl_attributes (&decl
, *attrlist
, 0);
7616 *attrlist
= NULL_TREE
;
7619 /* Check main's type after attributes have been applied. */
7620 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7622 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7625 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7627 error ("%<::main%> must return %<int%>");
7628 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7629 TREE_TYPE (decl
) = newtype
;
7632 check_main_parameter_types (decl
);
7635 if (ctype
!= NULL_TREE
7636 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
7639 tree old_decl
= check_classfn (ctype
, decl
,
7640 (processing_template_decl
7641 > template_class_depth (ctype
))
7642 ? current_template_parms
7645 if (old_decl
== error_mark_node
)
7653 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
7654 /* Because grokfndecl is always supposed to return a
7655 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7656 here. We depend on our callers to figure out that its
7657 really a template that's being returned. */
7658 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
7660 if (DECL_STATIC_FUNCTION_P (old_decl
)
7661 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7663 /* Remove the `this' parm added by grokclassfn. */
7664 revert_static_member_fn (decl
);
7665 check_static_quals (decl
, quals
);
7667 if (DECL_ARTIFICIAL (old_decl
))
7669 error ("definition of implicitly-declared %qD", old_decl
);
7672 else if (DECL_DEFAULTED_FN (old_decl
))
7674 error ("definition of explicitly-defaulted %q+D", decl
);
7675 error ("%q+#D explicitly defaulted here", old_decl
);
7679 /* Since we've smashed OLD_DECL to its
7680 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7681 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7682 decl
= DECL_TEMPLATE_RESULT (decl
);
7684 /* Attempt to merge the declarations. This can fail, in
7685 the case of some invalid specialization declarations. */
7686 pushed_scope
= push_scope (ctype
);
7687 ok
= duplicate_decls (decl
, old_decl
, friendp
);
7689 pop_scope (pushed_scope
);
7692 error ("no %q#D member function declared in class %qT",
7700 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
7703 if (ctype
== NULL_TREE
|| check
)
7707 DECL_VIRTUAL_P (decl
) = 1;
7712 /* decl is a FUNCTION_DECL.
7713 specifiers are the parsed virt-specifiers.
7715 Set flags to reflect the virt-specifiers.
7720 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
7722 if (decl
== NULL_TREE
)
7724 if (specifiers
& VIRT_SPEC_OVERRIDE
)
7725 DECL_OVERRIDE_P (decl
) = 1;
7726 if (specifiers
& VIRT_SPEC_FINAL
)
7727 DECL_FINAL_P (decl
) = 1;
7731 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7732 the linkage that DECL will receive in the object file. */
7735 set_linkage_for_static_data_member (tree decl
)
7737 /* A static data member always has static storage duration and
7738 external linkage. Note that static data members are forbidden in
7739 local classes -- the only situation in which a class has
7740 non-external linkage. */
7741 TREE_PUBLIC (decl
) = 1;
7742 TREE_STATIC (decl
) = 1;
7743 /* For non-template classes, static data members are always put
7744 out in exactly those files where they are defined, just as
7745 with ordinary namespace-scope variables. */
7746 if (!processing_template_decl
)
7747 DECL_INTERFACE_KNOWN (decl
) = 1;
7750 /* Create a VAR_DECL named NAME with the indicated TYPE.
7752 If SCOPE is non-NULL, it is the class type or namespace containing
7753 the variable. If SCOPE is NULL, the variable should is created in
7754 the innermost enclosings scope. */
7757 grokvardecl (tree type
,
7759 const cp_decl_specifier_seq
*declspecs
,
7765 tree explicit_scope
;
7767 gcc_assert (!name
|| TREE_CODE (name
) == IDENTIFIER_NODE
);
7769 /* Compute the scope in which to place the variable, but remember
7770 whether or not that scope was explicitly specified by the user. */
7771 explicit_scope
= scope
;
7774 /* An explicit "extern" specifier indicates a namespace-scope
7776 if (declspecs
->storage_class
== sc_extern
)
7777 scope
= current_decl_namespace ();
7778 else if (!at_function_scope_p ())
7779 scope
= current_scope ();
7783 && (/* If the variable is a namespace-scope variable declared in a
7784 template, we need DECL_LANG_SPECIFIC. */
7785 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
7786 /* Similarly for namespace-scope variables with language linkage
7788 || (TREE_CODE (scope
) == NAMESPACE_DECL
7789 && current_lang_name
!= lang_name_cplusplus
)
7790 /* Similarly for static data members. */
7792 decl
= build_lang_decl (VAR_DECL
, name
, type
);
7794 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7796 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
7797 set_decl_namespace (decl
, explicit_scope
, 0);
7799 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
7801 if (declspecs
->storage_class
== sc_extern
)
7803 DECL_THIS_EXTERN (decl
) = 1;
7804 DECL_EXTERNAL (decl
) = !initialized
;
7807 if (DECL_CLASS_SCOPE_P (decl
))
7809 set_linkage_for_static_data_member (decl
);
7810 /* This function is only called with out-of-class definitions. */
7811 DECL_EXTERNAL (decl
) = 0;
7812 check_class_member_definition_namespace (decl
);
7814 /* At top level, either `static' or no s.c. makes a definition
7815 (perhaps tentative), and absence of `static' makes it public. */
7816 else if (toplevel_bindings_p ())
7818 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
7819 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7820 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7822 /* Not at top level, only `static' makes a static definition. */
7825 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
7826 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7829 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
7831 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
7832 if (declspecs
->gnu_thread_keyword_p
)
7833 DECL_GNU_TLS_P (decl
) = true;
7836 /* If the type of the decl has no linkage, make sure that we'll
7837 notice that in mark_used. */
7838 if (cxx_dialect
> cxx98
7839 && decl_linkage (decl
) != lk_none
7840 && DECL_LANG_SPECIFIC (decl
) == NULL
7841 && !DECL_EXTERN_C_P (decl
)
7842 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
7843 retrofit_lang_decl (decl
);
7845 if (TREE_PUBLIC (decl
))
7847 /* [basic.link]: A name with no linkage (notably, the name of a class
7848 or enumeration declared in a local scope) shall not be used to
7849 declare an entity with linkage.
7851 DR 757 relaxes this restriction for C++0x. */
7852 tree t
= (cxx_dialect
> cxx98
? NULL_TREE
7853 : no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false));
7856 if (TYPE_ANONYMOUS_P (t
))
7858 if (DECL_EXTERN_C_P (decl
))
7859 /* Allow this; it's pretty common in C. */
7863 /* DRs 132, 319 and 389 seem to indicate types with
7864 no linkage can only be used to declare extern "C"
7865 entities. Since it's not always an error in the
7866 ISO C++ 90 Standard, we only issue a warning. */
7867 warning (0, "anonymous type with no linkage used to declare "
7868 "variable %q#D with linkage", decl
);
7869 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7870 warning (0, "%q+#D does not refer to the unqualified "
7871 "type, so it is not used for linkage",
7876 warning (0, "type %qT with no linkage used to declare variable "
7877 "%q#D with linkage", t
, decl
);
7881 DECL_INTERFACE_KNOWN (decl
) = 1;
7886 /* Create and return a canonical pointer to member function type, for
7887 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7890 build_ptrmemfunc_type (tree type
)
7894 tree unqualified_variant
= NULL_TREE
;
7896 if (type
== error_mark_node
)
7899 /* If a canonical type already exists for this type, use it. We use
7900 this method instead of type_hash_canon, because it only does a
7901 simple equality check on the list of field members. */
7903 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
7906 /* Make sure that we always have the unqualified pointer-to-member
7908 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7910 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
7912 t
= make_class_type (RECORD_TYPE
);
7913 xref_basetypes (t
, NULL_TREE
);
7915 /* Let the front end know this is a pointer to member function... */
7916 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
7917 /* ... and not really a class type. */
7918 SET_CLASS_TYPE_P (t
, 0);
7920 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
7923 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
7925 DECL_CHAIN (field
) = fields
;
7928 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
7930 /* Zap out the name so that the back end will give us the debugging
7931 information for this anonymous RECORD_TYPE. */
7932 TYPE_NAME (t
) = NULL_TREE
;
7934 /* If this is not the unqualified form of this pointer-to-member
7935 type, set the TYPE_MAIN_VARIANT for this type to be the
7936 unqualified type. Since they are actually RECORD_TYPEs that are
7937 not variants of each other, we must do this manually.
7938 As we just built a new type there is no need to do yet another copy. */
7939 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7941 int type_quals
= cp_type_quals (type
);
7942 TYPE_READONLY (t
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
7943 TYPE_VOLATILE (t
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
7944 TYPE_RESTRICT (t
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
7945 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
7946 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
7947 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
7948 TREE_TYPE (TYPE_BINFO (t
)) = t
;
7951 /* Cache this pointer-to-member type so that we can find it again
7953 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
7955 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
7956 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7957 else if (TYPE_CANONICAL (type
) != type
)
7958 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
7963 /* Create and return a pointer to data member type. */
7966 build_ptrmem_type (tree class_type
, tree member_type
)
7968 if (TREE_CODE (member_type
) == METHOD_TYPE
)
7970 cp_cv_quals quals
= type_memfn_quals (member_type
);
7971 member_type
= build_memfn_type (member_type
, class_type
, quals
);
7972 return build_ptrmemfunc_type (build_pointer_type (member_type
));
7976 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
7977 return build_offset_type (class_type
, member_type
);
7981 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7982 Check to see that the definition is valid. Issue appropriate error
7983 messages. Return 1 if the definition is particularly bad, or 0
7987 check_static_variable_definition (tree decl
, tree type
)
7989 /* Can't check yet if we don't know the type. */
7990 if (dependent_type_p (type
))
7992 /* If DECL is declared constexpr, we'll do the appropriate checks
7993 in check_initializer. */
7994 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
7996 else if (cxx_dialect
>= cxx0x
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7998 if (!COMPLETE_TYPE_P (type
))
7999 error ("in-class initialization of static data member %q#D of "
8000 "incomplete type", decl
);
8001 else if (literal_type_p (type
))
8002 permerror (input_location
,
8003 "%<constexpr%> needed for in-class initialization of "
8004 "static data member %q#D of non-integral type", decl
);
8006 error ("in-class initialization of static data member %q#D of "
8007 "non-literal type", decl
);
8011 /* Motion 10 at San Diego: If a static const integral data member is
8012 initialized with an integral constant expression, the initializer
8013 may appear either in the declaration (within the class), or in
8014 the definition, but not both. If it appears in the class, the
8015 member is a member constant. The file-scope definition is always
8017 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8019 error ("invalid in-class initialization of static data member "
8020 "of non-integral type %qT",
8024 else if (!CP_TYPE_CONST_P (type
))
8025 error ("ISO C++ forbids in-class initialization of non-const "
8026 "static member %qD",
8028 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8029 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8030 "%qD of non-integral type %qT", decl
, type
);
8035 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8036 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8037 expressions out into temporary variables so that walk_tree doesn't
8038 step into them (c++/15764). */
8041 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8043 struct pointer_set_t
*pset
= (struct pointer_set_t
*)data
;
8044 tree expr
= *expr_p
;
8045 if (TREE_CODE (expr
) == SAVE_EXPR
)
8047 tree op
= TREE_OPERAND (expr
, 0);
8048 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8049 if (TREE_SIDE_EFFECTS (op
))
8050 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8053 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8058 /* Entry point for the above. */
8061 stabilize_vla_size (tree size
)
8063 struct pointer_set_t
*pset
= pointer_set_create ();
8064 /* Break out any function calls into temporary variables. */
8065 cp_walk_tree (&size
, stabilize_save_expr_r
, pset
, pset
);
8066 pointer_set_destroy (pset
);
8069 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8070 not inside of SAVE_EXPR and fold them. */
8073 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8075 tree expr
= *expr_p
;
8076 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8078 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8080 *(bool *)data
= true;
8081 if (SIZEOF_EXPR_TYPE_P (expr
))
8082 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8083 SIZEOF_EXPR
, false);
8084 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8085 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8088 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8090 if (expr
== error_mark_node
)
8091 expr
= size_one_node
;
8098 /* Given the SIZE (i.e., number of elements) in an array, compute an
8099 appropriate index type for the array. If non-NULL, NAME is the
8100 name of the thing being declared. */
8103 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8107 tree abi_1_itype
= NULL_TREE
;
8109 if (error_operand_p (size
))
8110 return error_mark_node
;
8112 if (!type_dependent_expression_p (size
))
8114 tree type
= TREE_TYPE (size
);
8116 mark_rvalue_use (size
);
8118 if (cxx_dialect
< cxx0x
&& TREE_CODE (size
) == NOP_EXPR
8119 && TREE_SIDE_EFFECTS (size
))
8120 /* In C++98, we mark a non-constant array bound with a magic
8121 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8124 size
= fold_non_dependent_expr_sfinae (size
, complain
);
8126 if (CLASS_TYPE_P (type
)
8127 && CLASSTYPE_LITERAL_P (type
))
8129 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8132 if (!(complain
& tf_error
))
8133 return error_mark_node
;
8135 error ("size of array %qD has non-integral type %qT",
8138 error ("size of array has non-integral type %qT", type
);
8139 size
= integer_one_node
;
8141 if (size
== error_mark_node
)
8142 return error_mark_node
;
8143 type
= TREE_TYPE (size
);
8144 /* We didn't support this case in GCC 3.2, so don't bother
8145 trying to model it now in ABI v1. */
8146 abi_1_itype
= error_mark_node
;
8149 size
= maybe_constant_value (size
);
8150 if (!TREE_CONSTANT (size
))
8154 if (error_operand_p (size
))
8155 return error_mark_node
;
8157 /* The array bound must be an integer type. */
8158 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8160 if (!(complain
& tf_error
))
8161 return error_mark_node
;
8163 error ("size of array %qD has non-integral type %qT", name
, type
);
8165 error ("size of array has non-integral type %qT", type
);
8166 size
= integer_one_node
;
8167 type
= TREE_TYPE (size
);
8171 /* A type is dependent if it is...an array type constructed from any
8172 dependent type or whose size is specified by a constant expression
8173 that is value-dependent. */
8174 /* We can only call value_dependent_expression_p on integral constant
8175 expressions; treat non-constant expressions as dependent, too. */
8176 if (processing_template_decl
8177 && (type_dependent_expression_p (size
)
8178 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8180 /* We cannot do any checking for a SIZE that isn't known to be
8181 constant. Just build the index type and mark that it requires
8182 structural equality checks. */
8183 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8184 size
, integer_one_node
));
8185 TYPE_DEPENDENT_P (itype
) = 1;
8186 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8187 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8191 if (!abi_version_at_least (2) && processing_template_decl
8192 && abi_1_itype
== NULL_TREE
)
8193 /* For abi-1, we handled all instances in templates the same way,
8194 even when they were non-dependent. This affects the manglings
8195 produced. So, we do the normal checking for non-dependent
8196 sizes, but at the end we'll return the same type that abi-1
8197 would have, but with TYPE_CANONICAL set to the "right"
8198 value that the current ABI would provide. */
8199 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8200 osize
, integer_one_node
));
8202 /* Normally, the array-bound will be a constant. */
8203 if (TREE_CODE (size
) == INTEGER_CST
)
8205 /* Check to see if the array bound overflowed. Make that an
8206 error, no matter how generous we're being. */
8207 constant_expression_error (size
);
8209 /* An array must have a positive number of elements. */
8210 if (INT_CST_LT (size
, integer_zero_node
))
8212 if (!(complain
& tf_error
))
8213 return error_mark_node
;
8215 error ("size of array %qD is negative", name
);
8217 error ("size of array is negative");
8218 size
= integer_one_node
;
8220 /* As an extension we allow zero-sized arrays. */
8221 else if (integer_zerop (size
))
8223 if (!(complain
& tf_error
))
8224 /* We must fail if performing argument deduction (as
8225 indicated by the state of complain), so that
8226 another substitution can be found. */
8227 return error_mark_node
;
8228 else if (in_system_header
)
8229 /* Allow them in system headers because glibc uses them. */;
8231 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8233 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8236 else if (TREE_CONSTANT (size
)
8237 /* We don't allow VLAs at non-function scopes, or during
8238 tentative template substitution. */
8239 || !at_function_scope_p () || !(complain
& tf_error
))
8241 if (!(complain
& tf_error
))
8242 return error_mark_node
;
8243 /* `(int) &fn' is not a valid array bound. */
8245 error ("size of array %qD is not an integral constant-expression",
8248 error ("size of array is not an integral constant-expression");
8249 size
= integer_one_node
;
8251 else if (pedantic
&& warn_vla
!= 0)
8254 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8256 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8258 else if (warn_vla
> 0)
8262 "variable length array %qD is used", name
);
8265 "variable length array is used");
8268 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8269 /* A variable sized array. */
8270 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8273 HOST_WIDE_INT saved_processing_template_decl
;
8275 /* Compute the index of the largest element in the array. It is
8276 one less than the number of elements in the array. We save
8277 and restore PROCESSING_TEMPLATE_DECL so that computations in
8278 cp_build_binary_op will be appropriately folded. */
8279 saved_processing_template_decl
= processing_template_decl
;
8280 processing_template_decl
= 0;
8281 itype
= cp_build_binary_op (input_location
,
8283 cp_convert (ssizetype
, size
, complain
),
8284 cp_convert (ssizetype
, integer_one_node
,
8287 itype
= fold (itype
);
8288 processing_template_decl
= saved_processing_template_decl
;
8290 if (!TREE_CONSTANT (itype
))
8292 /* A variable sized array. */
8293 itype
= variable_size (itype
);
8294 if (TREE_CODE (itype
) != SAVE_EXPR
)
8296 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8297 they might survive till gimplification. */
8298 tree newitype
= itype
;
8300 cp_walk_tree_without_duplicates (&newitype
,
8301 fold_sizeof_expr_r
, &found
);
8303 itype
= variable_size (fold (newitype
));
8306 /* Make sure that there was no overflow when creating to a signed
8307 index type. (For example, on a 32-bit machine, an array with
8308 size 2^32 - 1 is too big.) */
8309 else if (TREE_CODE (itype
) == INTEGER_CST
8310 && TREE_OVERFLOW (itype
))
8312 if (!(complain
& tf_error
))
8313 return error_mark_node
;
8314 error ("overflow in array dimension");
8315 TREE_OVERFLOW (itype
) = 0;
8319 /* Create and return the appropriate index type. */
8320 if (abi_1_itype
&& abi_1_itype
!= error_mark_node
)
8322 tree t
= build_index_type (itype
);
8323 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
8324 itype
= abi_1_itype
;
8327 itype
= build_index_type (itype
);
8329 /* If the index type were dependent, we would have returned early, so
8330 remember that it isn't. */
8331 TYPE_DEPENDENT_P (itype
) = 0;
8332 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8336 /* Returns the scope (if any) in which the entity declared by
8337 DECLARATOR will be located. If the entity was declared with an
8338 unqualified name, NULL_TREE is returned. */
8341 get_scope_of_declarator (const cp_declarator
*declarator
)
8343 while (declarator
&& declarator
->kind
!= cdk_id
)
8344 declarator
= declarator
->declarator
;
8346 /* If the declarator-id is a SCOPE_REF, the scope in which the
8347 declaration occurs is the first operand. */
8349 && declarator
->u
.id
.qualifying_scope
)
8350 return declarator
->u
.id
.qualifying_scope
;
8352 /* Otherwise, the declarator is not a qualified name; the entity will
8353 be declared in the current scope. */
8357 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8358 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8362 create_array_type_for_decl (tree name
, tree type
, tree size
)
8364 tree itype
= NULL_TREE
;
8366 /* If things have already gone awry, bail now. */
8367 if (type
== error_mark_node
|| size
== error_mark_node
)
8368 return error_mark_node
;
8370 /* 8.3.4/1: If the type of the identifier of D contains the auto
8371 type-specifier, the program is ill-formed. */
8372 if (pedantic
&& type_uses_auto (type
))
8373 pedwarn (input_location
, OPT_Wpedantic
,
8374 "declaration of %qD as array of %<auto%>", name
);
8376 /* If there are some types which cannot be array elements,
8377 issue an error-message and return. */
8378 switch (TREE_CODE (type
))
8382 error ("declaration of %qD as array of void", name
);
8384 error ("creating array of void");
8385 return error_mark_node
;
8389 error ("declaration of %qD as array of functions", name
);
8391 error ("creating array of functions");
8392 return error_mark_node
;
8394 case REFERENCE_TYPE
:
8396 error ("declaration of %qD as array of references", name
);
8398 error ("creating array of references");
8399 return error_mark_node
;
8403 error ("declaration of %qD as array of function members", name
);
8405 error ("creating array of function members");
8406 return error_mark_node
;
8414 The constant expressions that specify the bounds of the arrays
8415 can be omitted only for the first member of the sequence. */
8416 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8419 error ("declaration of %qD as multidimensional array must "
8420 "have bounds for all dimensions except the first",
8423 error ("multidimensional array must have bounds for all "
8424 "dimensions except the first");
8426 return error_mark_node
;
8429 /* Figure out the index type for the array. */
8431 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8434 T is called the array element type; this type shall not be [...] an
8435 abstract class type. */
8436 abstract_virtuals_error (name
, type
);
8438 return build_cplus_array_type (type
, itype
);
8441 /* Check that it's OK to declare a function with the indicated TYPE.
8442 SFK indicates the kind of special function (if any) that this
8443 function is. OPTYPE is the type given in a conversion operator
8444 declaration, or the class type for a constructor/destructor.
8445 Returns the actual return type of the function; that
8446 may be different than TYPE if an error occurs, or for certain
8447 special functions. */
8450 check_special_function_return_type (special_function_kind sfk
,
8456 case sfk_constructor
:
8458 error ("return type specification for constructor invalid");
8460 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8461 type
= build_pointer_type (optype
);
8463 type
= void_type_node
;
8466 case sfk_destructor
:
8468 error ("return type specification for destructor invalid");
8469 /* We can't use the proper return type here because we run into
8470 problems with ambiguous bases and covariant returns.
8471 Java classes are left unchanged because (void *) isn't a valid
8472 Java type, and we don't want to change the Java ABI. */
8473 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8474 type
= build_pointer_type (void_type_node
);
8476 type
= void_type_node
;
8479 case sfk_conversion
:
8481 error ("return type specified for %<operator %T%>", optype
);
8492 /* A variable or data member (whose unqualified name is IDENTIFIER)
8493 has been declared with the indicated TYPE. If the TYPE is not
8494 acceptable, issue an error message and return a type to use for
8495 error-recovery purposes. */
8498 check_var_type (tree identifier
, tree type
)
8500 if (VOID_TYPE_P (type
))
8503 error ("unnamed variable or field declared void");
8504 else if (TREE_CODE (identifier
) == IDENTIFIER_NODE
)
8506 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8507 error ("variable or field %qE declared void", identifier
);
8510 error ("variable or field declared void");
8511 type
= error_mark_node
;
8517 /* Given declspecs and a declarator (abstract or otherwise), determine
8518 the name and type of the object declared and construct a DECL node
8521 DECLSPECS points to the representation of declaration-specifier
8522 sequence that precedes declarator.
8524 DECL_CONTEXT says which syntactic context this declaration is in:
8525 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8526 FUNCDEF for a function definition. Like NORMAL but a few different
8527 error messages in each case. Return value may be zero meaning
8528 this definition is too screwy to try to parse.
8529 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8530 handle member functions (which have FIELD context).
8531 Return value may be zero meaning this definition is too screwy to
8533 PARM for a parameter declaration (either within a function prototype
8534 or before a function body). Make a PARM_DECL, or return void_type_node.
8535 TPARM for a template parameter declaration.
8536 CATCHPARM for a parameter declaration before a catch clause.
8537 TYPENAME if for a typename (in a cast or sizeof).
8538 Don't make a DECL node; just return the ..._TYPE node.
8539 FIELD for a struct or union field; make a FIELD_DECL.
8540 BITFIELD for a field with specified width.
8542 INITIALIZED is as for start_decl.
8544 ATTRLIST is a pointer to the list of attributes, which may be NULL
8545 if there are none; *ATTRLIST may be modified if attributes from inside
8546 the declarator should be applied to the declaration.
8548 When this function is called, scoping variables (such as
8549 CURRENT_CLASS_TYPE) should reflect the scope in which the
8550 declaration occurs, not the scope in which the new declaration will
8551 be placed. For example, on:
8555 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8558 Returns a DECL (if a declarator is present), a TYPE (if there is no
8559 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8563 grokdeclarator (const cp_declarator
*declarator
,
8564 cp_decl_specifier_seq
*declspecs
,
8565 enum decl_context decl_context
,
8569 tree type
= NULL_TREE
;
8571 int explicit_int128
= 0;
8572 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8573 int explicit_int
= 0;
8574 int explicit_char
= 0;
8575 int defaulted_int
= 0;
8576 tree dependent_name
= NULL_TREE
;
8578 tree typedef_decl
= NULL_TREE
;
8579 const char *name
= NULL
;
8580 tree typedef_type
= NULL_TREE
;
8581 /* True if this declarator is a function definition. */
8582 bool funcdef_flag
= false;
8583 cp_declarator_kind innermost_code
= cdk_error
;
8586 /* See the code below that used this. */
8587 tree decl_attr
= NULL_TREE
;
8590 /* Keep track of what sort of function is being processed
8591 so that we can warn about default return values, or explicit
8592 return values which do not match prescribed defaults. */
8593 special_function_kind sfk
= sfk_none
;
8595 tree dname
= NULL_TREE
;
8596 tree ctor_return_type
= NULL_TREE
;
8597 enum overload_flags flags
= NO_SPECIAL
;
8598 /* cv-qualifiers that apply to the declarator, for a declaration of
8599 a member function. */
8600 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8601 /* virt-specifiers that apply to the declarator, for a declaration of
8602 a member function. */
8603 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8604 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8606 tree raises
= NULL_TREE
;
8607 int template_count
= 0;
8608 tree returned_attrs
= NULL_TREE
;
8609 tree parms
= NULL_TREE
;
8610 const cp_declarator
*id_declarator
;
8611 /* The unqualified name of the declarator; either an
8612 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8613 tree unqualified_id
;
8614 /* The class type, if any, in which this entity is located,
8615 or NULL_TREE if none. Note that this value may be different from
8616 the current class type; for example if an attempt is made to declare
8617 "A::f" inside "B", this value will be "A". */
8618 tree ctype
= current_class_type
;
8619 /* The NAMESPACE_DECL for the namespace in which this entity is
8620 located. If an unqualified name is used to declare the entity,
8621 this value will be NULL_TREE, even if the entity is located at
8623 tree in_namespace
= NULL_TREE
;
8624 cp_storage_class storage_class
;
8625 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8626 bool type_was_error_mark_node
= false;
8627 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8628 bool template_type_arg
= false;
8629 bool template_parm_flag
= false;
8630 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8633 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8634 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8635 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8636 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8637 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8638 explicit_int128
= declspecs
->explicit_int128_p
;
8639 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8641 if (decl_context
== FUNCDEF
)
8642 funcdef_flag
= true, decl_context
= NORMAL
;
8643 else if (decl_context
== MEMFUNCDEF
)
8644 funcdef_flag
= true, decl_context
= FIELD
;
8645 else if (decl_context
== BITFIELD
)
8646 bitfield
= 1, decl_context
= FIELD
;
8647 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8648 template_type_arg
= true, decl_context
= TYPENAME
;
8649 else if (decl_context
== TPARM
)
8650 template_parm_flag
= true, decl_context
= PARM
;
8652 if (initialized
> 1)
8653 funcdef_flag
= true;
8655 /* Look inside a declarator for the name being declared
8656 and get it as a string, for an error message. */
8657 for (id_declarator
= declarator
;
8659 id_declarator
= id_declarator
->declarator
)
8661 if (id_declarator
->kind
!= cdk_id
)
8662 innermost_code
= id_declarator
->kind
;
8664 switch (id_declarator
->kind
)
8667 if (id_declarator
->declarator
8668 && id_declarator
->declarator
->kind
== cdk_id
)
8670 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8671 if (sfk
== sfk_destructor
)
8678 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8679 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8682 if (qualifying_scope
)
8684 if (at_function_scope_p ())
8688 A declarator-id shall not be qualified except
8691 None of the cases are permitted in block
8693 if (qualifying_scope
== global_namespace
)
8694 error ("invalid use of qualified-name %<::%D%>",
8696 else if (TYPE_P (qualifying_scope
))
8697 error ("invalid use of qualified-name %<%T::%D%>",
8698 qualifying_scope
, decl
);
8700 error ("invalid use of qualified-name %<%D::%D%>",
8701 qualifying_scope
, decl
);
8702 return error_mark_node
;
8704 else if (TYPE_P (qualifying_scope
))
8706 ctype
= qualifying_scope
;
8707 if (!MAYBE_CLASS_TYPE_P (ctype
))
8709 error ("%q#T is not a class or a namespace", ctype
);
8712 else if (innermost_code
!= cdk_function
8713 && current_class_type
8714 && !uniquely_derived_from_p (ctype
,
8715 current_class_type
))
8717 error ("type %qT is not derived from type %qT",
8718 ctype
, current_class_type
);
8719 return error_mark_node
;
8722 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
8723 in_namespace
= qualifying_scope
;
8725 switch (TREE_CODE (decl
))
8731 if (innermost_code
!= cdk_function
)
8733 error ("declaration of %qD as non-function", decl
);
8734 return error_mark_node
;
8736 else if (!qualifying_scope
8737 && !(current_class_type
&& at_class_scope_p ()))
8739 error ("declaration of %qD as non-member", decl
);
8740 return error_mark_node
;
8743 type
= TREE_OPERAND (decl
, 0);
8745 type
= constructor_name (type
);
8746 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
8751 case TEMPLATE_ID_EXPR
:
8753 tree fns
= TREE_OPERAND (decl
, 0);
8756 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
8758 gcc_assert (is_overloaded_fn (dname
));
8759 dname
= DECL_NAME (get_first_fn (dname
));
8764 case IDENTIFIER_NODE
:
8765 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
8768 if (C_IS_RESERVED_WORD (dname
))
8770 error ("declarator-id missing; using reserved word %qD",
8772 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8774 else if (!IDENTIFIER_TYPENAME_P (dname
))
8775 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8778 gcc_assert (flags
== NO_SPECIAL
);
8779 flags
= TYPENAME_FLAG
;
8780 ctor_return_type
= TREE_TYPE (dname
);
8781 sfk
= sfk_conversion
;
8782 if (is_typename_at_global_scope (dname
))
8783 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8785 name
= "<invalid operator>";
8802 return error_mark_node
;
8807 if (id_declarator
->kind
== cdk_id
)
8813 The declarator in a function-definition shall have the form
8814 D1 ( parameter-declaration-clause) ... */
8815 if (funcdef_flag
&& innermost_code
!= cdk_function
)
8817 error ("function definition does not declare parameters");
8818 return error_mark_node
;
8821 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8822 && innermost_code
!= cdk_function
8823 && ! (ctype
&& !declspecs
->any_specifiers_p
))
8825 error ("declaration of %qD as non-function", dname
);
8826 return error_mark_node
;
8830 && TREE_CODE (dname
) == IDENTIFIER_NODE
8831 && UDLIT_OPER_P (dname
)
8832 && innermost_code
!= cdk_function
)
8834 error ("declaration of %qD as non-function", dname
);
8835 return error_mark_node
;
8838 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
8840 if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
8842 error ("declaration of %qD as %<typedef%>", dname
);
8843 return error_mark_node
;
8845 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8847 error ("declaration of %qD as parameter", dname
);
8848 return error_mark_node
;
8852 /* Anything declared one level down from the top level
8853 must be one of the parameters of a function
8854 (because the body is at least two levels down). */
8856 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8857 by not allowing C++ class definitions to specify their parameters
8858 with xdecls (must be spec.d in the parmlist).
8860 Since we now wait to push a class scope until we are sure that
8861 we are in a legitimate method context, we must set oldcname
8862 explicitly (since current_class_name is not yet alive).
8864 We also want to avoid calling this a PARM if it is in a namespace. */
8866 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
8868 cp_binding_level
*b
= current_binding_level
;
8869 current_binding_level
= b
->level_chain
;
8870 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8871 decl_context
= PARM
;
8872 current_binding_level
= b
;
8876 name
= decl_context
== PARM
? "parameter" : "type name";
8878 if (constexpr_p
&& decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
8880 error ("%<constexpr%> cannot appear in a typedef declaration");
8881 return error_mark_node
;
8884 /* If there were multiple types specified in the decl-specifier-seq,
8885 issue an error message. */
8886 if (declspecs
->multiple_types_p
)
8888 error ("two or more data types in declaration of %qs", name
);
8889 return error_mark_node
;
8892 if (declspecs
->conflicting_specifiers_p
)
8894 error ("conflicting specifiers in declaration of %qs", name
);
8895 return error_mark_node
;
8898 /* Extract the basic type from the decl-specifier-seq. */
8899 type
= declspecs
->type
;
8900 if (type
== error_mark_node
)
8903 type_was_error_mark_node
= true;
8905 /* If the entire declaration is itself tagged as deprecated then
8906 suppress reports of deprecated items. */
8907 if (type
&& TREE_DEPRECATED (type
)
8908 && deprecated_state
!= DEPRECATED_SUPPRESS
)
8909 warn_deprecated_use (type
, NULL_TREE
);
8910 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
8912 typedef_decl
= type
;
8913 type
= TREE_TYPE (typedef_decl
);
8914 if (TREE_DEPRECATED (type
)
8915 && DECL_ARTIFICIAL (typedef_decl
)
8916 && deprecated_state
!= DEPRECATED_SUPPRESS
)
8917 warn_deprecated_use (type
, NULL_TREE
);
8919 /* No type at all: default to `int', and set DEFAULTED_INT
8920 because it was not a user-defined typedef. */
8921 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
8923 /* These imply 'int'. */
8924 type
= integer_type_node
;
8928 explicit_int
= declspecs
->explicit_int_p
;
8929 explicit_char
= declspecs
->explicit_char_p
;
8932 /* See the code below that used this. */
8934 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
8936 typedef_type
= type
;
8939 if (sfk
!= sfk_conversion
)
8940 ctor_return_type
= ctype
;
8942 if (sfk
!= sfk_none
)
8943 type
= check_special_function_return_type (sfk
, type
,
8945 else if (type
== NULL_TREE
)
8951 /* We handle `main' specially here, because 'main () { }' is so
8952 common. With no options, it is allowed. With -Wreturn-type,
8953 it is a warning. It is only an error with -pedantic-errors. */
8954 is_main
= (funcdef_flag
8955 && dname
&& TREE_CODE (dname
) == IDENTIFIER_NODE
8956 && MAIN_NAME_P (dname
)
8957 && ctype
== NULL_TREE
8958 && in_namespace
== NULL_TREE
8959 && current_namespace
== global_namespace
);
8961 if (type_was_error_mark_node
)
8962 /* We've already issued an error, don't complain more. */;
8963 else if (in_system_header
|| flag_ms_extensions
)
8964 /* Allow it, sigh. */;
8966 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
8968 pedwarn (input_location
, OPT_Wpedantic
,
8969 "ISO C++ forbids declaration of %qs with no type", name
);
8971 warning (OPT_Wreturn_type
,
8972 "ISO C++ forbids declaration of %qs with no type", name
);
8974 type
= integer_type_node
;
8979 if (explicit_int128
)
8981 if (int128_integer_type_node
== NULL_TREE
)
8983 error ("%<__int128%> is not supported by this target");
8984 explicit_int128
= false;
8986 else if (pedantic
&& ! in_system_header
)
8987 pedwarn (input_location
, OPT_Wpedantic
,
8988 "ISO C++ does not support %<__int128%> for %qs", name
);
8991 /* Now process the modifiers that were specified
8992 and check for invalid combinations. */
8994 /* Long double is a special combination. */
8995 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
8998 type
= cp_build_qualified_type (long_double_type_node
,
8999 cp_type_quals (type
));
9002 /* Check all other uses of type modifiers. */
9004 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9008 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9009 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9010 else if (signed_p
&& unsigned_p
)
9011 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9012 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9013 error ("%<long long%> invalid for %qs", name
);
9014 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9015 error ("%<long%> invalid for %qs", name
);
9016 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9017 error ("%<short%> invalid for %qs", name
);
9018 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9019 error ("%<long%> or %<short%> invalid for %qs", name
);
9020 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_int128
)
9021 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9022 else if ((long_p
|| short_p
) && explicit_char
)
9023 error ("%<long%> or %<short%> specified with char for %qs", name
);
9024 else if (long_p
&& short_p
)
9025 error ("%<long%> and %<short%> specified together for %qs", name
);
9026 else if (type
== char16_type_node
|| type
== char32_type_node
)
9028 if (signed_p
|| unsigned_p
)
9029 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9030 else if (short_p
|| long_p
)
9031 error ("%<short%> or %<long%> invalid for %qs", name
);
9036 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_int128
&& pedantic
)
9038 pedwarn (input_location
, OPT_Wpedantic
,
9039 "long, short, signed or unsigned used invalidly for %qs",
9041 if (flag_pedantic_errors
)
9046 /* Discard the type modifiers if they are invalid. */
9057 /* Decide whether an integer type is signed or not.
9058 Optionally treat bitfields as signed by default. */
9062 It is implementation-defined whether a plain (neither
9063 explicitly signed or unsigned) char, short, int, or long
9064 bit-field is signed or unsigned.
9066 Naturally, we extend this to long long as well. Note that
9067 this does not include wchar_t. */
9068 || (bitfield
&& !flag_signed_bitfields
9070 /* A typedef for plain `int' without `signed' can be
9071 controlled just like plain `int', but a typedef for
9072 `signed int' cannot be so controlled. */
9074 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9075 && TREE_CODE (type
) == INTEGER_TYPE
9076 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9078 if (explicit_int128
)
9079 type
= int128_unsigned_type_node
;
9081 type
= long_long_unsigned_type_node
;
9083 type
= long_unsigned_type_node
;
9085 type
= short_unsigned_type_node
;
9086 else if (type
== char_type_node
)
9087 type
= unsigned_char_type_node
;
9088 else if (typedef_decl
)
9089 type
= unsigned_type_for (type
);
9091 type
= unsigned_type_node
;
9093 else if (signed_p
&& type
== char_type_node
)
9094 type
= signed_char_type_node
;
9095 else if (explicit_int128
)
9096 type
= int128_integer_type_node
;
9098 type
= long_long_integer_type_node
;
9100 type
= long_integer_type_node
;
9102 type
= short_integer_type_node
;
9104 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9106 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9107 error ("complex invalid for %qs", name
);
9108 /* If we just have "complex", it is equivalent to
9109 "complex double", but if any modifiers at all are specified it is
9110 the complex form of TYPE. E.g, "complex short" is
9111 "complex short int". */
9112 else if (defaulted_int
&& ! longlong
&& ! explicit_int128
9113 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
9114 type
= complex_double_type_node
;
9115 else if (type
== integer_type_node
)
9116 type
= complex_integer_type_node
;
9117 else if (type
== float_type_node
)
9118 type
= complex_float_type_node
;
9119 else if (type
== double_type_node
)
9120 type
= complex_double_type_node
;
9121 else if (type
== long_double_type_node
)
9122 type
= complex_long_double_type_node
;
9124 type
= build_complex_type (type
);
9127 type_quals
= TYPE_UNQUALIFIED
;
9128 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9129 type_quals
|= TYPE_QUAL_CONST
;
9130 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9131 type_quals
|= TYPE_QUAL_VOLATILE
;
9132 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9133 type_quals
|= TYPE_QUAL_RESTRICT
;
9134 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9135 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9138 /* If we're using the injected-class-name to form a compound type or a
9139 declaration, replace it with the underlying class so we don't get
9140 redundant typedefs in the debug output. But if we are returning the
9141 type unchanged, leave it alone so that it's available to
9142 maybe_get_template_decl_from_type_decl. */
9143 if (CLASS_TYPE_P (type
)
9144 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9145 && type
== TREE_TYPE (TYPE_NAME (type
))
9146 && (declarator
|| type_quals
))
9147 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9149 type_quals
|= cp_type_quals (type
);
9150 type
= cp_build_qualified_type_real
9151 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
9152 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9153 /* We might have ignored or rejected some of the qualifiers. */
9154 type_quals
= cp_type_quals (type
);
9157 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9158 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9159 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9161 storage_class
= declspecs
->storage_class
;
9162 if (storage_class
== sc_static
)
9163 staticp
= 1 + (decl_context
== FIELD
);
9165 if (virtualp
&& staticp
== 2)
9167 error ("member %qD cannot be declared both virtual and static", dname
);
9168 storage_class
= sc_none
;
9171 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9173 if (dependent_name
&& !friendp
)
9175 error ("%<%T::%D%> is not a valid declarator", ctype
, dependent_name
);
9176 return error_mark_node
;
9179 /* Issue errors about use of storage classes for parameters. */
9180 if (decl_context
== PARM
)
9182 if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
9184 error ("typedef declaration invalid in parameter declaration");
9185 return error_mark_node
;
9187 else if (template_parm_flag
&& storage_class
!= sc_none
)
9189 error ("storage class specified for template parameter %qs", name
);
9190 return error_mark_node
;
9192 else if (storage_class
== sc_static
9193 || storage_class
== sc_extern
9195 error ("storage class specifiers invalid in parameter declarations");
9197 /* Function parameters cannot be constexpr. If we saw one, moan
9198 and pretend it wasn't there. */
9201 error ("a parameter cannot be declared %<constexpr%>");
9206 /* Give error if `virtual' is used outside of class declaration. */
9208 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9210 error ("%<virtual%> outside class declaration");
9214 /* Static anonymous unions are dealt with here. */
9215 if (staticp
&& decl_context
== TYPENAME
9217 && ANON_AGGR_TYPE_P (declspecs
->type
))
9218 decl_context
= FIELD
;
9220 /* Warn about storage classes that are invalid for certain
9221 kinds of declarations (parameters, typenames, etc.). */
9224 && storage_class
!= sc_extern
9225 && storage_class
!= sc_static
)
9226 || decl_spec_seq_has_spec_p (declspecs
, ds_typedef
)))
9228 error ("multiple storage classes in declaration of %qs", name
);
9231 if (decl_context
!= NORMAL
9232 && ((storage_class
!= sc_none
9233 && storage_class
!= sc_mutable
)
9236 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9237 && (storage_class
== sc_register
9238 || storage_class
== sc_auto
))
9240 else if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
9242 else if (decl_context
== FIELD
9243 /* C++ allows static class elements. */
9244 && storage_class
== sc_static
)
9245 /* C++ also allows inlines and signed and unsigned elements,
9246 but in those cases we don't come in here. */
9250 if (decl_context
== FIELD
)
9251 error ("storage class specified for %qs", name
);
9254 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9255 error ("storage class specified for parameter %qs", name
);
9257 error ("storage class specified for typename");
9259 if (storage_class
== sc_register
9260 || storage_class
== sc_auto
9261 || storage_class
== sc_extern
9263 storage_class
= sc_none
;
9266 else if (storage_class
== sc_extern
&& funcdef_flag
9267 && ! toplevel_bindings_p ())
9268 error ("nested function %qs declared %<extern%>", name
);
9269 else if (toplevel_bindings_p ())
9271 if (storage_class
== sc_auto
)
9272 error ("top-level declaration of %qs specifies %<auto%>", name
);
9275 && storage_class
!= sc_extern
9276 && storage_class
!= sc_static
)
9278 if (declspecs
->gnu_thread_keyword_p
)
9279 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9280 "declared %<__thread%>", name
);
9282 /* When thread_local is applied to a variable of block scope the
9283 storage-class-specifier static is implied if it does not appear
9285 storage_class
= declspecs
->storage_class
= sc_static
;
9289 if (storage_class
&& friendp
)
9291 error ("storage class specifiers invalid in friend function declarations");
9292 storage_class
= sc_none
;
9297 unqualified_id
= NULL_TREE
;
9300 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9301 switch (TREE_CODE (unqualified_id
))
9304 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9305 if (TYPE_P (unqualified_id
))
9306 unqualified_id
= constructor_name (unqualified_id
);
9309 case IDENTIFIER_NODE
:
9310 case TEMPLATE_ID_EXPR
:
9318 if (declspecs
->std_attributes
)
9320 /* Apply the c++11 attributes to the type preceding them. */
9321 source_location saved_loc
= input_location
;
9322 input_location
= declspecs
->locations
[ds_std_attribute
];
9323 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9324 input_location
= saved_loc
;
9327 /* Determine the type of the entity declared by recurring on the
9329 for (; declarator
; declarator
= declarator
->declarator
)
9331 const cp_declarator
*inner_declarator
;
9334 if (type
== error_mark_node
)
9335 return error_mark_node
;
9337 attrs
= declarator
->attributes
;
9343 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9344 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9345 if (declarator
->kind
== cdk_function
)
9346 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9347 if (declarator
->kind
== cdk_array
)
9348 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9349 returned_attrs
= decl_attributes (&type
,
9350 chainon (returned_attrs
, attrs
),
9354 if (declarator
->kind
== cdk_id
)
9357 inner_declarator
= declarator
->declarator
;
9359 switch (declarator
->kind
)
9362 type
= create_array_type_for_decl (dname
, type
,
9363 declarator
->u
.array
.bounds
);
9364 if (declarator
->std_attributes
)
9367 The optional attribute-specifier-seq appertains to the
9369 returned_attrs
= chainon (returned_attrs
,
9370 declarator
->std_attributes
);
9378 /* Declaring a function type.
9379 Make sure we have a valid type for the function to return. */
9381 if (type_quals
!= TYPE_UNQUALIFIED
)
9383 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9384 warning (OPT_Wignored_qualifiers
,
9385 "type qualifiers ignored on function return type");
9386 /* We now know that the TYPE_QUALS don't apply to the
9387 decl, but to its return type. */
9388 type_quals
= TYPE_UNQUALIFIED
;
9390 errmsg
= targetm
.invalid_return_type (type
);
9394 type
= integer_type_node
;
9397 /* Error about some types functions can't return. */
9399 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9401 error ("%qs declared as function returning a function", name
);
9402 return error_mark_node
;
9404 if (TREE_CODE (type
) == ARRAY_TYPE
)
9406 error ("%qs declared as function returning an array", name
);
9407 return error_mark_node
;
9409 /* When decl_context == NORMAL we emit a better error message
9410 later in abstract_virtuals_error. */
9411 if (decl_context
== TYPENAME
&& ABSTRACT_CLASS_TYPE_P (type
))
9412 error ("%qs declared as function returning an abstract "
9413 "class type", name
);
9415 /* Pick up type qualifiers which should be applied to `this'. */
9416 memfn_quals
= declarator
->u
.function
.qualifiers
;
9417 /* Pick up virt-specifiers. */
9418 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9419 /* Pick up the exception specifications. */
9420 raises
= declarator
->u
.function
.exception_specification
;
9421 /* If the exception-specification is ill-formed, let's pretend
9422 there wasn't one. */
9423 if (raises
== error_mark_node
)
9426 /* Say it's a definition only for the CALL_EXPR
9427 closest to the identifier. */
9428 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9430 /* Handle a late-specified return type. */
9433 if (type_uses_auto (type
))
9435 if (!declarator
->u
.function
.late_return_type
)
9437 if (current_class_type
9438 && LAMBDA_TYPE_P (current_class_type
))
9439 /* OK for C++11 lambdas. */;
9440 else if (cxx_dialect
< cxx1y
)
9441 pedwarn (input_location
, 0, "%qs function uses "
9442 "%<auto%> type specifier without trailing "
9443 "return type", name
);
9445 else if (!is_auto (type
))
9447 error ("%qs function with trailing return type has"
9448 " %qT as its type rather than plain %<auto%>",
9450 return error_mark_node
;
9453 else if (declarator
->u
.function
.late_return_type
)
9455 if (cxx_dialect
< cxx0x
)
9456 /* Not using maybe_warn_cpp0x because this should
9457 always be an error. */
9458 error ("trailing return type only available with "
9459 "-std=c++11 or -std=gnu++11");
9461 error ("%qs function with trailing return type not "
9462 "declared with %<auto%> type specifier", name
);
9463 return error_mark_node
;
9466 type
= splice_late_return_type
9467 (type
, declarator
->u
.function
.late_return_type
);
9468 if (type
== error_mark_node
)
9469 return error_mark_node
;
9471 if (ctype
== NULL_TREE
9472 && decl_context
== FIELD
9474 && (friendp
== 0 || dname
== current_class_name
))
9475 ctype
= current_class_type
;
9477 if (ctype
&& (sfk
== sfk_constructor
9478 || sfk
== sfk_destructor
))
9480 /* We are within a class's scope. If our declarator name
9481 is the same as the class name, and we are defining
9482 a function, then it is a constructor/destructor, and
9483 therefore returns a void type. */
9485 /* ISO C++ 12.4/2. A destructor may not be declared
9486 const or volatile. A destructor may not be
9489 ISO C++ 12.1. A constructor may not be declared
9490 const or volatile. A constructor may not be
9491 virtual. A constructor may not be static. */
9493 error ((flags
== DTOR_FLAG
)
9494 ? G_("destructor cannot be static member function")
9495 : G_("constructor cannot be static member function"));
9498 error ((flags
== DTOR_FLAG
)
9499 ? G_("destructors may not be cv-qualified")
9500 : G_("constructors may not be cv-qualified"));
9501 memfn_quals
= TYPE_UNQUALIFIED
;
9504 if (decl_context
== FIELD
9505 && !member_function_or_else (ctype
,
9508 return error_mark_node
;
9510 if (flags
!= DTOR_FLAG
)
9512 /* It's a constructor. */
9517 permerror (input_location
, "constructors cannot be declared virtual");
9520 if (decl_context
== FIELD
9521 && sfk
!= sfk_constructor
)
9522 return error_mark_node
;
9524 if (decl_context
== FIELD
)
9530 error ("can%'t initialize friend function %qs", name
);
9533 /* Cannot be both friend and virtual. */
9534 error ("virtual functions cannot be friends");
9537 if (decl_context
== NORMAL
)
9538 error ("friend declaration not in class definition");
9539 if (current_function_decl
&& funcdef_flag
)
9540 error ("can%'t define friend function %qs in a local "
9544 else if (ctype
&& sfk
== sfk_conversion
)
9548 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9553 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9556 if (inner_declarator
9557 && inner_declarator
->kind
== cdk_id
9558 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9559 && arg_types
!= void_list_node
)
9561 error ("destructors may not have parameters");
9562 arg_types
= void_list_node
;
9566 type
= build_function_type (type
, arg_types
);
9567 if (declarator
->std_attributes
)
9570 The optional attribute-specifier-seq appertains to
9571 the function type. */
9572 decl_attributes (&type
, declarator
->std_attributes
,
9580 /* Filter out pointers-to-references and references-to-references.
9581 We can get these if a TYPE_DECL is used. */
9583 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9585 if (declarator
->kind
!= cdk_reference
)
9587 error ("cannot declare pointer to %q#T", type
);
9588 type
= TREE_TYPE (type
);
9591 /* In C++0x, we allow reference to reference declarations
9592 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9593 and template type arguments [14.3.1/4 temp.arg.type]. The
9594 check for direct reference to reference declarations, which
9595 are still forbidden, occurs below. Reasoning behind the change
9596 can be found in DR106, DR540, and the rvalue reference
9598 else if (cxx_dialect
== cxx98
)
9600 error ("cannot declare reference to %q#T", type
);
9601 type
= TREE_TYPE (type
);
9604 else if (VOID_TYPE_P (type
))
9606 if (declarator
->kind
== cdk_reference
)
9607 error ("cannot declare reference to %q#T", type
);
9608 else if (declarator
->kind
== cdk_ptrmem
)
9609 error ("cannot declare pointer to %q#T member", type
);
9612 /* We now know that the TYPE_QUALS don't apply to the decl,
9613 but to the target of the pointer. */
9614 type_quals
= TYPE_UNQUALIFIED
;
9616 if (declarator
->kind
== cdk_ptrmem
9617 && (TREE_CODE (type
) == FUNCTION_TYPE
9618 || (memfn_quals
&& TREE_CODE (type
) == METHOD_TYPE
)))
9620 memfn_quals
|= type_memfn_quals (type
);
9621 type
= build_memfn_type (type
,
9622 declarator
->u
.pointer
.class_type
,
9624 if (type
== error_mark_node
)
9625 return error_mark_node
;
9626 memfn_quals
= TYPE_UNQUALIFIED
;
9629 if (TREE_CODE (type
) == FUNCTION_TYPE
9630 && type_memfn_quals (type
) != TYPE_UNQUALIFIED
)
9631 error (declarator
->kind
== cdk_reference
9632 ? G_("cannot declare reference to qualified function type %qT")
9633 : G_("cannot declare pointer to qualified function type %qT"),
9636 /* When the pointed-to type involves components of variable size,
9637 care must be taken to ensure that the size evaluation code is
9638 emitted early enough to dominate all the possible later uses
9639 and late enough for the variables on which it depends to have
9642 This is expected to happen automatically when the pointed-to
9643 type has a name/declaration of it's own, but special attention
9644 is required if the type is anonymous.
9646 We handle the NORMAL and FIELD contexts here by inserting a
9647 dummy statement that just evaluates the size at a safe point
9648 and ensures it is not deferred until e.g. within a deeper
9649 conditional context (c++/43555).
9651 We expect nothing to be needed here for PARM or TYPENAME.
9652 Evaluating the size at this point for TYPENAME would
9653 actually be incorrect, as we might be in the middle of an
9654 expression with side effects on the pointed-to type size
9655 "arguments" prior to the pointer declaration point and the
9656 size evaluation could end up prior to the side effects. */
9658 if (!TYPE_NAME (type
)
9659 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9660 && at_function_scope_p ()
9661 && variably_modified_type_p (type
, NULL_TREE
))
9663 /* First break out any side-effects. */
9664 stabilize_vla_size (TYPE_SIZE (type
));
9665 /* And then force evaluation of the SAVE_EXPR. */
9666 finish_expr_stmt (TYPE_SIZE (type
));
9669 if (declarator
->kind
== cdk_reference
)
9671 /* In C++0x, the type we are creating a reference to might be
9672 a typedef which is itself a reference type. In that case,
9673 we follow the reference collapsing rules in
9674 [7.1.3/8 dcl.typedef] to create the final reference type:
9676 "If a typedef TD names a type that is a reference to a type
9677 T, an attempt to create the type 'lvalue reference to cv TD'
9678 creates the type 'lvalue reference to T,' while an attempt
9679 to create the type "rvalue reference to cv TD' creates the
9682 if (VOID_TYPE_P (type
))
9683 /* We already gave an error. */;
9684 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9686 if (declarator
->u
.reference
.rvalue_ref
)
9687 /* Leave type alone. */;
9689 type
= cp_build_reference_type (TREE_TYPE (type
), false);
9692 type
= cp_build_reference_type
9693 (type
, declarator
->u
.reference
.rvalue_ref
);
9695 /* In C++0x, we need this check for direct reference to
9696 reference declarations, which are forbidden by
9697 [8.3.2/5 dcl.ref]. Reference to reference declarations
9698 are only allowed indirectly through typedefs and template
9699 type arguments. Example:
9701 void foo(int & &); // invalid ref-to-ref decl
9703 typedef int & int_ref;
9704 void foo(int_ref &); // valid ref-to-ref decl
9706 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
9707 error ("cannot declare reference to %q#T, which is not "
9708 "a typedef or a template type argument", type
);
9710 else if (TREE_CODE (type
) == METHOD_TYPE
)
9711 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9712 else if (declarator
->kind
== cdk_ptrmem
)
9714 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
9716 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
9717 /* We will already have complained. */
9718 type
= error_mark_node
;
9720 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
9724 type
= build_pointer_type (type
);
9726 /* Process a list of type modifier keywords (such as
9727 const or volatile) that were given inside the `*' or `&'. */
9729 if (declarator
->u
.pointer
.qualifiers
)
9732 = cp_build_qualified_type (type
,
9733 declarator
->u
.pointer
.qualifiers
);
9734 type_quals
= cp_type_quals (type
);
9737 /* Apply C++11 attributes to the pointer, and not to the
9738 type pointed to. This is unlike what is done for GNU
9739 attributes above. It is to comply with [dcl.ptr]/1:
9741 [the optional attribute-specifier-seq (7.6.1) appertains
9742 to the pointer and not to the object pointed to]. */
9743 if (declarator
->std_attributes
)
9744 decl_attributes (&type
, declarator
->std_attributes
,
9758 /* We need to stabilize side-effects in VLA sizes for regular array
9759 declarations too, not just pointers to arrays. */
9760 if (type
!= error_mark_node
&& !TYPE_NAME (type
)
9761 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9762 && at_function_scope_p ()
9763 && variably_modified_type_p (type
, NULL_TREE
))
9764 stabilize_vla_size (TYPE_SIZE (type
));
9766 /* A `constexpr' specifier used in an object declaration declares
9767 the object as `const'. */
9768 if (constexpr_p
&& innermost_code
!= cdk_function
)
9770 if (type_quals
& TYPE_QUAL_VOLATILE
)
9771 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9772 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9774 type_quals
|= TYPE_QUAL_CONST
;
9775 type
= cp_build_qualified_type (type
, type_quals
);
9779 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
9780 && TREE_CODE (type
) != FUNCTION_TYPE
9781 && TREE_CODE (type
) != METHOD_TYPE
)
9783 error ("template-id %qD used as a declarator",
9785 unqualified_id
= dname
;
9788 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9789 qualified with a class-name, turn it into a METHOD_TYPE, unless
9790 we know that the function is static. We take advantage of this
9791 opportunity to do other processing that pertains to entities
9792 explicitly declared to be class members. Note that if DECLARATOR
9793 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9794 would not have exited the loop above. */
9796 && declarator
->u
.id
.qualifying_scope
9797 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
9799 ctype
= declarator
->u
.id
.qualifying_scope
;
9800 ctype
= TYPE_MAIN_VARIANT (ctype
);
9801 template_count
= num_template_headers_for_class (ctype
);
9803 if (ctype
== current_class_type
)
9807 permerror (input_location
, "member functions are implicitly friends of their class");
9811 permerror (declarator
->id_loc
,
9812 "extra qualification %<%T::%> on member %qs",
9815 else if (/* If the qualifying type is already complete, then we
9816 can skip the following checks. */
9817 !COMPLETE_TYPE_P (ctype
)
9818 && (/* If the function is being defined, then
9819 qualifying type must certainly be complete. */
9821 /* A friend declaration of "T::f" is OK, even if
9822 "T" is a template parameter. But, if this
9823 function is not a friend, the qualifying type
9825 || (!friendp
&& !CLASS_TYPE_P (ctype
))
9826 /* For a declaration, the type need not be
9827 complete, if either it is dependent (since there
9828 is no meaningful definition of complete in that
9829 case) or the qualifying class is currently being
9831 || !(dependent_type_p (ctype
)
9832 || currently_open_class (ctype
)))
9833 /* Check that the qualifying type is complete. */
9834 && !complete_type_or_else (ctype
, NULL_TREE
))
9835 return error_mark_node
;
9836 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9838 if (current_class_type
9839 && (!friendp
|| funcdef_flag
))
9842 ? G_("cannot define member function %<%T::%s%> "
9844 : G_("cannot declare member function %<%T::%s%> "
9846 ctype
, name
, current_class_type
);
9847 return error_mark_node
;
9850 else if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
)
9851 && current_class_type
)
9853 error ("cannot declare member %<%T::%s%> within %qT",
9854 ctype
, name
, current_class_type
);
9855 return error_mark_node
;
9859 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
9860 ctype
= current_class_type
;
9862 /* Now TYPE has the actual type. */
9867 *attrlist
= chainon (returned_attrs
, *attrlist
);
9869 attrlist
= &returned_attrs
;
9873 && declarator
->kind
== cdk_id
9874 && declarator
->std_attributes
)
9875 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
9876 a declarator-id appertains to the entity that is declared. */
9877 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
9879 /* Handle parameter packs. */
9880 if (parameter_pack_p
)
9882 if (decl_context
== PARM
)
9883 /* Turn the type into a pack expansion.*/
9884 type
= make_pack_expansion (type
);
9886 error ("non-parameter %qs cannot be a parameter pack", name
);
9889 /* Did array size calculations overflow or does the array cover more
9890 than half of the address-space? */
9891 if (TREE_CODE (type
) == ARRAY_TYPE
9892 && COMPLETE_TYPE_P (type
)
9893 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
9894 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
9896 error ("size of array %qs is too large", name
);
9897 /* If we proceed with the array type as it is, we'll eventually
9898 crash in tree_low_cst(). */
9899 type
= error_mark_node
;
9902 if ((decl_context
== FIELD
|| decl_context
== PARM
)
9903 && !processing_template_decl
9904 && variably_modified_type_p (type
, NULL_TREE
))
9906 if (decl_context
== FIELD
)
9907 error ("data member may not have variably modified type %qT", type
);
9909 error ("parameter may not have variably modified type %qT", type
);
9910 type
= error_mark_node
;
9913 if (explicitp
== 1 || (explicitp
&& friendp
))
9915 /* [dcl.fct.spec] The explicit specifier shall only be used in
9916 declarations of constructors within a class definition. */
9917 error ("only declarations of constructors can be %<explicit%>");
9921 if (storage_class
== sc_mutable
)
9923 if (decl_context
!= FIELD
|| friendp
)
9925 error ("non-member %qs cannot be declared %<mutable%>", name
);
9926 storage_class
= sc_none
;
9928 else if (decl_context
== TYPENAME
9929 || decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
9931 error ("non-object member %qs cannot be declared %<mutable%>", name
);
9932 storage_class
= sc_none
;
9934 else if (TREE_CODE (type
) == FUNCTION_TYPE
9935 || TREE_CODE (type
) == METHOD_TYPE
)
9937 error ("function %qs cannot be declared %<mutable%>", name
);
9938 storage_class
= sc_none
;
9942 error ("static %qs cannot be declared %<mutable%>", name
);
9943 storage_class
= sc_none
;
9945 else if (type_quals
& TYPE_QUAL_CONST
)
9947 error ("const %qs cannot be declared %<mutable%>", name
);
9948 storage_class
= sc_none
;
9950 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9952 permerror (input_location
, "reference %qs cannot be declared "
9953 "%<mutable%>", name
);
9954 storage_class
= sc_none
;
9958 /* If this is declaring a typedef name, return a TYPE_DECL. */
9959 if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
) && decl_context
!= TYPENAME
)
9963 /* Note that the grammar rejects storage classes
9964 in typenames, fields or parameters. */
9965 if (current_lang_name
== lang_name_java
)
9966 TYPE_FOR_JAVA (type
) = 1;
9968 /* This declaration:
9970 typedef void f(int) const;
9972 declares a function type which is not a member of any
9973 particular class, but which is cv-qualified; for
9974 example "f S::*" declares a pointer to a const-qualified
9975 member function of S. We record the cv-qualification in the
9977 if (memfn_quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
9979 type
= apply_memfn_quals (type
, memfn_quals
);
9981 /* We have now dealt with these qualifiers. */
9982 memfn_quals
= TYPE_UNQUALIFIED
;
9985 if (type_uses_auto (type
))
9987 error ("typedef declared %<auto%>");
9988 type
= error_mark_node
;
9991 if (decl_context
== FIELD
)
9992 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
9994 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
9995 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
9996 error_at (DECL_SOURCE_LOCATION (decl
),
9997 "typedef name may not be a nested-name-specifier");
9998 TREE_TYPE (decl
) = error_mark_node
;
10001 if (decl_context
!= FIELD
)
10003 if (!current_function_decl
)
10004 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10005 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10006 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10007 (current_function_decl
)))
10008 /* The TYPE_DECL is "abstract" because there will be
10009 clones of this constructor/destructor, and there will
10010 be copies of this TYPE_DECL generated in those
10012 DECL_ABSTRACT (decl
) = 1;
10014 else if (current_class_type
10015 && constructor_name_p (unqualified_id
, current_class_type
))
10016 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10017 "as enclosing class",
10020 /* If the user declares "typedef struct {...} foo" then the
10021 struct will have an anonymous name. Fill that name in now.
10022 Nothing can refer to it, so nothing needs know about the name
10024 if (type
!= error_mark_node
10026 && TYPE_NAME (type
)
10027 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10028 && TYPE_ANONYMOUS_P (type
)
10029 && declspecs
->type_definition_p
10030 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10034 /* Replace the anonymous name with the real name everywhere. */
10035 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10037 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10038 /* We do not rename the debug info representing the
10039 anonymous tagged type because the standard says in
10040 [dcl.typedef] that the naming applies only for
10041 linkage purposes. */
10042 /*debug_hooks->set_name (t, decl);*/
10043 TYPE_NAME (t
) = decl
;
10046 if (TYPE_LANG_SPECIFIC (type
))
10047 TYPE_WAS_ANONYMOUS (type
) = 1;
10049 /* If this is a typedef within a template class, the nested
10050 type is a (non-primary) template. The name for the
10051 template needs updating as well. */
10052 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10053 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10054 = TYPE_IDENTIFIER (type
);
10056 /* Adjust linkage now that we aren't anonymous anymore. */
10057 set_linkage_according_to_type (type
, TYPE_MAIN_DECL (type
));
10058 determine_visibility (TYPE_MAIN_DECL (type
));
10060 /* FIXME remangle member functions; member functions of a
10061 type with external linkage have external linkage. */
10065 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10066 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10068 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10069 memfn_quals
!= TYPE_UNQUALIFIED
,
10070 inlinep
, friendp
, raises
!= NULL_TREE
);
10072 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10073 /* Acknowledge that this was written:
10074 `using analias = atype;'. */
10075 TYPE_DECL_ALIAS_P (decl
) = 1;
10080 /* Detect the case of an array type of unspecified size
10081 which came, as such, direct from a typedef name.
10082 We must copy the type, so that the array's domain can be
10083 individually set by the object's initializer. */
10085 if (type
&& typedef_type
10086 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10087 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10088 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10090 /* Detect where we're using a typedef of function type to declare a
10091 function. PARMS will not be set, so we must create it now. */
10093 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10095 tree decls
= NULL_TREE
;
10098 for (args
= TYPE_ARG_TYPES (type
);
10099 args
&& args
!= void_list_node
;
10100 args
= TREE_CHAIN (args
))
10102 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10104 DECL_CHAIN (decl
) = decls
;
10108 parms
= nreverse (decls
);
10110 if (decl_context
!= TYPENAME
)
10112 /* A cv-qualifier-seq shall only be part of the function type
10113 for a non-static member function. [8.3.5/4 dcl.fct] */
10114 if (type_memfn_quals (type
) != TYPE_UNQUALIFIED
10115 && (current_class_type
== NULL_TREE
|| staticp
) )
10118 ? G_("qualified function types cannot be used to "
10119 "declare static member functions")
10120 : G_("qualified function types cannot be used to "
10121 "declare free functions"));
10122 type
= TYPE_MAIN_VARIANT (type
);
10125 /* The qualifiers on the function type become the qualifiers on
10126 the non-static member function. */
10127 memfn_quals
|= type_memfn_quals (type
);
10128 type_quals
= TYPE_UNQUALIFIED
;
10132 /* If this is a type name (such as, in a cast or sizeof),
10133 compute the type and return it now. */
10135 if (decl_context
== TYPENAME
)
10137 /* Note that the grammar rejects storage classes
10138 in typenames, fields or parameters. */
10139 if (type_quals
!= TYPE_UNQUALIFIED
)
10140 type_quals
= TYPE_UNQUALIFIED
;
10142 /* Special case: "friend class foo" looks like a TYPENAME context. */
10145 if (type_quals
!= TYPE_UNQUALIFIED
)
10147 error ("type qualifiers specified for friend class declaration");
10148 type_quals
= TYPE_UNQUALIFIED
;
10152 error ("%<inline%> specified for friend class declaration");
10158 /* Don't allow friend declaration without a class-key. */
10159 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10160 permerror (input_location
, "template parameters cannot be friends");
10161 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10162 permerror (input_location
, "friend declaration requires class-key, "
10163 "i.e. %<friend class %T::%D%>",
10164 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10166 permerror (input_location
, "friend declaration requires class-key, "
10167 "i.e. %<friend %#T%>",
10171 /* Only try to do this stuff if we didn't already give up. */
10172 if (type
!= integer_type_node
)
10174 /* A friendly class? */
10175 if (current_class_type
)
10176 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10177 /*complain=*/true);
10179 error ("trying to make class %qT a friend of global scope",
10182 type
= void_type_node
;
10185 else if (memfn_quals
)
10187 if (ctype
== NULL_TREE
10188 && TREE_CODE (type
) == METHOD_TYPE
)
10189 ctype
= TYPE_METHOD_BASETYPE (type
);
10192 type
= build_memfn_type (type
, ctype
, memfn_quals
);
10193 /* Core issue #547: need to allow this in template type args. */
10194 else if (template_type_arg
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10195 type
= apply_memfn_quals (type
, memfn_quals
);
10197 error ("invalid qualifiers on non-member function type");
10202 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10203 && decl_context
!= CATCHPARM
10204 && TREE_CODE (type
) != UNION_TYPE
10207 error ("abstract declarator %qT used as declaration", type
);
10208 return error_mark_node
;
10211 /* Only functions may be declared using an operator-function-id. */
10213 && IDENTIFIER_OPNAME_P (unqualified_id
)
10214 && TREE_CODE (type
) != FUNCTION_TYPE
10215 && TREE_CODE (type
) != METHOD_TYPE
)
10217 error ("declaration of %qD as non-function", unqualified_id
);
10218 return error_mark_node
;
10221 /* We don't check parameter types here because we can emit a better
10222 error message later. */
10223 if (decl_context
!= PARM
)
10225 type
= check_var_type (unqualified_id
, type
);
10226 if (type
== error_mark_node
)
10227 return error_mark_node
;
10230 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10231 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10233 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10235 if (ctype
|| in_namespace
)
10236 error ("cannot use %<::%> in parameter declaration");
10238 if (type_uses_auto (type
))
10240 error ("parameter declared %<auto%>");
10241 type
= error_mark_node
;
10244 /* A parameter declared as an array of T is really a pointer to T.
10245 One declared as a function is really a pointer to a function.
10246 One declared as a member is really a pointer to member. */
10248 if (TREE_CODE (type
) == ARRAY_TYPE
)
10250 /* Transfer const-ness of array into that of type pointed to. */
10251 type
= build_pointer_type (TREE_TYPE (type
));
10252 type_quals
= TYPE_UNQUALIFIED
;
10254 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10255 type
= build_pointer_type (type
);
10258 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10259 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10261 cp_cv_quals real_quals
= memfn_quals
;
10262 if (constexpr_p
&& sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10263 real_quals
|= TYPE_QUAL_CONST
;
10264 type
= build_memfn_type (type
, ctype
, real_quals
);
10270 if (decl_context
== PARM
)
10272 decl
= cp_build_parm_decl (unqualified_id
, type
);
10274 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10275 memfn_quals
!= TYPE_UNQUALIFIED
,
10276 inlinep
, friendp
, raises
!= NULL_TREE
);
10278 else if (decl_context
== FIELD
)
10280 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10281 && type_uses_auto (type
))
10283 error ("non-static data member declared %<auto%>");
10284 type
= error_mark_node
;
10287 /* The C99 flexible array extension. */
10288 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10289 && TYPE_DOMAIN (type
) == NULL_TREE
)
10291 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10292 tf_warning_or_error
);
10293 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10296 if (type
== error_mark_node
)
10298 /* Happens when declaring arrays of sizes which
10299 are error_mark_node, for example. */
10302 else if (in_namespace
&& !friendp
)
10304 /* Something like struct S { int N::j; }; */
10305 error ("invalid use of %<::%>");
10306 return error_mark_node
;
10308 else if (TREE_CODE (type
) == FUNCTION_TYPE
10309 || TREE_CODE (type
) == METHOD_TYPE
)
10312 tree function_context
;
10316 /* This should never happen in pure C++ (the check
10317 could be an assert). It could happen in
10318 Objective-C++ if someone writes invalid code that
10319 uses a function declaration for an instance
10320 variable or property (instance variables and
10321 properties are parsed as FIELD_DECLs, but they are
10322 part of an Objective-C class, not a C++ class).
10323 That code is invalid and is caught by this
10327 error ("declaration of function %qD in invalid context",
10329 return error_mark_node
;
10332 /* ``A union may [ ... ] not [ have ] virtual functions.''
10334 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10336 error ("function %qD declared virtual inside a union",
10338 return error_mark_node
;
10341 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10345 error ("%qD cannot be declared virtual, since it "
10346 "is always static",
10353 /* Check that the name used for a destructor makes sense. */
10354 if (sfk
== sfk_destructor
)
10356 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10360 gcc_assert (friendp
);
10361 error ("expected qualified name in friend declaration "
10362 "for destructor %qD", uqname
);
10363 return error_mark_node
;
10366 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10368 error ("declaration of %qD as member of %qT",
10370 return error_mark_node
;
10374 error ("a destructor cannot be %<constexpr%>");
10375 return error_mark_node
;
10378 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10380 error ("expected qualified name in friend declaration "
10381 "for constructor %qD",
10382 id_declarator
->u
.id
.unqualified_name
);
10383 return error_mark_node
;
10386 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10387 function_context
= (ctype
!= NULL_TREE
) ?
10388 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10389 publicp
= (! friendp
|| ! staticp
)
10390 && function_context
== NULL_TREE
;
10391 decl
= grokfndecl (ctype
, type
,
10392 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10393 ? unqualified_id
: dname
,
10396 virtualp
, flags
, memfn_quals
, raises
,
10397 friendp
? -1 : 0, friendp
, publicp
,
10398 inlinep
| (2 * constexpr_p
),
10400 funcdef_flag
, template_count
, in_namespace
,
10401 attrlist
, declarator
->id_loc
);
10402 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10403 if (decl
== NULL_TREE
)
10404 return error_mark_node
;
10406 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10407 /* The decl and setting of decl_attr is also turned off. */
10408 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10411 /* [class.conv.ctor]
10413 A constructor declared without the function-specifier
10414 explicit that can be called with a single parameter
10415 specifies a conversion from the type of its first
10416 parameter to the type of its class. Such a constructor
10417 is called a converting constructor. */
10418 if (explicitp
== 2)
10419 DECL_NONCONVERTING_P (decl
) = 1;
10421 else if (!staticp
&& !dependent_type_p (type
)
10422 && !COMPLETE_TYPE_P (complete_type (type
))
10423 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10425 if (unqualified_id
)
10426 error ("field %qD has incomplete type", unqualified_id
);
10428 error ("name %qT has incomplete type", type
);
10430 /* If we're instantiating a template, tell them which
10431 instantiation made the field's type be incomplete. */
10432 if (current_class_type
10433 && TYPE_NAME (current_class_type
)
10434 && IDENTIFIER_TEMPLATE (current_class_name
)
10436 && declspecs
->type
== type
)
10437 error (" in instantiation of template %qT",
10438 current_class_type
);
10440 return error_mark_node
;
10446 error ("%qE is neither function nor member function; "
10447 "cannot be declared friend", unqualified_id
);
10455 /* Friends are treated specially. */
10456 if (ctype
== current_class_type
)
10457 ; /* We already issued a permerror. */
10458 else if (decl
&& DECL_NAME (decl
))
10460 if (template_class_depth (current_class_type
) == 0)
10462 decl
= check_explicit_specialization
10463 (unqualified_id
, decl
, template_count
,
10464 2 * funcdef_flag
+ 4);
10465 if (decl
== error_mark_node
)
10466 return error_mark_node
;
10469 decl
= do_friend (ctype
, unqualified_id
, decl
,
10475 return error_mark_node
;
10478 /* Structure field. It may not be a function, except for C++. */
10480 if (decl
== NULL_TREE
)
10484 /* C++ allows static class members. All other work
10485 for this is done by grokfield. */
10486 decl
= build_lang_decl_loc (declarator
->id_loc
,
10487 VAR_DECL
, unqualified_id
, type
);
10488 set_linkage_for_static_data_member (decl
);
10489 /* Even if there is an in-class initialization, DECL
10490 is considered undefined until an out-of-class
10491 definition is provided. */
10492 DECL_EXTERNAL (decl
) = 1;
10496 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
10497 if (declspecs
->gnu_thread_keyword_p
)
10498 DECL_GNU_TLS_P (decl
) = true;
10501 if (constexpr_p
&& !initialized
)
10503 error ("constexpr static data member %qD must have an "
10504 "initializer", decl
);
10505 constexpr_p
= false;
10512 error ("non-static data member %qE declared %<constexpr%>",
10514 constexpr_p
= false;
10516 decl
= build_decl (input_location
,
10517 FIELD_DECL
, unqualified_id
, type
);
10518 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10519 if (bitfield
&& !unqualified_id
)
10520 TREE_NO_WARNING (decl
) = 1;
10522 if (storage_class
== sc_mutable
)
10524 DECL_MUTABLE_P (decl
) = 1;
10525 storage_class
= sc_none
;
10530 /* An attempt is being made to initialize a non-static
10531 member. This is new in C++11. */
10532 maybe_warn_cpp0x (CPP0X_NSDMI
);
10534 /* If this has been parsed with static storage class, but
10535 errors forced staticp to be cleared, ensure NSDMI is
10537 if (declspecs
->storage_class
== sc_static
)
10538 DECL_INITIAL (decl
) = error_mark_node
;
10542 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10543 memfn_quals
!= TYPE_UNQUALIFIED
,
10544 inlinep
, friendp
, raises
!= NULL_TREE
);
10547 else if (TREE_CODE (type
) == FUNCTION_TYPE
10548 || TREE_CODE (type
) == METHOD_TYPE
)
10550 tree original_name
;
10553 if (!unqualified_id
)
10554 return error_mark_node
;
10556 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10557 original_name
= dname
;
10559 original_name
= unqualified_id
;
10561 if (storage_class
== sc_auto
)
10562 error ("storage class %<auto%> invalid for function %qs", name
);
10563 else if (storage_class
== sc_register
)
10564 error ("storage class %<register%> invalid for function %qs", name
);
10567 if (declspecs
->gnu_thread_keyword_p
)
10568 error ("storage class %<__thread%> invalid for function %qs",
10571 error ("storage class %<thread_local%> invalid for function %qs",
10575 if (virt_specifiers
)
10576 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10577 /* Function declaration not at top level.
10578 Storage classes other than `extern' are not allowed
10579 and `extern' makes no difference. */
10580 if (! toplevel_bindings_p ()
10581 && (storage_class
== sc_static
10582 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10585 if (storage_class
== sc_static
)
10586 pedwarn (input_location
, OPT_Wpedantic
,
10587 "%<static%> specified invalid for function %qs "
10588 "declared out of global scope", name
);
10590 pedwarn (input_location
, OPT_Wpedantic
,
10591 "%<inline%> specifier invalid for function %qs "
10592 "declared out of global scope", name
);
10595 if (ctype
== NULL_TREE
)
10599 error ("virtual non-class function %qs", name
);
10602 else if (sfk
== sfk_constructor
10603 || sfk
== sfk_destructor
)
10605 error (funcdef_flag
10606 ? G_("%qs defined in a non-class scope")
10607 : G_("%qs declared in a non-class scope"), name
);
10612 /* Record presence of `static'. */
10613 publicp
= (ctype
!= NULL_TREE
10614 || storage_class
== sc_extern
10615 || storage_class
!= sc_static
);
10617 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10618 virtualp
, flags
, memfn_quals
, raises
,
10620 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10622 template_count
, in_namespace
, attrlist
,
10623 declarator
->id_loc
);
10624 if (decl
== NULL_TREE
)
10625 return error_mark_node
;
10629 int invalid_static
= 0;
10631 /* Don't allow a static member function in a class, and forbid
10632 declaring main to be static. */
10633 if (TREE_CODE (type
) == METHOD_TYPE
)
10635 permerror (input_location
, "cannot declare member function %qD to have "
10636 "static linkage", decl
);
10637 invalid_static
= 1;
10639 else if (current_function_decl
)
10641 /* FIXME need arm citation */
10642 error ("cannot declare static function inside another function");
10643 invalid_static
= 1;
10646 if (invalid_static
)
10649 storage_class
= sc_none
;
10655 /* It's a variable. */
10657 /* An uninitialized decl with `extern' is a reference. */
10658 decl
= grokvardecl (type
, unqualified_id
,
10661 (type_quals
& TYPE_QUAL_CONST
) != 0,
10662 ctype
? ctype
: in_namespace
);
10663 bad_specifiers (decl
, BSP_VAR
, virtualp
,
10664 memfn_quals
!= TYPE_UNQUALIFIED
,
10665 inlinep
, friendp
, raises
!= NULL_TREE
);
10669 DECL_CONTEXT (decl
) = ctype
;
10672 permerror (input_location
, "%<static%> may not be used when defining "
10673 "(as opposed to declaring) a static data member");
10675 storage_class
= sc_none
;
10677 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
10679 error ("static member %qD declared %<register%>", decl
);
10680 storage_class
= sc_none
;
10682 if (storage_class
== sc_extern
&& pedantic
)
10684 pedwarn (input_location
, OPT_Wpedantic
,
10685 "cannot explicitly declare member %q#D to have "
10686 "extern linkage", decl
);
10687 storage_class
= sc_none
;
10690 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
10692 error ("declaration of constexpr variable %qD is not a definition",
10694 constexpr_p
= false;
10698 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
10700 if (toplevel_bindings_p ())
10702 /* It's common practice (and completely valid) to have a const
10703 be initialized and declared extern. */
10704 if (!(type_quals
& TYPE_QUAL_CONST
))
10705 warning (0, "%qs initialized and declared %<extern%>", name
);
10709 error ("%qs has both %<extern%> and initializer", name
);
10710 return error_mark_node
;
10714 /* Record `register' declaration for warnings on &
10715 and in case doing stupid register allocation. */
10717 if (storage_class
== sc_register
)
10718 DECL_REGISTER (decl
) = 1;
10719 else if (storage_class
== sc_extern
)
10720 DECL_THIS_EXTERN (decl
) = 1;
10721 else if (storage_class
== sc_static
)
10722 DECL_THIS_STATIC (decl
) = 1;
10724 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10725 if (constexpr_p
&& TREE_CODE (decl
) == VAR_DECL
)
10726 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
10728 /* Record constancy and volatility on the DECL itself . There's
10729 no need to do this when processing a template; we'll do this
10730 for the instantiated declaration based on the type of DECL. */
10731 if (!processing_template_decl
)
10732 cp_apply_type_quals_to_decl (type_quals
, decl
);
10738 /* Subroutine of start_function. Ensure that each of the parameter
10739 types (as listed in PARMS) is complete, as is required for a
10740 function definition. */
10743 require_complete_types_for_parms (tree parms
)
10745 for (; parms
; parms
= DECL_CHAIN (parms
))
10747 if (dependent_type_p (TREE_TYPE (parms
)))
10749 if (!VOID_TYPE_P (TREE_TYPE (parms
))
10750 && complete_type_or_else (TREE_TYPE (parms
), parms
))
10752 relayout_decl (parms
);
10753 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
10756 /* grokparms or complete_type_or_else will have already issued
10758 TREE_TYPE (parms
) = error_mark_node
;
10762 /* Returns nonzero if T is a local variable. */
10765 local_variable_p (const_tree t
)
10767 if ((TREE_CODE (t
) == VAR_DECL
10768 /* A VAR_DECL with a context that is a _TYPE is a static data
10770 && !TYPE_P (CP_DECL_CONTEXT (t
))
10771 /* Any other non-local variable must be at namespace scope. */
10772 && !DECL_NAMESPACE_SCOPE_P (t
))
10773 || (TREE_CODE (t
) == PARM_DECL
))
10779 /* Like local_variable_p, but suitable for use as a tree-walking
10783 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
10786 /* Check DECL_NAME to avoid including temporaries. We don't check
10787 DECL_ARTIFICIAL because we do want to complain about 'this'. */
10788 if (local_variable_p (*tp
) && DECL_NAME (*tp
))
10790 else if (TYPE_P (*tp
))
10791 *walk_subtrees
= 0;
10796 /* Check that ARG, which is a default-argument expression for a
10797 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10798 something goes wrong. DECL may also be a _TYPE node, rather than a
10799 DECL, if there is no DECL available. */
10802 check_default_argument (tree decl
, tree arg
)
10807 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10808 /* We get a DEFAULT_ARG when looking at an in-class declaration
10809 with a default argument. Ignore the argument for now; we'll
10810 deal with it after the class is complete. */
10819 decl_type
= TREE_TYPE (decl
);
10821 if (arg
== error_mark_node
10822 || decl
== error_mark_node
10823 || TREE_TYPE (arg
) == error_mark_node
10824 || decl_type
== error_mark_node
)
10825 /* Something already went wrong. There's no need to check
10827 return error_mark_node
;
10829 /* [dcl.fct.default]
10831 A default argument expression is implicitly converted to the
10833 ++cp_unevaluated_operand
;
10834 perform_implicit_conversion_flags (decl_type
, arg
, tf_warning_or_error
,
10836 --cp_unevaluated_operand
;
10838 if (warn_zero_as_null_pointer_constant
10839 && c_inhibit_evaluation_warnings
== 0
10840 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
10841 && null_ptr_cst_p (arg
)
10842 && !NULLPTR_TYPE_P (TREE_TYPE (arg
)))
10844 warning (OPT_Wzero_as_null_pointer_constant
,
10845 "zero as null pointer constant");
10846 return nullptr_node
;
10849 /* [dcl.fct.default]
10851 Local variables shall not be used in default argument
10854 The keyword `this' shall not be used in a default argument of a
10855 member function. */
10856 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
10859 if (DECL_NAME (var
) == this_identifier
)
10860 permerror (input_location
, "default argument %qE uses %qD", arg
, var
);
10862 error ("default argument %qE uses local variable %qD", arg
, var
);
10863 return error_mark_node
;
10870 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
10873 type_is_deprecated (tree type
)
10875 enum tree_code code
;
10876 if (TREE_DEPRECATED (type
))
10878 if (TYPE_NAME (type
)
10879 && TREE_DEPRECATED (TYPE_NAME (type
)))
10882 /* Do warn about using typedefs to a deprecated class. */
10883 if (TAGGED_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
10884 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
10886 code
= TREE_CODE (type
);
10888 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
10889 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
10890 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
10891 return type_is_deprecated (TREE_TYPE (type
));
10893 if (TYPE_PTRMEMFUNC_P (type
))
10894 return type_is_deprecated
10895 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
10900 /* Decode the list of parameter types for a function type.
10901 Given the list of things declared inside the parens,
10902 return a list of types.
10904 If this parameter does not end with an ellipsis, we append
10907 *PARMS is set to the chain of PARM_DECLs created. */
10910 grokparms (tree parmlist
, tree
*parms
)
10912 tree result
= NULL_TREE
;
10913 tree decls
= NULL_TREE
;
10917 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
10919 tree type
= NULL_TREE
;
10920 tree init
= TREE_PURPOSE (parm
);
10921 tree decl
= TREE_VALUE (parm
);
10922 const char *errmsg
;
10924 if (parm
== void_list_node
)
10927 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
10930 type
= TREE_TYPE (decl
);
10931 if (VOID_TYPE_P (type
))
10933 if (same_type_p (type
, void_type_node
)
10934 && DECL_SELF_REFERENCE_P (type
)
10935 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
10936 /* this is a parmlist of `(void)', which is ok. */
10938 cxx_incomplete_type_error (decl
, type
);
10939 /* It's not a good idea to actually create parameters of
10940 type `void'; other parts of the compiler assume that a
10941 void type terminates the parameter list. */
10942 type
= error_mark_node
;
10943 TREE_TYPE (decl
) = error_mark_node
;
10946 if (type
!= error_mark_node
10947 && TYPE_FOR_JAVA (type
)
10948 && MAYBE_CLASS_TYPE_P (type
))
10950 error ("parameter %qD has Java class type", decl
);
10951 type
= error_mark_node
;
10952 TREE_TYPE (decl
) = error_mark_node
;
10956 if (type
!= error_mark_node
10957 && (errmsg
= targetm
.invalid_parameter_type (type
)))
10960 type
= error_mark_node
;
10961 TREE_TYPE (decl
) = error_mark_node
;
10964 if (type
!= error_mark_node
)
10966 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
10968 tree deptype
= type_is_deprecated (type
);
10970 warn_deprecated_use (deptype
, NULL_TREE
);
10973 /* Top-level qualifiers on the parameters are
10974 ignored for function types. */
10975 type
= cp_build_qualified_type (type
, 0);
10976 if (TREE_CODE (type
) == METHOD_TYPE
)
10978 error ("parameter %qD invalidly declared method type", decl
);
10979 type
= build_pointer_type (type
);
10980 TREE_TYPE (decl
) = type
;
10982 else if (abstract_virtuals_error (decl
, type
))
10983 any_error
= 1; /* Seems like a good idea. */
10984 else if (POINTER_TYPE_P (type
))
10986 /* [dcl.fct]/6, parameter types cannot contain pointers
10987 (references) to arrays of unknown bound. */
10988 tree t
= TREE_TYPE (type
);
10989 int ptr
= TYPE_PTR_P (type
);
10993 if (TYPE_PTR_P (t
))
10995 else if (TREE_CODE (t
) != ARRAY_TYPE
)
10997 else if (!TYPE_DOMAIN (t
))
11001 if (TREE_CODE (t
) == ARRAY_TYPE
)
11003 ? G_("parameter %qD includes pointer to array of "
11004 "unknown bound %qT")
11005 : G_("parameter %qD includes reference to array of "
11006 "unknown bound %qT"),
11012 else if (init
&& !processing_template_decl
)
11013 init
= check_default_argument (decl
, init
);
11016 DECL_CHAIN (decl
) = decls
;
11018 result
= tree_cons (init
, type
, result
);
11020 decls
= nreverse (decls
);
11021 result
= nreverse (result
);
11023 result
= chainon (result
, void_list_node
);
11030 /* D is a constructor or overloaded `operator='.
11032 Let T be the class in which D is declared. Then, this function
11035 -1 if D's is an ill-formed constructor or copy assignment operator
11036 whose first parameter is of type `T'.
11037 0 if D is not a copy constructor or copy assignment
11039 1 if D is a copy constructor or copy assignment operator whose
11040 first parameter is a reference to non-const qualified T.
11041 2 if D is a copy constructor or copy assignment operator whose
11042 first parameter is a reference to const qualified T.
11044 This function can be used as a predicate. Positive values indicate
11045 a copy constructor and nonzero values indicate a copy assignment
11049 copy_fn_p (const_tree d
)
11055 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11057 if (TREE_CODE (d
) == TEMPLATE_DECL
11058 || (DECL_TEMPLATE_INFO (d
)
11059 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11060 /* Instantiations of template member functions are never copy
11061 functions. Note that member functions of templated classes are
11062 represented as template functions internally, and we must
11063 accept those as copy functions. */
11066 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11070 arg_type
= TREE_VALUE (args
);
11071 if (arg_type
== error_mark_node
)
11074 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11076 /* Pass by value copy assignment operator. */
11079 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11080 && !TYPE_REF_IS_RVALUE (arg_type
)
11081 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11083 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11089 args
= TREE_CHAIN (args
);
11091 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11092 /* There are more non-optional args. */
11098 /* D is a constructor or overloaded `operator='.
11100 Let T be the class in which D is declared. Then, this function
11101 returns true when D is a move constructor or move assignment
11102 operator, false otherwise. */
11105 move_fn_p (const_tree d
)
11107 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11109 if (cxx_dialect
== cxx98
)
11110 /* There are no move constructors if we are in C++98 mode. */
11113 if (TREE_CODE (d
) == TEMPLATE_DECL
11114 || (DECL_TEMPLATE_INFO (d
)
11115 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11116 /* Instantiations of template member functions are never move
11117 functions. Note that member functions of templated classes are
11118 represented as template functions internally, and we must
11119 accept those as move functions. */
11122 return move_signature_fn_p (d
);
11125 /* D is a constructor or overloaded `operator='.
11127 Then, this function returns true when D has the same signature as a move
11128 constructor or move assignment operator (because either it is such a
11129 ctor/op= or it is a template specialization with the same signature),
11130 false otherwise. */
11133 move_signature_fn_p (const_tree d
)
11137 bool result
= false;
11139 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11143 arg_type
= TREE_VALUE (args
);
11144 if (arg_type
== error_mark_node
)
11147 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11148 && TYPE_REF_IS_RVALUE (arg_type
)
11149 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11153 args
= TREE_CHAIN (args
);
11155 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11156 /* There are more non-optional args. */
11162 /* Remember any special properties of member function DECL. */
11165 grok_special_member_properties (tree decl
)
11169 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11172 class_type
= DECL_CONTEXT (decl
);
11173 if (DECL_CONSTRUCTOR_P (decl
))
11175 int ctor
= copy_fn_p (decl
);
11177 if (!DECL_ARTIFICIAL (decl
))
11178 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11184 A non-template constructor for class X is a copy
11185 constructor if its first parameter is of type X&, const
11186 X&, volatile X& or const volatile X&, and either there
11187 are no other parameters or else all other parameters have
11188 default arguments. */
11189 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11190 if (user_provided_p (decl
))
11191 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11193 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11195 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11197 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11198 if (user_provided_p (decl
))
11199 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
11201 else if (move_fn_p (decl
) && user_provided_p (decl
))
11202 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11203 else if (is_list_ctor (decl
))
11204 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11206 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11207 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11208 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11210 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11214 A non-template assignment operator for class X is a copy
11215 assignment operator if its parameter is of type X, X&, const
11216 X&, volatile X& or const volatile X&. */
11218 int assop
= copy_fn_p (decl
);
11222 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11223 if (user_provided_p (decl
))
11224 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11226 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11228 else if (move_fn_p (decl
) && user_provided_p (decl
))
11229 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11231 /* Destructors are handled in check_methods. */
11234 /* Check a constructor DECL has the correct form. Complains
11235 if the class has a constructor of the form X(X). */
11238 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11240 int ctor_parm
= copy_fn_p (decl
);
11246 A declaration of a constructor for a class X is ill-formed if
11247 its first parameter is of type (optionally cv-qualified) X
11248 and either there are no other parameters or else all other
11249 parameters have default arguments.
11251 We *don't* complain about member template instantiations that
11252 have this form, though; they can occur as we try to decide
11253 what constructor to use during overload resolution. Since
11254 overload resolution will never prefer such a constructor to
11255 the non-template copy constructor (which is either explicitly
11256 or implicitly defined), there's no need to worry about their
11257 existence. Theoretically, they should never even be
11258 instantiated, but that's hard to forestall. */
11259 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11267 /* An operator with this code is unary, but can also be binary. */
11270 ambi_op_p (enum tree_code code
)
11272 return (code
== INDIRECT_REF
11273 || code
== ADDR_EXPR
11274 || code
== UNARY_PLUS_EXPR
11275 || code
== NEGATE_EXPR
11276 || code
== PREINCREMENT_EXPR
11277 || code
== PREDECREMENT_EXPR
);
11280 /* An operator with this name can only be unary. */
11283 unary_op_p (enum tree_code code
)
11285 return (code
== TRUTH_NOT_EXPR
11286 || code
== BIT_NOT_EXPR
11287 || code
== COMPONENT_REF
11288 || code
== TYPE_EXPR
);
11291 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11292 errors are issued for invalid declarations. */
11295 grok_op_properties (tree decl
, bool complain
)
11297 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11299 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11300 tree name
= DECL_NAME (decl
);
11301 enum tree_code operator_code
;
11306 /* Count the number of arguments and check for ellipsis. */
11307 for (argtype
= argtypes
, arity
= 0;
11308 argtype
&& argtype
!= void_list_node
;
11309 argtype
= TREE_CHAIN (argtype
))
11311 ellipsis_p
= !argtype
;
11313 class_type
= DECL_CONTEXT (decl
);
11314 if (class_type
&& !CLASS_TYPE_P (class_type
))
11315 class_type
= NULL_TREE
;
11317 if (DECL_CONV_FN_P (decl
))
11318 operator_code
= TYPE_EXPR
;
11322 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11323 if (ansi_opname (CODE) == name) \
11325 operator_code = (CODE); \
11328 else if (ansi_assopname (CODE) == name) \
11330 operator_code = (CODE); \
11331 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11335 #include "operators.def"
11336 #undef DEF_OPERATOR
11338 gcc_unreachable ();
11341 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11342 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11345 switch (operator_code
)
11348 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11352 TYPE_GETS_DELETE (class_type
) |= 1;
11356 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11359 case VEC_DELETE_EXPR
:
11360 TYPE_GETS_DELETE (class_type
) |= 2;
11367 /* [basic.std.dynamic.allocation]/1:
11369 A program is ill-formed if an allocation function is declared
11370 in a namespace scope other than global scope or declared static
11373 The same also holds true for deallocation functions. */
11374 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11375 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11377 if (DECL_NAMESPACE_SCOPE_P (decl
))
11379 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11381 error ("%qD may not be declared within a namespace", decl
);
11384 else if (!TREE_PUBLIC (decl
))
11386 error ("%qD may not be declared as static", decl
);
11392 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11394 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11395 DECL_IS_OPERATOR_NEW (decl
) = 1;
11397 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11398 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11401 /* An operator function must either be a non-static member function
11402 or have at least one parameter of a class, a reference to a class,
11403 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11404 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11406 if (operator_code
== TYPE_EXPR
11407 || operator_code
== CALL_EXPR
11408 || operator_code
== COMPONENT_REF
11409 || operator_code
== ARRAY_REF
11410 || operator_code
== NOP_EXPR
)
11412 error ("%qD must be a nonstatic member function", decl
);
11419 if (DECL_STATIC_FUNCTION_P (decl
))
11421 error ("%qD must be either a non-static member "
11422 "function or a non-member function", decl
);
11426 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11428 tree arg
= non_reference (TREE_VALUE (p
));
11429 if (arg
== error_mark_node
)
11432 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11433 because these checks are performed even on
11434 template functions. */
11435 if (MAYBE_CLASS_TYPE_P (arg
)
11436 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11440 if (!p
|| p
== void_list_node
)
11443 error ("%qD must have an argument of class or "
11444 "enumerated type", decl
);
11450 /* There are no restrictions on the arguments to an overloaded
11452 if (operator_code
== CALL_EXPR
)
11455 /* Warn about conversion operators that will never be used. */
11456 if (IDENTIFIER_TYPENAME_P (name
)
11457 && ! DECL_TEMPLATE_INFO (decl
)
11459 /* Warn only declaring the function; there is no need to
11460 warn again about out-of-class definitions. */
11461 && class_type
== current_class_type
)
11463 tree t
= TREE_TYPE (name
);
11464 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11467 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11469 if (TREE_CODE (t
) == VOID_TYPE
)
11470 warning (OPT_Wconversion
,
11472 ? G_("conversion to a reference to void "
11473 "will never use a type conversion operator")
11474 : G_("conversion to void "
11475 "will never use a type conversion operator"));
11476 else if (class_type
)
11478 if (t
== class_type
)
11479 warning (OPT_Wconversion
,
11481 ? G_("conversion to a reference to the same type "
11482 "will never use a type conversion operator")
11483 : G_("conversion to the same type "
11484 "will never use a type conversion operator"));
11485 /* Don't force t to be complete here. */
11486 else if (MAYBE_CLASS_TYPE_P (t
)
11487 && COMPLETE_TYPE_P (t
)
11488 && DERIVED_FROM_P (t
, class_type
))
11489 warning (OPT_Wconversion
,
11491 ? G_("conversion to a reference to a base class "
11492 "will never use a type conversion operator")
11493 : G_("conversion to a base class "
11494 "will never use a type conversion operator"));
11499 if (operator_code
== COND_EXPR
)
11502 error ("ISO C++ prohibits overloading operator ?:");
11505 else if (ellipsis_p
)
11507 error ("%qD must not have variable number of arguments", decl
);
11510 else if (ambi_op_p (operator_code
))
11513 /* We pick the one-argument operator codes by default, so
11514 we don't have to change anything. */
11516 else if (arity
== 2)
11518 /* If we thought this was a unary operator, we now know
11519 it to be a binary operator. */
11520 switch (operator_code
)
11523 operator_code
= MULT_EXPR
;
11527 operator_code
= BIT_AND_EXPR
;
11530 case UNARY_PLUS_EXPR
:
11531 operator_code
= PLUS_EXPR
;
11535 operator_code
= MINUS_EXPR
;
11538 case PREINCREMENT_EXPR
:
11539 operator_code
= POSTINCREMENT_EXPR
;
11542 case PREDECREMENT_EXPR
:
11543 operator_code
= POSTDECREMENT_EXPR
;
11547 gcc_unreachable ();
11550 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11552 if ((operator_code
== POSTINCREMENT_EXPR
11553 || operator_code
== POSTDECREMENT_EXPR
)
11554 && ! processing_template_decl
11555 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11558 error ("postfix %qD must take %<int%> as its argument",
11561 error ("postfix %qD must take %<int%> as its second "
11569 error ("%qD must take either zero or one argument", decl
);
11571 error ("%qD must take either one or two arguments", decl
);
11575 /* More Effective C++ rule 6. */
11577 && (operator_code
== POSTINCREMENT_EXPR
11578 || operator_code
== POSTDECREMENT_EXPR
11579 || operator_code
== PREINCREMENT_EXPR
11580 || operator_code
== PREDECREMENT_EXPR
))
11582 tree arg
= TREE_VALUE (argtypes
);
11583 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11584 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11585 arg
= TREE_TYPE (arg
);
11586 arg
= TYPE_MAIN_VARIANT (arg
);
11587 if (operator_code
== PREINCREMENT_EXPR
11588 || operator_code
== PREDECREMENT_EXPR
)
11590 if (TREE_CODE (ret
) != REFERENCE_TYPE
11591 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11593 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11594 build_reference_type (arg
));
11598 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11599 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11603 else if (unary_op_p (operator_code
))
11608 error ("%qD must take %<void%>", decl
);
11610 error ("%qD must take exactly one argument", decl
);
11614 else /* if (binary_op_p (operator_code)) */
11619 error ("%qD must take exactly one argument", decl
);
11621 error ("%qD must take exactly two arguments", decl
);
11625 /* More Effective C++ rule 7. */
11627 && (operator_code
== TRUTH_ANDIF_EXPR
11628 || operator_code
== TRUTH_ORIF_EXPR
11629 || operator_code
== COMPOUND_EXPR
))
11630 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11634 /* Effective C++ rule 23. */
11637 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11638 && (operator_code
== PLUS_EXPR
11639 || operator_code
== MINUS_EXPR
11640 || operator_code
== TRUNC_DIV_EXPR
11641 || operator_code
== MULT_EXPR
11642 || operator_code
== TRUNC_MOD_EXPR
)
11643 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11644 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11646 /* [over.oper]/8 */
11647 for (; argtypes
&& argtypes
!= void_list_node
;
11648 argtypes
= TREE_CHAIN (argtypes
))
11649 if (TREE_PURPOSE (argtypes
))
11651 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11652 if (operator_code
== POSTINCREMENT_EXPR
11653 || operator_code
== POSTDECREMENT_EXPR
)
11655 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
11660 error ("%qD cannot have default arguments", decl
);
11668 /* Return a string giving the keyword associate with CODE. */
11670 static const char *
11671 tag_name (enum tag_types code
)
11683 case typename_type
:
11686 gcc_unreachable ();
11690 /* Name lookup in an elaborated-type-specifier (after the keyword
11691 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11692 elaborated-type-specifier is invalid, issue a diagnostic and return
11693 error_mark_node; otherwise, return the *_TYPE to which it referred.
11694 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11697 check_elaborated_type_specifier (enum tag_types tag_code
,
11699 bool allow_template_p
)
11703 if (decl
== error_mark_node
)
11704 return error_mark_node
;
11708 struct S { struct S *p; };
11710 name lookup will find the TYPE_DECL for the implicit "S::S"
11711 typedef. Adjust for that here. */
11712 if (DECL_SELF_REFERENCE_P (decl
))
11713 decl
= TYPE_NAME (TREE_TYPE (decl
));
11715 type
= TREE_TYPE (decl
);
11717 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11718 is false for this case as well. */
11719 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11721 error ("using template type parameter %qT after %qs",
11722 type
, tag_name (tag_code
));
11723 return error_mark_node
;
11725 /* Accept template template parameters. */
11726 else if (allow_template_p
11727 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
11728 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
11732 If the identifier resolves to a typedef-name or the
11733 simple-template-id resolves to an alias template
11734 specialization, the elaborated-type-specifier is ill-formed.
11736 In other words, the only legitimate declaration to use in the
11737 elaborated type specifier is the implicit typedef created when
11738 the type is declared. */
11739 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
11740 && !DECL_SELF_REFERENCE_P (decl
)
11741 && tag_code
!= typename_type
)
11743 if (alias_template_specialization_p (type
))
11744 error ("using alias template specialization %qT after %qs",
11745 type
, tag_name (tag_code
));
11747 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
11748 inform (DECL_SOURCE_LOCATION (decl
),
11749 "%qD has a previous declaration here", decl
);
11750 return error_mark_node
;
11752 else if (TREE_CODE (type
) != RECORD_TYPE
11753 && TREE_CODE (type
) != UNION_TYPE
11754 && tag_code
!= enum_type
11755 && tag_code
!= typename_type
)
11757 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
11758 error ("%q+T has a previous declaration here", type
);
11759 return error_mark_node
;
11761 else if (TREE_CODE (type
) != ENUMERAL_TYPE
11762 && tag_code
== enum_type
)
11764 error ("%qT referred to as enum", type
);
11765 error ("%q+T has a previous declaration here", type
);
11766 return error_mark_node
;
11768 else if (!allow_template_p
11769 && TREE_CODE (type
) == RECORD_TYPE
11770 && CLASSTYPE_IS_TEMPLATE (type
))
11772 /* If a class template appears as elaborated type specifier
11773 without a template header such as:
11775 template <class T> class C {};
11776 void f(class C); // No template header here
11778 then the required template argument is missing. */
11779 error ("template argument required for %<%s %T%>",
11780 tag_name (tag_code
),
11781 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
11782 return error_mark_node
;
11788 /* Lookup NAME in elaborate type specifier in scope according to
11789 SCOPE and issue diagnostics if necessary.
11790 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11791 found, and ERROR_MARK_NODE for type error. */
11794 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
11795 tag_scope scope
, bool template_header_p
)
11799 if (scope
== ts_global
)
11801 /* First try ordinary name lookup, ignoring hidden class name
11802 injected via friend declaration. */
11803 decl
= lookup_name_prefer_type (name
, 2);
11804 /* If that fails, the name will be placed in the smallest
11805 non-class, non-function-prototype scope according to 3.3.1/5.
11806 We may already have a hidden name declared as friend in this
11807 scope. So lookup again but not ignoring hidden names.
11808 If we find one, that name will be made visible rather than
11809 creating a new tag. */
11811 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
11814 decl
= lookup_type_scope (name
, scope
);
11817 && (DECL_CLASS_TEMPLATE_P (decl
)
11818 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl
)))
11819 decl
= DECL_TEMPLATE_RESULT (decl
);
11821 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
11823 /* Look for invalid nested type:
11827 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
11829 error ("%qD has the same name as the class in which it is "
11832 return error_mark_node
;
11835 /* Two cases we need to consider when deciding if a class
11836 template is allowed as an elaborated type specifier:
11837 1. It is a self reference to its own class.
11838 2. It comes with a template header.
11842 template <class T> class C {
11843 class C *c1; // DECL_SELF_REFERENCE_P is true
11846 template <class U> class C; // template_header_p is true
11847 template <class T> class C<T>::D {
11848 class C *c2; // DECL_SELF_REFERENCE_P is true
11851 t
= check_elaborated_type_specifier (tag_code
,
11854 | DECL_SELF_REFERENCE_P (decl
));
11857 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
11859 error ("reference to %qD is ambiguous", name
);
11860 print_candidates (decl
);
11861 return error_mark_node
;
11867 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
11868 Define the tag as a forward-reference if it is not defined.
11870 If a declaration is given, process it here, and report an error if
11871 multiple declarations are not identical.
11873 SCOPE is TS_CURRENT when this is also a definition. Only look in
11874 the current frame for the name (since C++ allows new names in any
11875 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
11876 declaration. Only look beginning from the current scope outward up
11877 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
11879 TEMPLATE_HEADER_P is true when this declaration is preceded by
11880 a set of template parameters. */
11883 xref_tag_1 (enum tag_types tag_code
, tree name
,
11884 tag_scope scope
, bool template_header_p
)
11886 enum tree_code code
;
11888 tree context
= NULL_TREE
;
11890 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
11896 code
= RECORD_TYPE
;
11902 code
= ENUMERAL_TYPE
;
11905 gcc_unreachable ();
11908 /* In case of anonymous name, xref_tag is only called to
11909 make type node and push name. Name lookup is not required. */
11910 if (ANON_AGGRNAME_P (name
))
11913 t
= lookup_and_check_tag (tag_code
, name
,
11914 scope
, template_header_p
);
11916 if (t
== error_mark_node
)
11917 return error_mark_node
;
11919 if (scope
!= ts_current
&& t
&& current_class_type
11920 && template_class_depth (current_class_type
)
11921 && template_header_p
)
11923 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
11926 /* Since SCOPE is not TS_CURRENT, we are not looking at a
11927 definition of this tag. Since, in addition, we are currently
11928 processing a (member) template declaration of a template
11929 class, we must be very careful; consider:
11936 { template <class V>
11937 friend struct S1; };
11939 Here, the S2::S1 declaration should not be confused with the
11940 outer declaration. In particular, the inner version should
11941 have a template parameter of level 2, not level 1. This
11942 would be particularly important if the member declaration
11945 template <class V = U> friend struct S1;
11947 say, when we should tsubst into `U' when instantiating
11948 S2. On the other hand, when presented with:
11958 we must find the inner binding eventually. We
11959 accomplish this by making sure that the new type we
11960 create to represent this declaration has the right
11962 context
= TYPE_CONTEXT (t
);
11968 /* If no such tag is yet defined, create a forward-reference node
11969 and record it as the "definition".
11970 When a real declaration of this type is found,
11971 the forward-reference will be altered into a real type. */
11972 if (code
== ENUMERAL_TYPE
)
11974 error ("use of enum %q#D without previous declaration", name
);
11975 return error_mark_node
;
11979 t
= make_class_type (code
);
11980 TYPE_CONTEXT (t
) = context
;
11981 t
= pushtag (name
, t
, scope
);
11986 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
11988 if (!redeclare_class_template (t
, current_template_parms
))
11989 return error_mark_node
;
11991 else if (!processing_template_decl
11992 && CLASS_TYPE_P (t
)
11993 && CLASSTYPE_IS_TEMPLATE (t
))
11995 error ("redeclaration of %qT as a non-template", t
);
11996 error ("previous declaration %q+D", t
);
11997 return error_mark_node
;
12000 /* Make injected friend class visible. */
12001 if (scope
!= ts_within_enclosing_non_class
12002 && hidden_name_p (TYPE_NAME (t
)))
12004 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12005 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12007 if (TYPE_TEMPLATE_INFO (t
))
12009 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12010 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12018 /* Wrapper for xref_tag_1. */
12021 xref_tag (enum tag_types tag_code
, tree name
,
12022 tag_scope scope
, bool template_header_p
)
12026 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12027 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12028 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12034 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12036 enum tag_types tag_kind
;
12038 if (TREE_CODE (old
) == RECORD_TYPE
)
12039 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12041 tag_kind
= union_type
;
12043 if (id
== NULL_TREE
)
12044 id
= TYPE_IDENTIFIER (old
);
12046 return xref_tag (tag_kind
, id
, scope
, false);
12049 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12050 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12051 access_* node, and the TREE_VALUE is the type of the base-class.
12052 Non-NULL TREE_TYPE indicates virtual inheritance.
12054 Returns true if the binfo hierarchy was successfully created,
12055 false if an error was detected. */
12058 xref_basetypes (tree ref
, tree base_list
)
12061 tree binfo
, base_binfo
;
12062 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12063 unsigned max_bases
= 0; /* Maximum direct bases. */
12065 tree default_access
;
12066 tree igo_prev
; /* Track Inheritance Graph Order. */
12068 if (ref
== error_mark_node
)
12071 /* The base of a derived class is private by default, all others are
12073 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12074 && CLASSTYPE_DECLARED_CLASS (ref
)
12075 ? access_private_node
: access_public_node
);
12077 /* First, make sure that any templates in base-classes are
12078 instantiated. This ensures that if we call ourselves recursively
12079 we do not get confused about which classes are marked and which
12081 basep
= &base_list
;
12084 tree basetype
= TREE_VALUE (*basep
);
12086 /* The dependent_type_p call below should really be dependent_scope_p
12087 so that we give a hard error about using an incomplete type as a
12088 base, but we allow it with a pedwarn for backward
12090 if (processing_template_decl
12091 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12092 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12093 if (!dependent_type_p (basetype
)
12094 && !complete_type_or_else (basetype
, NULL
))
12095 /* An incomplete type. Remove it from the list. */
12096 *basep
= TREE_CHAIN (*basep
);
12100 if (TREE_TYPE (*basep
))
12102 if (CLASS_TYPE_P (basetype
))
12103 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12104 basep
= &TREE_CHAIN (*basep
);
12108 TYPE_MARKED_P (ref
) = 1;
12110 /* The binfo slot should be empty, unless this is an (ill-formed)
12112 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12114 error ("redefinition of %q#T", ref
);
12118 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12120 binfo
= make_tree_binfo (max_bases
);
12122 TYPE_BINFO (ref
) = binfo
;
12123 BINFO_OFFSET (binfo
) = size_zero_node
;
12124 BINFO_TYPE (binfo
) = ref
;
12126 /* Apply base-class info set up to the variants of this type. */
12127 fixup_type_variants (ref
);
12131 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12132 /* An aggregate cannot have baseclasses. */
12133 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12135 if (TREE_CODE (ref
) == UNION_TYPE
)
12137 error ("derived union %qT invalid", ref
);
12144 if (TYPE_FOR_JAVA (ref
))
12146 error ("Java class %qT cannot have multiple bases", ref
);
12153 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12155 if (TYPE_FOR_JAVA (ref
))
12157 error ("Java class %qT cannot have virtual bases", ref
);
12162 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12164 tree access
= TREE_PURPOSE (base_list
);
12165 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12166 tree basetype
= TREE_VALUE (base_list
);
12168 if (access
== access_default_node
)
12169 access
= default_access
;
12171 if (PACK_EXPANSION_P (basetype
))
12172 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12173 if (TREE_CODE (basetype
) == TYPE_DECL
)
12174 basetype
= TREE_TYPE (basetype
);
12175 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12177 error ("base type %qT fails to be a struct or class type",
12182 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12183 TYPE_FOR_JAVA (ref
) = 1;
12185 base_binfo
= NULL_TREE
;
12186 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12188 base_binfo
= TYPE_BINFO (basetype
);
12189 /* The original basetype could have been a typedef'd type. */
12190 basetype
= BINFO_TYPE (base_binfo
);
12192 /* Inherit flags from the base. */
12193 TYPE_HAS_NEW_OPERATOR (ref
)
12194 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12195 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12196 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12197 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12198 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12199 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12200 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12201 CLASSTYPE_REPEATED_BASE_P (ref
)
12202 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12205 /* We must do this test after we've seen through a typedef
12207 if (TYPE_MARKED_P (basetype
))
12209 if (basetype
== ref
)
12210 error ("recursive type %qT undefined", basetype
);
12212 error ("duplicate base type %qT invalid", basetype
);
12216 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12217 /* Regenerate the pack expansion for the bases. */
12218 basetype
= make_pack_expansion (basetype
);
12220 TYPE_MARKED_P (basetype
) = 1;
12222 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12223 &igo_prev
, via_virtual
);
12224 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12225 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12227 BINFO_BASE_APPEND (binfo
, base_binfo
);
12228 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12231 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12232 /* If we didn't get max_vbases vbases, we must have shared at
12233 least one of them, and are therefore diamond shaped. */
12234 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12236 /* Unmark all the types. */
12237 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12238 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12239 TYPE_MARKED_P (ref
) = 0;
12241 /* Now see if we have a repeated base type. */
12242 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12244 for (base_binfo
= binfo
; base_binfo
;
12245 base_binfo
= TREE_CHAIN (base_binfo
))
12247 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12249 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12252 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12254 for (base_binfo
= binfo
; base_binfo
;
12255 base_binfo
= TREE_CHAIN (base_binfo
))
12256 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12257 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12266 /* Copies the enum-related properties from type SRC to type DST.
12267 Used with the underlying type of an enum and the enum itself. */
12269 copy_type_enum (tree dst
, tree src
)
12272 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12274 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12275 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12276 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12277 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12278 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12279 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12280 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12281 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12282 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12286 /* Begin compiling the definition of an enumeration type.
12289 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12291 UNDERLYING_TYPE is the type that will be used as the storage for
12292 the enumeration type. This should be NULL_TREE if no storage type
12295 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12297 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12299 Returns the type object, as yet incomplete.
12300 Also records info about it so that build_enumerator
12301 may be used to declare the individual values as they are read. */
12304 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12305 bool scoped_enum_p
, bool *is_new
)
12307 tree prevtype
= NULL_TREE
;
12308 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
12312 /* [C++0x dcl.enum]p5:
12314 If not explicitly specified, the underlying type of a scoped
12315 enumeration type is int. */
12316 if (!underlying_type
&& scoped_enum_p
)
12317 underlying_type
= integer_type_node
;
12319 if (underlying_type
)
12320 underlying_type
= cv_unqualified (underlying_type
);
12322 /* If this is the real definition for a previous forward reference,
12323 fill in the contents in the same object that used to be the
12324 forward reference. */
12326 enumtype
= lookup_and_check_tag (enum_type
, name
,
12327 /*tag_scope=*/ts_current
,
12328 /*template_header_p=*/false);
12330 /* In case of a template_decl, the only check that should be deferred
12331 to instantiation time is the comparison of underlying types. */
12332 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12334 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12336 error_at (input_location
, "scoped/unscoped mismatch "
12337 "in enum %q#T", enumtype
);
12338 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12339 "previous definition here");
12340 enumtype
= error_mark_node
;
12342 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12344 error_at (input_location
, "underlying type mismatch "
12345 "in enum %q#T", enumtype
);
12346 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12347 "previous definition here");
12348 enumtype
= error_mark_node
;
12350 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12351 && !dependent_type_p (underlying_type
)
12352 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12353 && !same_type_p (underlying_type
,
12354 ENUM_UNDERLYING_TYPE (enumtype
)))
12356 error_at (input_location
, "different underlying type "
12357 "in enum %q#T", enumtype
);
12358 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12359 "previous definition here");
12360 underlying_type
= NULL_TREE
;
12364 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12365 || processing_template_decl
)
12367 /* In case of error, make a dummy enum to allow parsing to
12369 if (enumtype
== error_mark_node
)
12371 name
= make_anon_name ();
12372 enumtype
= NULL_TREE
;
12375 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12376 of an opaque enum, or an opaque enum of an already defined
12377 enumeration (C++0x only).
12378 In any other case, it'll be NULL_TREE. */
12384 prevtype
= enumtype
;
12386 /* Do not push the decl more than once, unless we need to
12387 compare underlying types at instantiation time */
12389 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12390 || (underlying_type
12391 && dependent_type_p (underlying_type
))
12392 || (ENUM_UNDERLYING_TYPE (enumtype
)
12393 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12395 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12396 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12399 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12402 if (enumtype
== error_mark_node
)
12403 return error_mark_node
;
12405 /* The enum is considered opaque until the opening '{' of the
12406 enumerator list. */
12407 SET_OPAQUE_ENUM_P (enumtype
, true);
12408 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12411 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12413 if (underlying_type
)
12415 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12417 copy_type_enum (enumtype
, underlying_type
);
12418 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12420 else if (dependent_type_p (underlying_type
))
12421 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12423 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12424 underlying_type
, enumtype
);
12427 /* If into a template class, the returned enum is always the first
12428 declaration (opaque or not) seen. This way all the references to
12429 this type will be to the same declaration. The following ones are used
12430 only to check for definition errors. */
12431 if (prevtype
&& processing_template_decl
)
12437 /* After processing and defining all the values of an enumeration type,
12438 install their decls in the enumeration type.
12439 ENUMTYPE is the type object. */
12442 finish_enum_value_list (tree enumtype
)
12445 tree underlying_type
;
12448 tree minnode
, maxnode
;
12451 bool fixed_underlying_type_p
12452 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12454 /* We built up the VALUES in reverse order. */
12455 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12457 /* For an enum defined in a template, just set the type of the values;
12458 all further processing is postponed until the template is
12459 instantiated. We need to set the type so that tsubst of a CONST_DECL
12461 if (processing_template_decl
)
12463 for (values
= TYPE_VALUES (enumtype
);
12465 values
= TREE_CHAIN (values
))
12466 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12470 /* Determine the minimum and maximum values of the enumerators. */
12471 if (TYPE_VALUES (enumtype
))
12473 minnode
= maxnode
= NULL_TREE
;
12475 for (values
= TYPE_VALUES (enumtype
);
12477 values
= TREE_CHAIN (values
))
12479 decl
= TREE_VALUE (values
);
12481 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12482 each enumerator has the type of its enumeration. Prior to the
12483 closing brace, the type of each enumerator is the type of its
12484 initializing value. */
12485 TREE_TYPE (decl
) = enumtype
;
12487 /* Update the minimum and maximum values, if appropriate. */
12488 value
= DECL_INITIAL (decl
);
12489 if (value
== error_mark_node
)
12490 value
= integer_zero_node
;
12491 /* Figure out what the minimum and maximum values of the
12492 enumerators are. */
12494 minnode
= maxnode
= value
;
12495 else if (tree_int_cst_lt (maxnode
, value
))
12497 else if (tree_int_cst_lt (value
, minnode
))
12504 If the enumerator-list is empty, the underlying type is as if
12505 the enumeration had a single enumerator with value 0. */
12506 minnode
= maxnode
= integer_zero_node
;
12508 if (!fixed_underlying_type_p
)
12510 /* Compute the number of bits require to represent all values of the
12511 enumeration. We must do this before the type of MINNODE and
12512 MAXNODE are transformed, since tree_int_cst_min_precision relies
12513 on the TREE_TYPE of the value it is passed. */
12514 bool unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12515 int lowprec
= tree_int_cst_min_precision (minnode
, unsignedp
);
12516 int highprec
= tree_int_cst_min_precision (maxnode
, unsignedp
);
12517 int precision
= MAX (lowprec
, highprec
);
12519 bool use_short_enum
;
12521 /* Determine the underlying type of the enumeration.
12525 The underlying type of an enumeration is an integral type that
12526 can represent all the enumerator values defined in the
12527 enumeration. It is implementation-defined which integral type is
12528 used as the underlying type for an enumeration except that the
12529 underlying type shall not be larger than int unless the value of
12530 an enumerator cannot fit in an int or unsigned int.
12532 We use "int" or an "unsigned int" as the underlying type, even if
12533 a smaller integral type would work, unless the user has
12534 explicitly requested that we use the smallest possible type. The
12535 user can request that for all enumerations with a command line
12536 flag, or for just one enumeration with an attribute. */
12538 use_short_enum
= flag_short_enums
12539 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12541 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12545 underlying_type
= integer_types
[itk
];
12546 if (underlying_type
!= NULL_TREE
12547 && TYPE_PRECISION (underlying_type
) >= precision
12548 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
12551 if (itk
== itk_none
)
12555 IF no integral type can represent all the enumerator values, the
12556 enumeration is ill-formed. */
12557 error ("no integral type can represent all of the enumerator values "
12558 "for %qT", enumtype
);
12559 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12560 underlying_type
= integer_types
[itk_unsigned_long_long
];
12565 The value of sizeof() applied to an enumeration type, an object
12566 of an enumeration type, or an enumerator, is the value of sizeof()
12567 applied to the underlying type. */
12568 copy_type_enum (enumtype
, underlying_type
);
12570 /* Compute the minimum and maximum values for the type.
12574 For an enumeration where emin is the smallest enumerator and emax
12575 is the largest, the values of the enumeration are the values of the
12576 underlying type in the range bmin to bmax, where bmin and bmax are,
12577 respectively, the smallest and largest values of the smallest bit-
12578 field that can store emin and emax. */
12580 /* The middle-end currently assumes that types with TYPE_PRECISION
12581 narrower than their underlying type are suitably zero or sign
12582 extended to fill their mode. Similarly, it assumes that the front
12583 end assures that a value of a particular type must be within
12584 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12586 We used to set these fields based on bmin and bmax, but that led
12587 to invalid assumptions like optimizing away bounds checking. So
12588 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12589 TYPE_MAX_VALUE to the values for the mode above and only restrict
12590 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12591 ENUM_UNDERLYING_TYPE (enumtype
)
12592 = build_distinct_type_copy (underlying_type
);
12593 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12594 set_min_and_max_values_for_integral_type
12595 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, unsignedp
);
12597 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12598 if (flag_strict_enums
)
12599 set_min_and_max_values_for_integral_type (enumtype
, precision
,
12603 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12605 /* Convert each of the enumerators to the type of the underlying
12606 type of the enumeration. */
12607 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12609 location_t saved_location
;
12611 decl
= TREE_VALUE (values
);
12612 saved_location
= input_location
;
12613 input_location
= DECL_SOURCE_LOCATION (decl
);
12614 if (fixed_underlying_type_p
)
12615 /* If the enumeration type has a fixed underlying type, we
12616 already checked all of the enumerator values. */
12617 value
= DECL_INITIAL (decl
);
12619 value
= perform_implicit_conversion (underlying_type
,
12620 DECL_INITIAL (decl
),
12621 tf_warning_or_error
);
12622 input_location
= saved_location
;
12624 /* Do not clobber shared ints. */
12625 value
= copy_node (value
);
12627 TREE_TYPE (value
) = enumtype
;
12628 DECL_INITIAL (decl
) = value
;
12631 /* Fix up all variant types of this enum type. */
12632 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12633 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12635 if (at_class_scope_p ()
12636 && COMPLETE_TYPE_P (current_class_type
)
12637 && UNSCOPED_ENUM_P (enumtype
))
12638 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
12639 current_class_type
);
12641 /* Finish debugging output for this type. */
12642 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12645 /* Finishes the enum type. This is called only the first time an
12646 enumeration is seen, be it opaque or odinary.
12647 ENUMTYPE is the type object. */
12650 finish_enum (tree enumtype
)
12652 if (processing_template_decl
)
12654 if (at_function_scope_p ())
12655 add_stmt (build_min (TAG_DEFN
, enumtype
));
12659 /* If this is a forward declaration, there should not be any variants,
12660 though we can get a variant in the middle of an enum-specifier with
12661 wacky code like 'enum E { e = sizeof(const E*) };' */
12662 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
12663 && (TYPE_VALUES (enumtype
)
12664 || !TYPE_NEXT_VARIANT (enumtype
)));
12667 /* Build and install a CONST_DECL for an enumeration constant of the
12668 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12669 LOC is the location of NAME.
12670 Assignment of sequential values by default is handled here. */
12673 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
12679 /* If the VALUE was erroneous, pretend it wasn't there; that will
12680 result in the enum being assigned the next value in sequence. */
12681 if (value
== error_mark_node
)
12684 /* Remove no-op casts from the value. */
12686 STRIP_TYPE_NOPS (value
);
12688 if (! processing_template_decl
)
12690 /* Validate and default VALUE. */
12691 if (value
!= NULL_TREE
)
12693 value
= cxx_constant_value (value
);
12695 if (TREE_CODE (value
) != INTEGER_CST
12696 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
12698 error ("enumerator value for %qD is not an integer constant",
12704 /* Default based on previous value. */
12705 if (value
== NULL_TREE
)
12707 if (TYPE_VALUES (enumtype
))
12712 /* C++03 7.2/4: If no initializer is specified for the first
12713 enumerator, the type is an unspecified integral
12714 type. Otherwise the type is the same as the type of the
12715 initializing value of the preceding enumerator unless the
12716 incremented value is not representable in that type, in
12717 which case the type is an unspecified integral type
12718 sufficient to contain the incremented value. */
12719 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12720 if (error_operand_p (prev_value
))
12721 value
= error_mark_node
;
12724 double_int di
= TREE_INT_CST (prev_value
)
12725 .add_with_sign (double_int_one
,
12726 false, &overflowed
);
12729 tree type
= TREE_TYPE (prev_value
);
12730 bool pos
= TYPE_UNSIGNED (type
) || !di
.is_negative ();
12731 if (!double_int_fits_to_tree_p (type
, di
))
12734 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
12736 type
= integer_types
[itk
];
12737 if (type
!= NULL_TREE
12738 && (pos
|| !TYPE_UNSIGNED (type
))
12739 && double_int_fits_to_tree_p (type
, di
))
12742 if (type
&& cxx_dialect
< cxx0x
12743 && itk
> itk_unsigned_long
)
12744 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
12745 incremented enumerator value is too large for %<unsigned long%>" : "\
12746 incremented enumerator value is too large for %<long%>");
12748 if (type
== NULL_TREE
)
12751 value
= double_int_to_tree (type
, di
);
12756 error ("overflow in enumeration values at %qD", name
);
12757 value
= error_mark_node
;
12762 value
= integer_zero_node
;
12765 /* Remove no-op casts from the value. */
12766 STRIP_TYPE_NOPS (value
);
12768 /* If the underlying type of the enum is fixed, check whether
12769 the enumerator values fits in the underlying type. If it
12770 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12771 if (ENUM_UNDERLYING_TYPE (enumtype
)
12773 && TREE_CODE (value
) == INTEGER_CST
12774 && !int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
12776 error ("enumerator value %E is too large for underlying type %<%T%>",
12777 value
, ENUM_UNDERLYING_TYPE (enumtype
));
12779 /* Silently convert the value so that we can continue. */
12780 value
= perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype
),
12785 /* C++ associates enums with global, function, or class declarations. */
12786 context
= current_scope ();
12788 /* Build the actual enumeration constant. Note that the enumeration
12789 constants have the underlying type of the enum (if it is fixed)
12790 or the type of their initializer (if the underlying type of the
12791 enum is not fixed):
12795 If the underlying type is fixed, the type of each enumerator
12796 prior to the closing brace is the underlying type; if the
12797 initializing value of an enumerator cannot be represented by
12798 the underlying type, the program is ill-formed. If the
12799 underlying type is not fixed, the type of each enumerator is
12800 the type of its initializing value.
12802 If the underlying type is not fixed, it will be computed by
12803 finish_enum and we will reset the type of this enumerator. Of
12804 course, if we're processing a template, there may be no value. */
12805 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12807 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
12809 DECL_CONTEXT (decl
) = enumtype
;
12810 TREE_CONSTANT (decl
) = 1;
12811 TREE_READONLY (decl
) = 1;
12812 DECL_INITIAL (decl
) = value
;
12814 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
12815 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12816 on the TYPE_FIELDS list for `S'. (That's so that you can say
12817 things like `S::i' later.) */
12818 finish_member_declaration (decl
);
12822 /* Add this enumeration constant to the list for this type. */
12823 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12826 /* Look for an enumerator with the given NAME within the enumeration
12827 type ENUMTYPE. This routine is used primarily for qualified name
12828 lookup into an enumerator in C++0x, e.g.,
12830 enum class Color { Red, Green, Blue };
12832 Color color = Color::Red;
12834 Returns the value corresponding to the enumerator, or
12835 NULL_TREE if no such enumerator was found. */
12837 lookup_enumerator (tree enumtype
, tree name
)
12840 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
12842 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
12843 return e
? TREE_VALUE (e
) : NULL_TREE
;
12847 /* We're defining DECL. Make sure that its type is OK. */
12850 check_function_type (tree decl
, tree current_function_parms
)
12852 tree fntype
= TREE_TYPE (decl
);
12853 tree return_type
= complete_type (TREE_TYPE (fntype
));
12855 /* In a function definition, arg types must be complete. */
12856 require_complete_types_for_parms (current_function_parms
);
12858 if (dependent_type_p (return_type
)
12859 || type_uses_auto (return_type
))
12861 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
12862 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
12864 tree args
= TYPE_ARG_TYPES (fntype
);
12866 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
12867 error ("return type %q#T is incomplete", return_type
);
12869 error ("return type has Java class type %q#T", return_type
);
12871 /* Make it return void instead. */
12872 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12873 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
12875 TREE_CHAIN (args
));
12877 fntype
= build_function_type (void_type_node
, args
);
12879 = build_exception_variant (fntype
,
12880 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
12881 fntype
= (cp_build_type_attribute_variant
12882 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
12883 TREE_TYPE (decl
) = fntype
;
12886 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
12889 /* Create the FUNCTION_DECL for a function definition.
12890 DECLSPECS and DECLARATOR are the parts of the declaration;
12891 they describe the function's name and the type it returns,
12892 but twisted together in a fashion that parallels the syntax of C.
12894 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12895 DECLARATOR is really the DECL for the function we are about to
12896 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12897 indicating that the function is an inline defined in-class.
12899 This function creates a binding context for the function body
12900 as well as setting up the FUNCTION_DECL in current_function_decl.
12902 For C++, we must first check whether that datum makes any sense.
12903 For example, "class A local_a(1,2);" means that variable local_a
12904 is an aggregate of type A, which should have a constructor
12905 applied to it with the argument list [1, 2].
12907 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
12908 or may be a BLOCK if the function has been defined previously
12909 in this translation unit. On exit, DECL_INITIAL (decl1) will be
12910 error_mark_node if the function has never been defined, or
12911 a BLOCK if the function has been defined somewhere. */
12914 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
12916 tree ctype
= NULL_TREE
;
12919 int doing_friend
= 0;
12920 cp_binding_level
*bl
;
12921 tree current_function_parms
;
12922 struct c_fileinfo
*finfo
12923 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
12924 bool honor_interface
;
12926 /* Sanity check. */
12927 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
);
12928 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
12930 fntype
= TREE_TYPE (decl1
);
12931 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12932 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12934 /* ISO C++ 11.4/5. A friend function defined in a class is in
12935 the (lexical) scope of the class in which it is defined. */
12936 if (!ctype
&& DECL_FRIEND_P (decl1
))
12938 ctype
= DECL_FRIEND_CONTEXT (decl1
);
12940 /* CTYPE could be null here if we're dealing with a template;
12941 for example, `inline friend float foo()' inside a template
12942 will have no CTYPE set. */
12943 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12949 if (DECL_DECLARED_INLINE_P (decl1
)
12950 && lookup_attribute ("noinline", attrs
))
12951 warning (0, "inline function %q+D given attribute noinline", decl1
);
12953 /* Handle gnu_inline attribute. */
12954 if (GNU_INLINE_P (decl1
))
12956 DECL_EXTERNAL (decl1
) = 1;
12957 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
12958 DECL_INTERFACE_KNOWN (decl1
) = 1;
12959 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
12962 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
12963 /* This is a constructor, we must ensure that any default args
12964 introduced by this definition are propagated to the clones
12965 now. The clones are used directly in overload resolution. */
12966 adjust_clone_args (decl1
);
12968 /* Sometimes we don't notice that a function is a static member, and
12969 build a METHOD_TYPE for it. Fix that up now. */
12970 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
12971 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
12973 /* Set up current_class_type, and enter the scope of the class, if
12976 push_nested_class (ctype
);
12977 else if (DECL_STATIC_FUNCTION_P (decl1
))
12978 push_nested_class (DECL_CONTEXT (decl1
));
12980 /* Now that we have entered the scope of the class, we must restore
12981 the bindings for any template parameters surrounding DECL1, if it
12982 is an inline member template. (Order is important; consider the
12983 case where a template parameter has the same name as a field of
12984 the class.) It is not until after this point that
12985 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
12986 if (flags
& SF_INCLASS_INLINE
)
12987 maybe_begin_member_template_processing (decl1
);
12989 /* Effective C++ rule 15. */
12991 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
12992 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
12993 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
12995 /* Make the init_value nonzero so pushdecl knows this is not tentative.
12996 error_mark_node is replaced below (in poplevel) with the BLOCK. */
12997 if (!DECL_INITIAL (decl1
))
12998 DECL_INITIAL (decl1
) = error_mark_node
;
13000 /* This function exists in static storage.
13001 (This does not mean `static' in the C sense!) */
13002 TREE_STATIC (decl1
) = 1;
13004 /* We must call push_template_decl after current_class_type is set
13005 up. (If we are processing inline definitions after exiting a
13006 class scope, current_class_type will be NULL_TREE until set above
13007 by push_nested_class.) */
13008 if (processing_template_decl
)
13010 /* FIXME: Handle error_mark_node more gracefully. */
13011 tree newdecl1
= push_template_decl (decl1
);
13012 if (newdecl1
!= error_mark_node
)
13016 /* We are now in the scope of the function being defined. */
13017 current_function_decl
= decl1
;
13019 /* Save the parm names or decls from this function's declarator
13020 where store_parm_decls will find them. */
13021 current_function_parms
= DECL_ARGUMENTS (decl1
);
13023 /* Make sure the parameter and return types are reasonable. When
13024 you declare a function, these types can be incomplete, but they
13025 must be complete when you define the function. */
13026 check_function_type (decl1
, current_function_parms
);
13028 /* Build the return declaration for the function. */
13029 restype
= TREE_TYPE (fntype
);
13031 if (DECL_RESULT (decl1
) == NULL_TREE
)
13035 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13036 DECL_ARTIFICIAL (resdecl
) = 1;
13037 DECL_IGNORED_P (resdecl
) = 1;
13038 DECL_RESULT (decl1
) = resdecl
;
13040 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13043 /* Let the user know we're compiling this function. */
13044 announce_function (decl1
);
13046 /* Record the decl so that the function name is defined.
13047 If we already have a decl for this name, and it is a FUNCTION_DECL,
13048 use the old decl. */
13049 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13051 /* A specialization is not used to guide overload resolution. */
13052 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13053 && !(DECL_USE_TEMPLATE (decl1
) &&
13054 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13056 tree olddecl
= pushdecl (decl1
);
13058 if (olddecl
== error_mark_node
)
13059 /* If something went wrong when registering the declaration,
13060 use DECL1; we have to have a FUNCTION_DECL to use when
13061 parsing the body of the function. */
13065 /* Otherwise, OLDDECL is either a previous declaration
13066 of the same function or DECL1 itself. */
13068 if (warn_missing_declarations
13069 && olddecl
== decl1
13070 && !DECL_MAIN_P (decl1
)
13071 && TREE_PUBLIC (decl1
)
13072 && !DECL_DECLARED_INLINE_P (decl1
))
13076 /* Check whether DECL1 is in an anonymous
13078 for (context
= DECL_CONTEXT (decl1
);
13080 context
= DECL_CONTEXT (context
))
13082 if (TREE_CODE (context
) == NAMESPACE_DECL
13083 && DECL_NAME (context
) == NULL_TREE
)
13087 if (context
== NULL
)
13088 warning (OPT_Wmissing_declarations
,
13089 "no previous declaration for %q+D", decl1
);
13097 /* We need to set the DECL_CONTEXT. */
13098 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13099 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13101 fntype
= TREE_TYPE (decl1
);
13103 /* If #pragma weak applies, mark the decl appropriately now.
13104 The pragma only applies to global functions. Because
13105 determining whether or not the #pragma applies involves
13106 computing the mangled name for the declaration, we cannot
13107 apply the pragma until after we have merged this declaration
13108 with any previous declarations; if the original declaration
13109 has a linkage specification, that specification applies to
13110 the definition as well, and may affect the mangled name. */
13111 if (DECL_FILE_SCOPE_P (decl1
))
13112 maybe_apply_pragma_weak (decl1
);
13115 /* Reset this in case the call to pushdecl changed it. */
13116 current_function_decl
= decl1
;
13118 gcc_assert (DECL_INITIAL (decl1
));
13120 /* This function may already have been parsed, in which case just
13121 return; our caller will skip over the body without parsing. */
13122 if (DECL_INITIAL (decl1
) != error_mark_node
)
13125 /* Initialize RTL machinery. We cannot do this until
13126 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13127 even when processing a template; this is how we get
13128 CFUN set up, and our per-function variables initialized.
13129 FIXME factor out the non-RTL stuff. */
13130 bl
= current_binding_level
;
13131 allocate_struct_function (decl1
, processing_template_decl
);
13133 /* Initialize the language data structures. Whenever we start
13134 a new function, we destroy temporaries in the usual way. */
13135 cfun
->language
= ggc_alloc_cleared_language_function ();
13136 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13137 current_binding_level
= bl
;
13139 if (!processing_template_decl
&& type_uses_auto (restype
))
13141 FNDECL_USED_AUTO (decl1
) = true;
13142 current_function_auto_return_pattern
= restype
;
13145 /* Start the statement-tree, start the tree now. */
13146 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13148 /* If we are (erroneously) defining a function that we have already
13149 defined before, wipe out what we knew before. */
13150 if (!DECL_PENDING_INLINE_P (decl1
))
13151 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13153 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13155 /* We know that this was set up by `grokclassfn'. We do not
13156 wait until `store_parm_decls', since evil parse errors may
13157 never get us to that point. Here we keep the consistency
13158 between `current_class_type' and `current_class_ptr'. */
13159 tree t
= DECL_ARGUMENTS (decl1
);
13161 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13162 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
);
13164 cp_function_chain
->x_current_class_ref
13165 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13166 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13167 cp_function_chain
->x_current_class_ptr
= t
;
13169 /* Constructors and destructors need to know whether they're "in
13170 charge" of initializing virtual base classes. */
13171 t
= DECL_CHAIN (t
);
13172 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13174 current_in_charge_parm
= t
;
13175 t
= DECL_CHAIN (t
);
13177 if (DECL_HAS_VTT_PARM_P (decl1
))
13179 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13180 current_vtt_parm
= t
;
13184 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13185 /* Implicitly-defined methods (like the
13186 destructor for a class in which no destructor
13187 is explicitly declared) must not be defined
13188 until their definition is needed. So, we
13189 ignore interface specifications for
13190 compiler-generated functions. */
13191 && !DECL_ARTIFICIAL (decl1
));
13193 if (processing_template_decl
)
13194 /* Don't mess with interface flags. */;
13195 else if (DECL_INTERFACE_KNOWN (decl1
))
13197 tree ctx
= decl_function_context (decl1
);
13199 if (DECL_NOT_REALLY_EXTERN (decl1
))
13200 DECL_EXTERNAL (decl1
) = 0;
13202 if (ctx
!= NULL_TREE
&& DECL_DECLARED_INLINE_P (ctx
)
13203 && TREE_PUBLIC (ctx
))
13204 /* This is a function in a local class in an extern inline
13206 comdat_linkage (decl1
);
13208 /* If this function belongs to an interface, it is public.
13209 If it belongs to someone else's interface, it is also external.
13210 This only affects inlines and template instantiations. */
13211 else if (!finfo
->interface_unknown
&& honor_interface
)
13213 if (DECL_DECLARED_INLINE_P (decl1
)
13214 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13216 DECL_EXTERNAL (decl1
)
13217 = (finfo
->interface_only
13218 || (DECL_DECLARED_INLINE_P (decl1
)
13219 && ! flag_implement_inlines
13220 && !DECL_VINDEX (decl1
)));
13222 /* For WIN32 we also want to put these in linkonce sections. */
13223 maybe_make_one_only (decl1
);
13226 DECL_EXTERNAL (decl1
) = 0;
13227 DECL_INTERFACE_KNOWN (decl1
) = 1;
13228 /* If this function is in an interface implemented in this file,
13229 make sure that the back end knows to emit this function
13231 if (!DECL_EXTERNAL (decl1
))
13232 mark_needed (decl1
);
13234 else if (finfo
->interface_unknown
&& finfo
->interface_only
13235 && honor_interface
)
13237 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13238 interface, we will have both finfo->interface_unknown and
13239 finfo->interface_only set. In that case, we don't want to
13240 use the normal heuristics because someone will supply a
13241 #pragma implementation elsewhere, and deducing it here would
13242 produce a conflict. */
13243 comdat_linkage (decl1
);
13244 DECL_EXTERNAL (decl1
) = 0;
13245 DECL_INTERFACE_KNOWN (decl1
) = 1;
13246 DECL_DEFER_OUTPUT (decl1
) = 1;
13250 /* This is a definition, not a reference.
13251 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13252 if (!GNU_INLINE_P (decl1
))
13253 DECL_EXTERNAL (decl1
) = 0;
13255 if ((DECL_DECLARED_INLINE_P (decl1
)
13256 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13257 && ! DECL_INTERFACE_KNOWN (decl1
))
13258 DECL_DEFER_OUTPUT (decl1
) = 1;
13260 DECL_INTERFACE_KNOWN (decl1
) = 1;
13263 /* Determine the ELF visibility attribute for the function. We must not
13264 do this before calling "pushdecl", as we must allow "duplicate_decls"
13265 to merge any attributes appropriately. We also need to wait until
13267 if (!DECL_CLONED_FUNCTION_P (decl1
))
13268 determine_visibility (decl1
);
13270 begin_scope (sk_function_parms
, decl1
);
13274 if (DECL_DESTRUCTOR_P (decl1
)
13275 || (DECL_CONSTRUCTOR_P (decl1
)
13276 && targetm
.cxx
.cdtor_returns_this ()))
13278 cdtor_label
= build_decl (input_location
,
13279 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13280 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13283 start_fname_decls ();
13285 store_parm_decls (current_function_parms
);
13289 /* Like start_preparsed_function, except that instead of a
13290 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13292 Returns 1 on success. If the DECLARATOR is not suitable for a function
13293 (it defines a datum instead), we return 0, which tells
13294 yyparse to report a parse error. */
13297 start_function (cp_decl_specifier_seq
*declspecs
,
13298 const cp_declarator
*declarator
,
13303 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13304 if (decl1
== error_mark_node
)
13306 /* If the declarator is not suitable for a function definition,
13307 cause a syntax error. */
13308 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13310 error ("invalid function declaration");
13314 if (DECL_MAIN_P (decl1
))
13315 /* main must return int. grokfndecl should have corrected it
13316 (and issued a diagnostic) if the user got it wrong. */
13317 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13318 integer_type_node
));
13320 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13325 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13329 use_eh_spec_block (tree fn
)
13331 return (flag_exceptions
&& flag_enforce_eh_specs
13332 && !processing_template_decl
13333 && !type_throw_all_p (TREE_TYPE (fn
))
13334 /* We insert the EH_SPEC_BLOCK only in the original
13335 function; then, it is copied automatically to the
13337 && !DECL_CLONED_FUNCTION_P (fn
)
13338 /* Implicitly-generated constructors and destructors have
13339 exception specifications. However, those specifications
13340 are the union of the possible exceptions specified by the
13341 constructors/destructors for bases and members, so no
13342 unallowed exception will ever reach this function. By
13343 not creating the EH_SPEC_BLOCK we save a little memory,
13344 and we avoid spurious warnings about unreachable
13346 && !DECL_DEFAULTED_FN (fn
));
13349 /* Store the parameter declarations into the current function declaration.
13350 This is called after parsing the parameter declarations, before
13351 digesting the body of the function.
13353 Also install to binding contour return value identifier, if any. */
13356 store_parm_decls (tree current_function_parms
)
13358 tree fndecl
= current_function_decl
;
13361 /* This is a chain of any other decls that came in among the parm
13362 declarations. If a parm is declared with enum {foo, bar} x;
13363 then CONST_DECLs for foo and bar are put here. */
13364 tree nonparms
= NULL_TREE
;
13366 if (current_function_parms
)
13368 /* This case is when the function was defined with an ANSI prototype.
13369 The parms already have decls, so we need not do anything here
13370 except record them as in effect
13371 and complain if any redundant old-style parm decls were written. */
13373 tree specparms
= current_function_parms
;
13376 /* Must clear this because it might contain TYPE_DECLs declared
13378 current_binding_level
->names
= NULL
;
13380 /* If we're doing semantic analysis, then we'll call pushdecl
13381 for each of these. We must do them in reverse order so that
13382 they end in the correct forward order. */
13383 specparms
= nreverse (specparms
);
13385 for (parm
= specparms
; parm
; parm
= next
)
13387 next
= DECL_CHAIN (parm
);
13388 if (TREE_CODE (parm
) == PARM_DECL
)
13390 if (DECL_NAME (parm
) == NULL_TREE
13391 || TREE_CODE (parm
) != VOID_TYPE
)
13394 error ("parameter %qD declared void", parm
);
13398 /* If we find an enum constant or a type tag,
13399 put it aside for the moment. */
13400 TREE_CHAIN (parm
) = NULL_TREE
;
13401 nonparms
= chainon (nonparms
, parm
);
13405 /* Get the decls in their original chain order and record in the
13406 function. This is all and only the PARM_DECLs that were
13407 pushed into scope by the loop above. */
13408 DECL_ARGUMENTS (fndecl
) = getdecls ();
13411 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13413 /* Now store the final chain of decls for the arguments
13414 as the decl-chain of the current lexical scope.
13415 Put the enumerators in as well, at the front so that
13416 DECL_ARGUMENTS is not modified. */
13417 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13419 if (use_eh_spec_block (current_function_decl
))
13420 current_eh_spec_block
= begin_eh_spec_block ();
13424 /* We have finished doing semantic analysis on DECL, but have not yet
13425 generated RTL for its body. Save away our current state, so that
13426 when we want to generate RTL later we know what to do. */
13429 save_function_data (tree decl
)
13431 struct language_function
*f
;
13433 /* Save the language-specific per-function data so that we can
13434 get it back when we really expand this function. */
13435 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13438 f
= ggc_alloc_language_function ();
13439 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13440 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13442 /* Clear out the bits we don't need. */
13443 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13444 f
->bindings
= NULL
;
13445 f
->x_local_names
= NULL
;
13446 f
->base
.local_typedefs
= NULL
;
13450 /* Set the return value of the constructor (if present). */
13453 finish_constructor_body (void)
13458 if (targetm
.cxx
.cdtor_returns_this ()
13459 && (! TYPE_FOR_JAVA (current_class_type
)))
13461 /* Any return from a constructor will end up here. */
13462 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13464 val
= DECL_ARGUMENTS (current_function_decl
);
13465 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13466 DECL_RESULT (current_function_decl
), val
);
13467 /* Return the address of the object. */
13468 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13469 add_stmt (exprstmt
);
13473 /* Do all the processing for the beginning of a destructor; set up the
13474 vtable pointers and cleanups for bases and members. */
13477 begin_destructor_body (void)
13479 tree compound_stmt
;
13481 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13482 issued an error message. We still want to try to process the
13483 body of the function, but initialize_vtbl_ptrs will crash if
13484 TYPE_BINFO is NULL. */
13485 if (COMPLETE_TYPE_P (current_class_type
))
13487 compound_stmt
= begin_compound_stmt (0);
13488 /* Make all virtual function table pointers in non-virtual base
13489 classes point to CURRENT_CLASS_TYPE's virtual function
13491 initialize_vtbl_ptrs (current_class_ptr
);
13492 finish_compound_stmt (compound_stmt
);
13494 /* And insert cleanups for our bases and members so that they
13495 will be properly destroyed if we throw. */
13496 push_base_cleanups ();
13500 /* At the end of every destructor we generate code to delete the object if
13501 necessary. Do that now. */
13504 finish_destructor_body (void)
13508 /* Any return from a destructor will end up here; that way all base
13509 and member cleanups will be run when the function returns. */
13510 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13512 /* In a virtual destructor, we must call delete. */
13513 if (DECL_VIRTUAL_P (current_function_decl
))
13516 tree virtual_size
= cxx_sizeof (current_class_type
);
13520 At the point of definition of a virtual destructor (including
13521 an implicit definition), non-placement operator delete shall
13522 be looked up in the scope of the destructor's class and if
13523 found shall be accessible and unambiguous. */
13524 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13526 /*global_p=*/false,
13527 /*placement=*/NULL_TREE
,
13528 /*alloc_fn=*/NULL_TREE
,
13529 tf_warning_or_error
);
13531 if_stmt
= begin_if_stmt ();
13532 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13533 current_in_charge_parm
,
13536 finish_expr_stmt (exprstmt
);
13537 finish_then_clause (if_stmt
);
13538 finish_if_stmt (if_stmt
);
13541 if (targetm
.cxx
.cdtor_returns_this ())
13545 val
= DECL_ARGUMENTS (current_function_decl
);
13546 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13547 DECL_RESULT (current_function_decl
), val
);
13548 /* Return the address of the object. */
13549 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13550 add_stmt (exprstmt
);
13554 /* Do the necessary processing for the beginning of a function body, which
13555 in this case includes member-initializers, but not the catch clauses of
13556 a function-try-block. Currently, this means opening a binding level
13557 for the member-initializers (in a ctor), member cleanups (in a dtor),
13558 and capture proxies (in a lambda operator()). */
13561 begin_function_body (void)
13565 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13568 if (processing_template_decl
)
13569 /* Do nothing now. */;
13571 /* Always keep the BLOCK node associated with the outermost pair of
13572 curly braces of a function. These are needed for correct
13573 operation of dwarfout.c. */
13574 keep_next_level (true);
13576 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13578 if (processing_template_decl
)
13579 /* Do nothing now. */;
13580 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13581 begin_destructor_body ();
13586 /* Do the processing for the end of a function body. Currently, this means
13587 closing out the cleanups for fully-constructed bases and members, and in
13588 the case of the destructor, deleting the object if desired. Again, this
13589 is only meaningful for [cd]tors, since they are the only functions where
13590 there is a significant distinction between the main body and any
13591 function catch clauses. Handling, say, main() return semantics here
13592 would be wrong, as flowing off the end of a function catch clause for
13593 main() would also need to return 0. */
13596 finish_function_body (tree compstmt
)
13598 if (compstmt
== NULL_TREE
)
13601 /* Close the block. */
13602 finish_compound_stmt (compstmt
);
13604 if (processing_template_decl
)
13605 /* Do nothing now. */;
13606 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
13607 finish_constructor_body ();
13608 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13609 finish_destructor_body ();
13612 /* Given a function, returns the BLOCK corresponding to the outermost level
13613 of curly braces, skipping the artificial block created for constructor
13617 outer_curly_brace_block (tree fndecl
)
13619 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
13620 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13621 /* Skip the artificial function body block. */
13622 block
= BLOCK_SUBBLOCKS (block
);
13626 /* If FNDECL is a class's key method, add the class to the list of
13627 keyed classes that should be emitted. */
13630 record_key_method_defined (tree fndecl
)
13632 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
13633 && DECL_VIRTUAL_P (fndecl
)
13634 && !processing_template_decl
)
13636 tree fnclass
= DECL_CONTEXT (fndecl
);
13637 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
13638 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
13642 /* Subroutine of finish_function.
13643 Save the body of constexpr functions for possible
13644 future compile time evaluation. */
13647 maybe_save_function_definition (tree fun
)
13649 if (!processing_template_decl
13650 && DECL_DECLARED_CONSTEXPR_P (fun
)
13651 && !DECL_CLONED_FUNCTION_P (fun
))
13652 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
13655 /* Finish up a function declaration and compile that function
13656 all the way to assembler language output. The free the storage
13657 for the function definition.
13659 FLAGS is a bitwise or of the following values:
13661 We just finished processing the body of an in-class inline
13662 function definition. (This processing will have taken place
13663 after the class definition is complete.) */
13666 finish_function (int flags
)
13668 tree fndecl
= current_function_decl
;
13669 tree fntype
, ctype
= NULL_TREE
;
13670 int inclass_inline
= (flags
& 2) != 0;
13672 /* When we get some parse errors, we can end up without a
13673 current_function_decl, so cope. */
13674 if (fndecl
== NULL_TREE
)
13675 return error_mark_node
;
13677 if (c_dialect_objc ())
13678 objc_finish_function ();
13680 gcc_assert (!defer_mark_used_calls
);
13681 defer_mark_used_calls
= true;
13683 record_key_method_defined (fndecl
);
13685 fntype
= TREE_TYPE (fndecl
);
13687 /* TREE_READONLY (fndecl) = 1;
13688 This caused &foo to be of type ptr-to-const-function
13689 which then got a warning when stored in a ptr-to-function variable. */
13691 gcc_assert (building_stmt_list_p ());
13692 /* The current function is being defined, so its DECL_INITIAL should
13693 be set, and unless there's a multiple definition, it should be
13694 error_mark_node. */
13695 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
13697 /* For a cloned function, we've already got all the code we need;
13698 there's no need to add any extra bits. */
13699 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13701 /* Make it so that `main' always returns 0 by default. */
13702 if (DECL_MAIN_P (current_function_decl
))
13703 finish_return_stmt (integer_zero_node
);
13705 if (use_eh_spec_block (current_function_decl
))
13706 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13707 (TREE_TYPE (current_function_decl
)),
13708 current_eh_spec_block
);
13711 /* If we're saving up tree structure, tie off the function now. */
13712 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
13714 finish_fname_decls ();
13716 /* If this function can't throw any exceptions, remember that. */
13717 if (!processing_template_decl
13718 && !cp_function_chain
->can_throw
13719 && !flag_non_call_exceptions
13720 && !decl_replaceable_p (fndecl
))
13721 TREE_NOTHROW (fndecl
) = 1;
13723 /* This must come after expand_function_end because cleanups might
13724 have declarations (from inline functions) that need to go into
13725 this function's blocks. */
13727 /* If the current binding level isn't the outermost binding level
13728 for this function, either there is a bug, or we have experienced
13729 syntax errors and the statement tree is malformed. */
13730 if (current_binding_level
->kind
!= sk_function_parms
)
13732 /* Make sure we have already experienced errors. */
13733 gcc_assert (errorcount
);
13735 /* Throw away the broken statement tree and extra binding
13737 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
13739 while (current_binding_level
->kind
!= sk_function_parms
)
13741 if (current_binding_level
->kind
== sk_class
)
13742 pop_nested_class ();
13744 poplevel (0, 0, 0);
13747 poplevel (1, 0, 1);
13749 /* Statements should always be full-expressions at the outermost set
13750 of curly braces for a function. */
13751 gcc_assert (stmts_are_full_exprs_p ());
13753 /* If there are no return statements in a function with auto return type,
13754 the return type is void. But if the declared type is something like
13755 auto*, this is an error. */
13756 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
13757 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
13759 if (!is_auto (current_function_auto_return_pattern
)
13760 && !current_function_returns_value
&& !current_function_returns_null
)
13762 error ("no return statements in function returning %qT",
13763 current_function_auto_return_pattern
);
13764 inform (input_location
, "only plain %<auto%> return type can be "
13765 "deduced to %<void%>");
13767 apply_deduced_return_type (fndecl
, void_type_node
);
13768 fntype
= TREE_TYPE (fndecl
);
13771 /* Save constexpr function body before it gets munged by
13772 the NRV transformation. */
13773 maybe_save_function_definition (fndecl
);
13775 /* Set up the named return value optimization, if we can. Candidate
13776 variables are selected in check_return_expr. */
13777 if (current_function_return_value
)
13779 tree r
= current_function_return_value
;
13782 if (r
!= error_mark_node
13783 /* This is only worth doing for fns that return in memory--and
13784 simpler, since we don't have to worry about promoted modes. */
13785 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
13786 /* Only allow this for variables declared in the outer scope of
13787 the function so we know that their lifetime always ends with a
13788 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13789 we were to do this optimization in tree-ssa. */
13790 && (outer
= outer_curly_brace_block (fndecl
))
13791 && chain_member (r
, BLOCK_VARS (outer
)))
13792 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
13794 current_function_return_value
= NULL_TREE
;
13797 /* Remember that we were in class scope. */
13798 if (current_class_name
)
13799 ctype
= current_class_type
;
13801 /* Must mark the RESULT_DECL as being in this function. */
13802 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13804 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13805 to the FUNCTION_DECL node itself. */
13806 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13808 /* Save away current state, if appropriate. */
13809 if (!processing_template_decl
)
13810 save_function_data (fndecl
);
13812 /* Complain if there's just no return statement. */
13813 if (warn_return_type
13814 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
13815 && !dependent_type_p (TREE_TYPE (fntype
))
13816 && !current_function_returns_value
&& !current_function_returns_null
13817 /* Don't complain if we abort or throw. */
13818 && !current_function_returns_abnormally
13819 /* Don't complain if we are declared noreturn. */
13820 && !TREE_THIS_VOLATILE (fndecl
)
13821 && !DECL_NAME (DECL_RESULT (fndecl
))
13822 && !TREE_NO_WARNING (fndecl
)
13823 /* Structor return values (if any) are set by the compiler. */
13824 && !DECL_CONSTRUCTOR_P (fndecl
)
13825 && !DECL_DESTRUCTOR_P (fndecl
)
13826 && targetm
.warn_func_return (fndecl
))
13828 warning (OPT_Wreturn_type
,
13829 "no return statement in function returning non-void");
13830 TREE_NO_WARNING (fndecl
) = 1;
13833 /* Store the end of the function, so that we get good line number
13834 info for the epilogue. */
13835 cfun
->function_end_locus
= input_location
;
13837 /* Complain about parameters that are only set, but never otherwise used. */
13838 if (warn_unused_but_set_parameter
13839 && !processing_template_decl
13840 && errorcount
== unused_but_set_errorcount
13841 && !DECL_CLONED_FUNCTION_P (fndecl
))
13845 for (decl
= DECL_ARGUMENTS (fndecl
);
13847 decl
= DECL_CHAIN (decl
))
13848 if (TREE_USED (decl
)
13849 && TREE_CODE (decl
) == PARM_DECL
13850 && !DECL_READ_P (decl
)
13851 && DECL_NAME (decl
)
13852 && !DECL_ARTIFICIAL (decl
)
13853 && !TREE_NO_WARNING (decl
)
13854 && !DECL_IN_SYSTEM_HEADER (decl
)
13855 && TREE_TYPE (decl
) != error_mark_node
13856 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13857 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
13858 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
13859 warning (OPT_Wunused_but_set_parameter
,
13860 "parameter %q+D set but not used", decl
);
13861 unused_but_set_errorcount
= errorcount
;
13864 /* Complain about locally defined typedefs that are not used in this
13866 maybe_warn_unused_local_typedefs ();
13868 /* Genericize before inlining. */
13869 if (!processing_template_decl
)
13871 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
13872 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
13873 cp_genericize (fndecl
);
13874 /* Clear out the bits we don't need. */
13875 f
->x_current_class_ptr
= NULL
;
13876 f
->x_current_class_ref
= NULL
;
13877 f
->x_eh_spec_block
= NULL
;
13878 f
->x_in_charge_parm
= NULL
;
13879 f
->x_vtt_parm
= NULL
;
13880 f
->x_return_value
= NULL
;
13881 f
->bindings
= NULL
;
13882 f
->extern_decl_map
= NULL
;
13884 /* Clear out the bits we don't need. */
13885 local_names
= NULL
;
13887 /* We're leaving the context of this function, so zap cfun. It's still in
13888 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
13890 current_function_decl
= NULL
;
13892 /* If this is an in-class inline definition, we may have to pop the
13893 bindings for the template parameters that we added in
13894 maybe_begin_member_template_processing when start_function was
13896 if (inclass_inline
)
13897 maybe_end_member_template_processing ();
13899 /* Leave the scope of the class. */
13901 pop_nested_class ();
13906 current_function_decl
= NULL_TREE
;
13908 defer_mark_used_calls
= false;
13909 if (deferred_mark_used_calls
)
13914 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
13916 vec_free (deferred_mark_used_calls
);
13922 /* Create the FUNCTION_DECL for a function definition.
13923 DECLSPECS and DECLARATOR are the parts of the declaration;
13924 they describe the return type and the name of the function,
13925 but twisted together in a fashion that parallels the syntax of C.
13927 This function creates a binding context for the function body
13928 as well as setting up the FUNCTION_DECL in current_function_decl.
13930 Returns a FUNCTION_DECL on success.
13932 If the DECLARATOR is not suitable for a function (it defines a datum
13933 instead), we return 0, which tells yyparse to report a parse error.
13935 May return void_type_node indicating that this method is actually
13936 a friend. See grokfield for more details.
13938 Came here with a `.pushlevel' .
13940 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13941 CHANGES TO CODE IN `grokfield'. */
13944 grokmethod (cp_decl_specifier_seq
*declspecs
,
13945 const cp_declarator
*declarator
, tree attrlist
)
13947 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13950 if (fndecl
== error_mark_node
)
13951 return error_mark_node
;
13953 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
13955 error ("invalid member function declaration");
13956 return error_mark_node
;
13960 cplus_decl_attributes (&fndecl
, attrlist
, 0);
13962 /* Pass friends other than inline friend functions back. */
13963 if (fndecl
== void_type_node
)
13966 if (DECL_IN_AGGR_P (fndecl
))
13968 if (DECL_CLASS_SCOPE_P (fndecl
))
13969 error ("%qD is already defined in class %qT", fndecl
,
13970 DECL_CONTEXT (fndecl
));
13971 return error_mark_node
;
13974 check_template_shadow (fndecl
);
13976 DECL_DECLARED_INLINE_P (fndecl
) = 1;
13977 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
13979 /* We process method specializations in finish_struct_1. */
13980 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
13982 fndecl
= push_template_decl (fndecl
);
13983 if (fndecl
== error_mark_node
)
13987 if (! DECL_FRIEND_P (fndecl
))
13989 if (DECL_CHAIN (fndecl
))
13991 fndecl
= copy_node (fndecl
);
13992 TREE_CHAIN (fndecl
) = NULL_TREE
;
13996 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
13998 DECL_IN_AGGR_P (fndecl
) = 1;
14003 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14004 we can lay it out later, when and if its type becomes complete. */
14007 maybe_register_incomplete_var (tree var
)
14009 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
14011 /* Keep track of variables with incomplete types. */
14012 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14013 && DECL_EXTERNAL (var
))
14015 tree inner_type
= TREE_TYPE (var
);
14017 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14018 inner_type
= TREE_TYPE (inner_type
);
14019 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14021 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14022 /* RTTI TD entries are created while defining the type_info. */
14023 || (TYPE_LANG_SPECIFIC (inner_type
)
14024 && TYPE_BEING_DEFINED (inner_type
)))
14026 incomplete_var iv
= {var
, inner_type
};
14027 vec_safe_push (incomplete_vars
, iv
);
14032 /* Called when a class type (given by TYPE) is defined. If there are
14033 any existing VAR_DECLs whose type has been completed by this
14034 declaration, update them now. */
14037 complete_vars (tree type
)
14040 incomplete_var
*iv
;
14042 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14044 if (same_type_p (type
, iv
->incomplete_type
))
14046 tree var
= iv
->decl
;
14047 tree type
= TREE_TYPE (var
);
14048 /* Complete the type of the variable. The VAR_DECL itself
14049 will be laid out in expand_expr. */
14050 complete_type (type
);
14051 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14052 /* Remove this entry from the list. */
14053 incomplete_vars
->unordered_remove (ix
);
14059 /* Check for pending declarations which may have abstract type. */
14060 complete_type_check_abstract (type
);
14063 /* If DECL is of a type which needs a cleanup, build and return an
14064 expression to perform that cleanup here. Return NULL_TREE if no
14065 cleanup need be done. */
14068 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14074 /* Assume no cleanup is required. */
14075 cleanup
= NULL_TREE
;
14077 if (error_operand_p (decl
))
14080 /* Handle "__attribute__((cleanup))". We run the cleanup function
14081 before the destructor since the destructor is what actually
14082 terminates the lifetime of the object. */
14083 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14090 /* Get the name specified by the user for the cleanup function. */
14091 id
= TREE_VALUE (TREE_VALUE (attr
));
14092 /* Look up the name to find the cleanup function to call. It is
14093 important to use lookup_name here because that is what is
14094 used in c-common.c:handle_cleanup_attribute when performing
14095 initial checks on the attribute. Note that those checks
14096 include ensuring that the function found is not an overloaded
14097 function, or an object with an overloaded call operator,
14098 etc.; we can rely on the fact that the function found is an
14099 ordinary FUNCTION_DECL. */
14100 fn
= lookup_name (id
);
14101 arg
= build_address (decl
);
14103 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14104 if (cleanup
== error_mark_node
)
14105 return error_mark_node
;
14107 /* Handle ordinary C++ destructors. */
14108 type
= TREE_TYPE (decl
);
14109 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
14111 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14112 bool has_vbases
= (TREE_CODE (type
) == RECORD_TYPE
14113 && CLASSTYPE_VBASECLASSES (type
));
14117 if (TREE_CODE (type
) == ARRAY_TYPE
)
14120 addr
= build_address (decl
);
14122 /* Optimize for space over speed here. */
14123 if (!has_vbases
|| flag_expensive_optimizations
)
14124 flags
|= LOOKUP_NONVIRTUAL
;
14126 call
= build_delete (TREE_TYPE (addr
), addr
,
14127 sfk_complete_destructor
, flags
, 0, complain
);
14128 if (call
== error_mark_node
)
14129 cleanup
= error_mark_node
;
14131 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14136 /* build_delete sets the location of the destructor call to the
14137 current location, even though the destructor is going to be
14138 called later, at the end of the current scope. This can lead to
14139 a "jumpy" behaviour for users of debuggers when they step around
14140 the end of the block. So let's unset the location of the
14141 destructor call instead. */
14142 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14143 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14148 /* When a stmt has been parsed, this function is called. */
14155 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14156 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14157 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14160 static_fn_type (tree memfntype
)
14165 if (TYPE_PTRMEMFUNC_P (memfntype
))
14166 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14167 if (POINTER_TYPE_P (memfntype
)
14168 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14169 memfntype
= TREE_TYPE (memfntype
);
14170 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14172 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14173 args
= TYPE_ARG_TYPES (memfntype
);
14174 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14175 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
));
14176 fntype
= (cp_build_type_attribute_variant
14177 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14178 fntype
= (build_exception_variant
14179 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14183 /* DECL was originally constructed as a non-static member function,
14184 but turned out to be static. Update it accordingly. */
14187 revert_static_member_fn (tree decl
)
14189 tree stype
= static_fn_type (decl
);
14190 cp_cv_quals quals
= type_memfn_quals (stype
);
14192 if (quals
!= TYPE_UNQUALIFIED
)
14193 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
);
14195 TREE_TYPE (decl
) = stype
;
14197 if (DECL_ARGUMENTS (decl
))
14198 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14199 DECL_STATIC_FUNCTION_P (decl
) = 1;
14202 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14203 one of the language-independent trees. */
14205 enum cp_tree_node_structure_enum
14206 cp_tree_node_structure (union lang_tree_node
* t
)
14208 switch (TREE_CODE (&t
->generic
))
14210 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14211 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14212 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14213 case OVERLOAD
: return TS_CP_OVERLOAD
;
14214 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14215 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14216 case BASELINK
: return TS_CP_BASELINK
;
14217 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14218 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14219 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14220 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14221 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14222 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14223 default: return TS_CP_GENERIC
;
14227 /* Build the void_list_node (void_type_node having been created). */
14229 build_void_list_node (void)
14231 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14236 cp_missing_noreturn_ok_p (tree decl
)
14238 /* A missing noreturn is ok for the `main' function. */
14239 return DECL_MAIN_P (decl
);
14242 /* Return the COMDAT group into which DECL should be placed. */
14245 cxx_comdat_group (tree decl
)
14249 /* Virtual tables, construction virtual tables, and virtual table
14250 tables all go in a single COMDAT group, named after the primary
14252 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VTABLE_OR_VTT_P (decl
))
14253 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
14254 /* For all other DECLs, the COMDAT group is the mangled name of the
14255 declaration itself. */
14258 while (DECL_THUNK_P (decl
))
14260 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14261 into the same section as the target function. In that case
14262 we must return target's name. */
14263 tree target
= THUNK_TARGET (decl
);
14264 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14265 && DECL_SECTION_NAME (target
) != NULL
14266 && DECL_ONE_ONLY (target
))
14271 name
= DECL_ASSEMBLER_NAME (decl
);
14277 #include "gt-cp-decl.h"