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
);
4838 else if (failure
== 2)
4842 error ("array size missing in %qD", decl
);
4844 /* If a `static' var's size isn't known, make it extern as
4845 well as static, so it does not get allocated. If it's not
4846 `static', then don't mark it extern; finish_incomplete_decl
4847 will give it a default size and it will get allocated. */
4848 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4849 DECL_EXTERNAL (decl
) = 1;
4851 else if (failure
== 3)
4853 error ("zero-size array %qD", decl
);
4857 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4859 relayout_decl (decl
);
4863 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4864 any appropriate error messages regarding the layout. */
4867 layout_var_decl (tree decl
)
4871 type
= TREE_TYPE (decl
);
4872 if (type
== error_mark_node
)
4875 /* If we haven't already layed out this declaration, do so now.
4876 Note that we must not call complete type for an external object
4877 because it's type might involve templates that we are not
4878 supposed to instantiate yet. (And it's perfectly valid to say
4879 `extern X x' for some incomplete type `X'.) */
4880 if (!DECL_EXTERNAL (decl
))
4881 complete_type (type
);
4882 if (!DECL_SIZE (decl
)
4883 && TREE_TYPE (decl
) != error_mark_node
4884 && (COMPLETE_TYPE_P (type
)
4885 || (TREE_CODE (type
) == ARRAY_TYPE
4886 && !TYPE_DOMAIN (type
)
4887 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4888 layout_decl (decl
, 0);
4890 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4892 /* An automatic variable with an incomplete type: that is an error.
4893 Don't talk about array types here, since we took care of that
4894 message in grokdeclarator. */
4895 error ("storage size of %qD isn%'t known", decl
);
4896 TREE_TYPE (decl
) = error_mark_node
;
4899 /* Keep this code around in case we later want to control debug info
4900 based on whether a type is "used". (jason 1999-11-11) */
4902 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4903 /* Let debugger know it should output info for this type. */
4904 note_debug_info_needed (ttype
);
4906 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4907 note_debug_info_needed (DECL_CONTEXT (decl
));
4910 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4911 && DECL_SIZE (decl
) != NULL_TREE
4912 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4914 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4915 constant_expression_warning (DECL_SIZE (decl
));
4918 error ("storage size of %qD isn%'t constant", decl
);
4919 TREE_TYPE (decl
) = error_mark_node
;
4924 /* If a local static variable is declared in an inline function, or if
4925 we have a weak definition, we must endeavor to create only one
4926 instance of the variable at link-time. */
4929 maybe_commonize_var (tree decl
)
4931 /* Static data in a function with comdat linkage also has comdat
4933 if (TREE_STATIC (decl
)
4934 /* Don't mess with __FUNCTION__. */
4935 && ! DECL_ARTIFICIAL (decl
)
4936 && DECL_FUNCTION_SCOPE_P (decl
)
4937 && vague_linkage_p (DECL_CONTEXT (decl
)))
4941 /* With weak symbols, we simply make the variable COMDAT;
4942 that will cause copies in multiple translations units to
4944 comdat_linkage (decl
);
4948 if (DECL_INITIAL (decl
) == NULL_TREE
4949 || DECL_INITIAL (decl
) == error_mark_node
)
4951 /* Without weak symbols, we can use COMMON to merge
4952 uninitialized variables. */
4953 TREE_PUBLIC (decl
) = 1;
4954 DECL_COMMON (decl
) = 1;
4958 /* While for initialized variables, we must use internal
4959 linkage -- which means that multiple copies will not
4961 TREE_PUBLIC (decl
) = 0;
4962 DECL_COMMON (decl
) = 0;
4963 warning_at (input_location
, 0,
4964 "sorry: semantics of inline function static "
4965 "data %q+#D are wrong (you%'ll wind up "
4966 "with multiple copies)", decl
);
4967 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4968 " you can work around this by removing "
4973 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4974 /* Set it up again; we might have set DECL_INITIAL since the last
4976 comdat_linkage (decl
);
4979 /* Issue an error message if DECL is an uninitialized const variable. */
4982 check_for_uninitialized_const_var (tree decl
)
4984 tree type
= strip_array_types (TREE_TYPE (decl
));
4986 /* ``Unless explicitly declared extern, a const object does not have
4987 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4989 if (TREE_CODE (decl
) == VAR_DECL
4990 && TREE_CODE (type
) != REFERENCE_TYPE
4991 && CP_TYPE_CONST_P (type
)
4992 && !DECL_INITIAL (decl
))
4994 tree field
= default_init_uninitialized_part (type
);
4998 permerror (DECL_SOURCE_LOCATION (decl
),
4999 "uninitialized const %qD", decl
);
5001 if (CLASS_TYPE_P (type
))
5003 tree defaulted_ctor
;
5005 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5006 "%q#T has no user-provided default constructor", type
);
5007 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5009 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5010 "constructor is not user-provided because it is "
5011 "explicitly defaulted in the class body");
5012 inform (0, "and the implicitly-defined constructor does not "
5013 "initialize %q+#D", field
);
5018 /* Structure holding the current initializer being processed by reshape_init.
5019 CUR is a pointer to the current element being processed, END is a pointer
5020 after the last element present in the initializer. */
5021 typedef struct reshape_iterator_t
5023 constructor_elt
*cur
;
5024 constructor_elt
*end
;
5027 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5029 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5030 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5031 initialized. If there are no more such fields, the return value
5035 next_initializable_field (tree field
)
5038 && (TREE_CODE (field
) != FIELD_DECL
5039 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5040 || DECL_ARTIFICIAL (field
)))
5041 field
= DECL_CHAIN (field
);
5046 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5047 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5048 INTEGER_CST representing the size of the array minus one (the maximum index),
5049 or NULL_TREE if the array was declared without specifying the size. D is
5050 the iterator within the constructor. */
5053 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5054 tsubst_flags_t complain
)
5057 bool sized_array_p
= (max_index
!= NULL_TREE
);
5058 unsigned HOST_WIDE_INT max_index_cst
= 0;
5059 unsigned HOST_WIDE_INT index
;
5061 /* The initializer for an array is always a CONSTRUCTOR. */
5062 new_init
= build_constructor (init_list_type_node
, NULL
);
5066 /* Minus 1 is used for zero sized arrays. */
5067 if (integer_all_onesp (max_index
))
5070 if (host_integerp (max_index
, 1))
5071 max_index_cst
= tree_low_cst (max_index
, 1);
5072 /* sizetype is sign extended, not zero extended. */
5074 max_index_cst
= tree_low_cst (fold_convert (size_type_node
, max_index
),
5078 /* Loop until there are no more initializers. */
5080 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5084 constructor_elt
*old_cur
= d
->cur
;
5086 check_array_designated_initializer (d
->cur
, index
);
5087 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5089 if (elt_init
== error_mark_node
)
5090 return error_mark_node
;
5091 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5092 size_int (index
), elt_init
);
5093 if (!TREE_CONSTANT (elt_init
))
5094 TREE_CONSTANT (new_init
) = false;
5096 /* This can happen with an invalid initializer (c++/54501). */
5097 if (d
->cur
== old_cur
&& !sized_array_p
)
5104 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5105 Parameters are the same of reshape_init_r. */
5108 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5110 tree max_index
= NULL_TREE
;
5112 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5114 if (TYPE_DOMAIN (type
))
5115 max_index
= array_type_nelts (type
);
5117 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5120 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5121 Parameters are the same of reshape_init_r. */
5124 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5126 tree max_index
= NULL_TREE
;
5128 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
5130 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5132 tree value
= d
->cur
->value
;
5133 if (!same_type_p (TREE_TYPE (value
), type
))
5135 if (complain
& tf_error
)
5136 error ("invalid type %qT as initializer for a vector of type %qT",
5137 TREE_TYPE (d
->cur
->value
), type
);
5138 value
= error_mark_node
;
5144 /* For a vector, we initialize it as an array of the appropriate size. */
5145 if (TREE_CODE (type
) == VECTOR_TYPE
)
5146 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5148 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5151 /* Subroutine of reshape_init_r, processes the initializers for classes
5152 or union. Parameters are the same of reshape_init_r. */
5155 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5156 tsubst_flags_t complain
)
5161 gcc_assert (CLASS_TYPE_P (type
));
5163 /* The initializer for a class is always a CONSTRUCTOR. */
5164 new_init
= build_constructor (init_list_type_node
, NULL
);
5165 field
= next_initializable_field (TYPE_FIELDS (type
));
5171 An initializer for an aggregate member that is an
5172 empty class shall have the form of an empty
5173 initializer-list {}. */
5174 if (!first_initializer_p
)
5176 if (complain
& tf_error
)
5177 error ("initializer for %qT must be brace-enclosed", type
);
5178 return error_mark_node
;
5183 /* Loop through the initializable fields, gathering initializers. */
5184 while (d
->cur
!= d
->end
)
5187 constructor_elt
*old_cur
= d
->cur
;
5189 /* Handle designated initializers, as an extension. */
5192 if (TREE_CODE (d
->cur
->index
) == INTEGER_CST
)
5194 if (complain
& tf_error
)
5195 error ("%<[%E] =%> used in a GNU-style designated initializer"
5196 " for class %qT", d
->cur
->index
, type
);
5197 return error_mark_node
;
5200 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5201 /* We already reshaped this. */
5202 gcc_assert (d
->cur
->index
== field
);
5204 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5206 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5208 if (complain
& tf_error
)
5209 error ("%qT has no non-static data member named %qD", type
,
5211 return error_mark_node
;
5215 /* If we processed all the member of the class, we are done. */
5219 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5220 /*first_initializer_p=*/false, complain
);
5221 if (field_init
== error_mark_node
)
5222 return error_mark_node
;
5224 if (d
->cur
== old_cur
&& d
->cur
->index
)
5226 /* This can happen with an invalid initializer for a flexible
5227 array member (c++/54441). */
5228 if (complain
& tf_error
)
5229 error ("invalid initializer for %q#D", field
);
5230 return error_mark_node
;
5233 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5237 When a union is initialized with a brace-enclosed
5238 initializer, the braces shall only contain an
5239 initializer for the first member of the union. */
5240 if (TREE_CODE (type
) == UNION_TYPE
)
5243 field
= next_initializable_field (DECL_CHAIN (field
));
5249 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5250 designators are not valid; either complain or return true to indicate
5251 that reshape_init_r should return error_mark_node. */
5254 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5258 if (complain
& tf_error
)
5259 error ("C99 designator %qE outside aggregate initializer",
5267 /* Subroutine of reshape_init, which processes a single initializer (part of
5268 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5269 iterator within the CONSTRUCTOR which points to the initializer to process.
5270 FIRST_INITIALIZER_P is true if this is the first initializer of the
5271 outermost CONSTRUCTOR node. */
5274 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5275 tsubst_flags_t complain
)
5277 tree init
= d
->cur
->value
;
5279 if (error_operand_p (init
))
5280 return error_mark_node
;
5282 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5283 && has_designator_problem (d
, complain
))
5284 return error_mark_node
;
5286 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5288 /* A complex type can be initialized from one or two initializers,
5289 but braces are not elided. */
5291 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5293 if (CONSTRUCTOR_NELTS (init
) > 2)
5295 if (complain
& tf_error
)
5296 error ("too many initializers for %qT", type
);
5298 return error_mark_node
;
5301 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5303 vec
<constructor_elt
, va_gc
> *v
= 0;
5304 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5305 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5306 if (has_designator_problem (d
, complain
))
5307 return error_mark_node
;
5309 init
= build_constructor (init_list_type_node
, v
);
5314 /* A non-aggregate type is always initialized with a single
5316 if (!CP_AGGREGATE_TYPE_P (type
))
5318 /* It is invalid to initialize a non-aggregate type with a
5319 brace-enclosed initializer before C++0x.
5320 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5321 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5322 a CONSTRUCTOR (with a record type). */
5323 if (TREE_CODE (init
) == CONSTRUCTOR
5324 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5326 if (SCALAR_TYPE_P (type
))
5328 if (complain
& tf_error
)
5329 error ("braces around scalar initializer for type %qT", type
);
5330 init
= error_mark_node
;
5333 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5342 All implicit type conversions (clause _conv_) are considered when
5343 initializing the aggregate member with an initializer from an
5344 initializer-list. If the initializer can initialize a member,
5345 the member is initialized. Otherwise, if the member is itself a
5346 non-empty subaggregate, brace elision is assumed and the
5347 initializer is considered for the initialization of the first
5348 member of the subaggregate. */
5349 if (TREE_CODE (init
) != CONSTRUCTOR
5350 /* But don't try this for the first initializer, since that would be
5351 looking through the outermost braces; A a2 = { a1 }; is not a
5352 valid aggregate initialization. */
5353 && !first_initializer_p
5354 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5355 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5362 /* [dcl.init.string]
5364 A char array (whether plain char, signed char, or unsigned char)
5365 can be initialized by a string-literal (optionally enclosed in
5366 braces); a wchar_t array can be initialized by a wide
5367 string-literal (optionally enclosed in braces). */
5368 if (TREE_CODE (type
) == ARRAY_TYPE
5369 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5371 tree str_init
= init
;
5373 /* Strip one level of braces if and only if they enclose a single
5374 element (as allowed by [dcl.init.string]). */
5375 if (!first_initializer_p
5376 && TREE_CODE (str_init
) == CONSTRUCTOR
5377 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5379 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5382 /* If it's a string literal, then it's the initializer for the array
5383 as a whole. Otherwise, continue with normal initialization for
5384 array types (one value per array element). */
5385 if (TREE_CODE (str_init
) == STRING_CST
)
5387 if (has_designator_problem (d
, complain
))
5388 return error_mark_node
;
5394 /* The following cases are about aggregates. If we are not within a full
5395 initializer already, and there is not a CONSTRUCTOR, it means that there
5396 is a missing set of braces (that is, we are processing the case for
5397 which reshape_init exists). */
5398 if (!first_initializer_p
)
5400 if (TREE_CODE (init
) == CONSTRUCTOR
)
5402 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5403 /* There is no need to reshape pointer-to-member function
5404 initializers, as they are always constructed correctly
5405 by the front end. */
5407 else if (COMPOUND_LITERAL_P (init
))
5408 /* For a nested compound literal, there is no need to reshape since
5409 brace elision is not allowed. Even if we decided to allow it,
5410 we should add a call to reshape_init in finish_compound_literal,
5411 before calling digest_init, so changing this code would still
5412 not be necessary. */
5413 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5417 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5418 return reshape_init (type
, init
, complain
);
5422 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5426 /* Dispatch to specialized routines. */
5427 if (CLASS_TYPE_P (type
))
5428 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5429 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5430 return reshape_init_array (type
, d
, complain
);
5431 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5432 return reshape_init_vector (type
, d
, complain
);
5437 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5438 brace-enclosed aggregate initializer.
5440 INIT is the CONSTRUCTOR containing the list of initializers describing
5441 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5442 It may not presently match the shape of the TYPE; for example:
5444 struct S { int a; int b; };
5445 struct S a[] = { 1, 2, 3, 4 };
5447 Here INIT will hold a vector of four elements, rather than a
5448 vector of two elements, each itself a vector of two elements. This
5449 routine transforms INIT from the former form into the latter. The
5450 revised CONSTRUCTOR node is returned. */
5453 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5455 vec
<constructor_elt
, va_gc
> *v
;
5459 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5461 v
= CONSTRUCTOR_ELTS (init
);
5463 /* An empty constructor does not need reshaping, and it is always a valid
5465 if (vec_safe_is_empty (v
))
5468 /* Recurse on this CONSTRUCTOR. */
5470 d
.end
= d
.cur
+ v
->length ();
5472 new_init
= reshape_init_r (type
, &d
, true, complain
);
5473 if (new_init
== error_mark_node
)
5474 return error_mark_node
;
5476 /* Make sure all the element of the constructor were used. Otherwise,
5477 issue an error about exceeding initializers. */
5480 if (complain
& tf_error
)
5481 error ("too many initializers for %qT", type
);
5483 return error_mark_node
;
5489 /* Verify array initializer. Returns true if errors have been reported. */
5492 check_array_initializer (tree decl
, tree type
, tree init
)
5494 tree element_type
= TREE_TYPE (type
);
5496 /* The array type itself need not be complete, because the
5497 initializer may tell us how many elements are in the array.
5498 But, the elements of the array must be complete. */
5499 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5502 error ("elements of array %q#D have incomplete type", decl
);
5504 error ("elements of array %q#T have incomplete type", type
);
5507 /* It is not valid to initialize a VLA. */
5509 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5510 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5513 error ("variable-sized object %qD may not be initialized", decl
);
5515 error ("variable-sized compound literal");
5521 /* Subroutine of check_initializer; args are passed down from that function.
5522 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5525 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5528 gcc_assert (stmts_are_full_exprs_p ());
5529 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5532 /* Verify INIT (the initializer for DECL), and record the
5533 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5534 grok_reference_init.
5536 If the return value is non-NULL, it is an expression that must be
5537 evaluated dynamically to initialize DECL. */
5540 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5542 tree type
= TREE_TYPE (decl
);
5543 tree init_code
= NULL
;
5544 tree extra_init
= NULL_TREE
;
5547 /* Things that are going to be initialized need to have complete
5549 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5551 if (DECL_HAS_VALUE_EXPR_P (decl
))
5553 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5554 it doesn't have storage to be initialized. */
5555 gcc_assert (init
== NULL_TREE
);
5559 if (type
== error_mark_node
)
5560 /* We will have already complained. */
5563 if (TREE_CODE (type
) == ARRAY_TYPE
)
5565 if (check_array_initializer (decl
, type
, init
))
5568 else if (!COMPLETE_TYPE_P (type
))
5570 error ("%q#D has incomplete type", decl
);
5571 TREE_TYPE (decl
) = error_mark_node
;
5575 /* There is no way to make a variable-sized class type in GNU C++. */
5576 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5578 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5580 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5581 if (SCALAR_TYPE_P (type
))
5585 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5586 init
= build_zero_init (type
, NULL_TREE
, false);
5588 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5590 error ("scalar object %qD requires one element in initializer",
5592 TREE_TYPE (decl
) = error_mark_node
;
5598 if (TREE_CODE (decl
) == CONST_DECL
)
5600 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5602 DECL_INITIAL (decl
) = init
;
5604 gcc_assert (init
!= NULL_TREE
);
5607 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5609 else if (init
|| type_build_ctor_call (type
)
5610 || TREE_CODE (type
) == REFERENCE_TYPE
)
5612 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5614 init
= grok_reference_init (decl
, type
, init
, flags
);
5615 flags
|= LOOKUP_ALREADY_DIGESTED
;
5618 check_for_uninitialized_const_var (decl
);
5619 /* Do not reshape constructors of vectors (they don't need to be
5621 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5623 if (is_std_init_list (type
))
5625 init
= perform_implicit_conversion (type
, init
,
5626 tf_warning_or_error
);
5627 flags
|= LOOKUP_ALREADY_DIGESTED
;
5629 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5631 /* Don't reshape if the class has constructors. */
5632 if (cxx_dialect
== cxx98
)
5633 error ("in C++98 %qD must be initialized by constructor, "
5637 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5639 error ("opaque vector types cannot be initialized");
5640 init
= error_mark_node
;
5644 init
= reshape_init (type
, init
, tf_warning_or_error
);
5645 if (SCALAR_TYPE_P (type
))
5646 check_narrowing (type
, init
);
5650 /* If DECL has an array type without a specific bound, deduce the
5651 array size from the initializer. */
5652 maybe_deduce_size_from_array_init (decl
, init
);
5653 type
= TREE_TYPE (decl
);
5654 if (type
== error_mark_node
)
5657 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5658 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5659 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5660 && CP_AGGREGATE_TYPE_P (type
)
5661 && (CLASS_TYPE_P (type
)
5662 || type_has_extended_temps (type
))))
5664 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5666 /* A constructor call is a non-trivial initializer even if
5667 it isn't explicitly written. */
5668 if (TREE_SIDE_EFFECTS (init_code
))
5669 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5671 /* If this is a constexpr initializer, expand_default_init will
5672 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5673 case, pull the initializer back out and pass it down into
5674 store_init_value. */
5675 while (TREE_CODE (init_code
) == EXPR_STMT
5676 || TREE_CODE (init_code
) == CONVERT_EXPR
)
5677 init_code
= TREE_OPERAND (init_code
, 0);
5678 if (TREE_CODE (init_code
) == INIT_EXPR
)
5680 init
= TREE_OPERAND (init_code
, 1);
5681 init_code
= NULL_TREE
;
5682 /* Don't call digest_init; it's unnecessary and will complain
5683 about aggregate initialization of non-aggregate classes. */
5684 flags
|= LOOKUP_ALREADY_DIGESTED
;
5686 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
5688 /* Declared constexpr, but no suitable initializer; massage
5689 init appropriately so we can pass it into store_init_value
5691 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5692 init
= finish_compound_literal (type
, init
,
5693 tf_warning_or_error
);
5694 else if (CLASS_TYPE_P (type
)
5695 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
5697 init
= build_functional_cast (type
, init
, tf_none
);
5698 if (init
!= error_mark_node
)
5699 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
5701 init_code
= NULL_TREE
;
5707 if (init
&& TREE_CODE (init
) != TREE_VEC
)
5709 /* In aggregate initialization of a variable, each element
5710 initialization is a full-expression because there is no
5711 enclosing expression. */
5712 gcc_assert (stmts_are_full_exprs_p ());
5714 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
5716 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5717 && DECL_INITIAL (decl
)
5718 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5719 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5720 warning (0, "array %qD initialized by parenthesized string literal %qE",
5721 decl
, DECL_INITIAL (decl
));
5727 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
5728 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
5729 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
5730 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
5733 check_for_uninitialized_const_var (decl
);
5736 if (init
&& init
!= error_mark_node
)
5737 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5740 init_code
= add_stmt_to_compound (extra_init
, init_code
);
5742 if (init_code
&& DECL_IN_AGGR_P (decl
))
5744 static int explained
= 0;
5746 if (cxx_dialect
< cxx0x
)
5747 error ("initializer invalid for static member with constructor");
5749 error ("non-constant in-class initialization invalid for static "
5750 "member %qD", decl
);
5753 error ("(an out of class initialization is required)");
5761 /* If DECL is not a local variable, give it RTL. */
5764 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5766 int toplev
= toplevel_bindings_p ();
5768 const char *filename
;
5770 /* Set the DECL_ASSEMBLER_NAME for the object. */
5773 /* The `register' keyword, when used together with an
5774 asm-specification, indicates that the variable should be
5775 placed in a particular register. */
5776 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
5778 set_user_assembler_name (decl
, asmspec
);
5779 DECL_HARD_REGISTER (decl
) = 1;
5783 if (TREE_CODE (decl
) == FUNCTION_DECL
5784 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5785 set_builtin_user_assembler_name (decl
, asmspec
);
5786 set_user_assembler_name (decl
, asmspec
);
5790 /* Handle non-variables up front. */
5791 if (TREE_CODE (decl
) != VAR_DECL
)
5793 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5797 /* If we see a class member here, it should be a static data
5799 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5801 gcc_assert (TREE_STATIC (decl
));
5802 /* An in-class declaration of a static data member should be
5803 external; it is only a declaration, and not a definition. */
5804 if (init
== NULL_TREE
)
5805 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5808 /* We don't create any RTL for local variables. */
5809 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5812 /* We defer emission of local statics until the corresponding
5813 DECL_EXPR is expanded. */
5814 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5816 /* We try to defer namespace-scope static constants so that they are
5817 not emitted into the object file unnecessarily. */
5818 filename
= input_filename
;
5819 if (!DECL_VIRTUAL_P (decl
)
5820 && TREE_READONLY (decl
)
5821 && DECL_INITIAL (decl
) != NULL_TREE
5822 && DECL_INITIAL (decl
) != error_mark_node
5824 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5826 && !TREE_PUBLIC (decl
))
5828 /* Fool with the linkage of static consts according to #pragma
5830 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5831 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5833 TREE_PUBLIC (decl
) = 1;
5834 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5839 /* Likewise for template instantiations. */
5840 else if (DECL_LANG_SPECIFIC (decl
)
5841 && DECL_IMPLICIT_INSTANTIATION (decl
))
5844 /* If we're not deferring, go ahead and assemble the variable. */
5846 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5849 /* walk_tree helper for wrap_temporary_cleanups, below. */
5852 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5854 /* Stop at types or full-expression boundaries. */
5855 if (TYPE_P (*stmt_p
)
5856 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
5862 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5864 tree guard
= (tree
)data
;
5865 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5867 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5868 /* Tell honor_protect_cleanup_actions to handle this as a separate
5870 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5872 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5878 /* We're initializing a local variable which has a cleanup GUARD. If there
5879 are any temporaries used in the initializer INIT of this variable, we
5880 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5881 variable will be cleaned up properly if one of them throws.
5883 Unfortunately, there's no way to express this properly in terms of
5884 nesting, as the regions for the temporaries overlap the region for the
5885 variable itself; if there are two temporaries, the variable needs to be
5886 the first thing destroyed if either of them throws. However, we only
5887 want to run the variable's cleanup if it actually got constructed. So
5888 we need to guard the temporary cleanups with the variable's cleanup if
5889 they are run on the normal path, but not if they are run on the
5890 exceptional path. We implement this by telling
5891 honor_protect_cleanup_actions to strip the variable cleanup from the
5892 exceptional path. */
5895 wrap_temporary_cleanups (tree init
, tree guard
)
5897 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5900 /* Generate code to initialize DECL (a local variable). */
5903 initialize_local_var (tree decl
, tree init
)
5905 tree type
= TREE_TYPE (decl
);
5909 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5910 || TREE_CODE (decl
) == RESULT_DECL
);
5911 gcc_assert (!TREE_STATIC (decl
));
5913 if (DECL_SIZE (decl
) == NULL_TREE
)
5915 /* If we used it already as memory, it must stay in memory. */
5916 DECL_INITIAL (decl
) = NULL_TREE
;
5917 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5921 if (type
== error_mark_node
)
5924 /* Compute and store the initial value. */
5925 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5926 if (TREE_USED (type
))
5927 DECL_READ_P (decl
) = 1;
5929 /* Generate a cleanup, if necessary. */
5930 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
5932 /* Perform the initialization. */
5935 if (TREE_CODE (init
) == INIT_EXPR
5936 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init
, 1)))
5938 /* Stick simple initializers in DECL_INITIAL so that
5939 -Wno-init-self works (c++/34772). */
5940 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
5941 DECL_INITIAL (decl
) = TREE_OPERAND (init
, 1);
5945 int saved_stmts_are_full_exprs_p
;
5947 /* If we're only initializing a single object, guard the
5948 destructors of any temporaries used in its initializer with
5949 its destructor. This isn't right for arrays because each
5950 element initialization is a full-expression. */
5951 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
5952 wrap_temporary_cleanups (init
, cleanup
);
5954 gcc_assert (building_stmt_list_p ());
5955 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5956 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5957 finish_expr_stmt (init
);
5958 current_stmt_tree ()->stmts_are_full_exprs_p
=
5959 saved_stmts_are_full_exprs_p
;
5963 /* Set this to 0 so we can tell whether an aggregate which was
5964 initialized was ever used. Don't do this if it has a
5965 destructor, so we don't complain about the 'resource
5966 allocation is initialization' idiom. Now set
5967 attribute((unused)) on types so decls of that type will be
5968 marked used. (see TREE_USED, above.) */
5969 if (TYPE_NEEDS_CONSTRUCTING (type
)
5971 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
5972 && DECL_NAME (decl
))
5973 TREE_USED (decl
) = 0;
5974 else if (already_used
)
5975 TREE_USED (decl
) = 1;
5978 finish_decl_cleanup (decl
, cleanup
);
5981 /* DECL is a VAR_DECL for a compiler-generated variable with static
5982 storage duration (like a virtual table) whose initializer is a
5983 compile-time constant. Initialize the variable and provide it to the
5987 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
5990 gcc_assert (DECL_ARTIFICIAL (decl
));
5991 init
= build_constructor (TREE_TYPE (decl
), v
);
5992 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
5993 DECL_INITIAL (decl
) = init
;
5994 DECL_INITIALIZED_P (decl
) = 1;
5995 determine_visibility (decl
);
5996 layout_var_decl (decl
);
5997 maybe_commonize_var (decl
);
5998 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6001 /* INIT is the initializer for a variable, as represented by the
6002 parser. Returns true iff INIT is type-dependent. */
6005 type_dependent_init_p (tree init
)
6007 if (TREE_CODE (init
) == TREE_LIST
)
6008 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6009 return any_type_dependent_elements_p (init
);
6010 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6011 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6013 vec
<constructor_elt
, va_gc
> *elts
;
6017 elts
= CONSTRUCTOR_ELTS (init
);
6018 nelts
= vec_safe_length (elts
);
6019 for (i
= 0; i
< nelts
; ++i
)
6020 if (type_dependent_init_p ((*elts
)[i
].value
))
6024 /* It must be a simple expression, e.g., int i = 3; */
6025 return type_dependent_expression_p (init
);
6030 /* INIT is the initializer for a variable, as represented by the
6031 parser. Returns true iff INIT is value-dependent. */
6034 value_dependent_init_p (tree init
)
6036 if (TREE_CODE (init
) == TREE_LIST
)
6037 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6038 return any_value_dependent_elements_p (init
);
6039 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6040 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6042 vec
<constructor_elt
, va_gc
> *elts
;
6046 elts
= CONSTRUCTOR_ELTS (init
);
6047 nelts
= vec_safe_length (elts
);
6048 for (i
= 0; i
< nelts
; ++i
)
6049 if (value_dependent_init_p ((*elts
)[i
].value
))
6053 /* It must be a simple expression, e.g., int i = 3; */
6054 return value_dependent_expression_p (init
);
6059 /* Finish processing of a declaration;
6060 install its line number and initial value.
6061 If the length of an array type is not known before,
6062 it must be determined now, from the initial value, or it is an error.
6064 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6065 true, then INIT is an integral constant expression.
6067 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6068 if the (init) syntax was used. */
6071 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6072 tree asmspec_tree
, int flags
)
6075 vec
<tree
, va_gc
> *cleanups
= NULL
;
6076 const char *asmspec
= NULL
;
6077 int was_readonly
= 0;
6078 bool var_definition_p
= false;
6081 if (decl
== error_mark_node
)
6086 error ("assignment (not initialization) in declaration");
6090 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6091 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6092 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6094 type
= TREE_TYPE (decl
);
6095 if (type
== error_mark_node
)
6098 /* If a name was specified, get the string. */
6099 if (at_namespace_scope_p ())
6100 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6101 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6102 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6104 if (current_class_type
6105 && CP_DECL_CONTEXT (decl
) == current_class_type
6106 && TYPE_BEING_DEFINED (current_class_type
)
6107 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6108 && (DECL_INITIAL (decl
) || init
))
6109 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6111 if (TREE_CODE (decl
) != FUNCTION_DECL
6112 && (auto_node
= type_uses_auto (type
)))
6115 if (init
== NULL_TREE
)
6117 error ("declaration of %q#D has no initializer", decl
);
6118 TREE_TYPE (decl
) = error_mark_node
;
6122 if (TREE_CODE (d_init
) == TREE_LIST
)
6123 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6124 tf_warning_or_error
);
6125 d_init
= resolve_nondeduced_context (d_init
);
6126 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6128 if (type
== error_mark_node
)
6132 if (!ensure_literal_type_for_constexpr_object (decl
))
6133 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6135 if (TREE_CODE (decl
) == VAR_DECL
6136 && DECL_CLASS_SCOPE_P (decl
)
6137 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6138 check_static_variable_definition (decl
, type
);
6140 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6143 if (init
== ridpointers
[(int)RID_DELETE
])
6145 /* FIXME check this is 1st decl. */
6146 DECL_DELETED_FN (decl
) = 1;
6147 DECL_DECLARED_INLINE_P (decl
) = 1;
6148 DECL_INITIAL (decl
) = error_mark_node
;
6149 FOR_EACH_CLONE (clone
, decl
)
6151 DECL_DELETED_FN (clone
) = 1;
6152 DECL_DECLARED_INLINE_P (clone
) = 1;
6153 DECL_INITIAL (clone
) = error_mark_node
;
6157 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6159 if (defaultable_fn_check (decl
))
6160 DECL_DEFAULTED_FN (decl
) = 1;
6162 DECL_INITIAL (decl
) = NULL_TREE
;
6166 if (init
&& TREE_CODE (decl
) == VAR_DECL
)
6168 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6169 /* If DECL is a reference, then we want to know whether init is a
6170 reference constant; init_const_expr_p as passed tells us whether
6171 it's an rvalue constant. */
6172 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6173 init_const_expr_p
= potential_constant_expression (init
);
6174 if (init_const_expr_p
)
6176 /* Set these flags now for templates. We'll update the flags in
6177 store_init_value for instantiations. */
6178 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6179 if (decl_maybe_constant_var_p (decl
))
6180 TREE_CONSTANT (decl
) = 1;
6184 if (processing_template_decl
)
6186 bool type_dependent_p
;
6188 /* Add this declaration to the statement-tree. */
6189 if (at_function_scope_p ())
6190 add_decl_expr (decl
);
6192 type_dependent_p
= dependent_type_p (type
);
6194 if (check_for_bare_parameter_packs (init
))
6197 DECL_INITIAL (decl
) = NULL_TREE
;
6200 /* Generally, initializers in templates are expanded when the
6201 template is instantiated. But, if DECL is a variable constant
6202 then it can be used in future constant expressions, so its value
6203 must be available. */
6205 if (TREE_CODE (decl
) != VAR_DECL
|| dependent_type_p (type
))
6206 /* We can't do anything if the decl has dependent type. */;
6208 && init_const_expr_p
6209 && !type_dependent_p
6210 && decl_maybe_constant_var_p (decl
)
6211 && !type_dependent_init_p (init
)
6212 && !value_dependent_init_p (init
))
6214 /* This variable seems to be a non-dependent constant, so process
6215 its initializer. If check_initializer returns non-null the
6216 initialization wasn't constant after all. */
6218 cleanups
= make_tree_vector ();
6219 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6220 if (init_code
== NULL_TREE
)
6222 release_tree_vector (cleanups
);
6224 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6226 /* Deduce array size even if the initializer is dependent. */
6227 maybe_deduce_size_from_array_init (decl
, init
);
6228 /* And complain about multiple initializers. */
6229 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6230 && !MAYBE_CLASS_TYPE_P (type
))
6231 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6232 tf_warning_or_error
);
6236 DECL_INITIAL (decl
) = init
;
6240 /* Just store non-static data member initializers for later. */
6241 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6242 DECL_INITIAL (decl
) = init
;
6244 /* Take care of TYPE_DECLs up front. */
6245 if (TREE_CODE (decl
) == TYPE_DECL
)
6247 if (type
!= error_mark_node
6248 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6250 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6251 warning (0, "shadowing previous type declaration of %q#D", decl
);
6252 set_identifier_type_value (DECL_NAME (decl
), decl
);
6255 /* If we have installed this as the canonical typedef for this
6256 type, and that type has not been defined yet, delay emitting
6257 the debug information for it, as we will emit it later. */
6258 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6259 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6260 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6262 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6267 /* A reference will be modified here, as it is initialized. */
6268 if (! DECL_EXTERNAL (decl
)
6269 && TREE_READONLY (decl
)
6270 && TREE_CODE (type
) == REFERENCE_TYPE
)
6273 TREE_READONLY (decl
) = 0;
6276 if (TREE_CODE (decl
) == VAR_DECL
)
6278 /* If this is a local variable that will need a mangled name,
6279 register it now. We must do this before processing the
6280 initializer for the variable, since the initialization might
6281 require a guard variable, and since the mangled name of the
6282 guard variable will depend on the mangled name of this
6284 if (DECL_FUNCTION_SCOPE_P (decl
)
6285 && TREE_STATIC (decl
)
6286 && !DECL_ARTIFICIAL (decl
))
6288 push_local_name (decl
);
6289 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6290 || DECL_DESTRUCTOR_P (current_function_decl
))
6291 /* Normally local_decls is populated during GIMPLE lowering,
6292 but [cd]tors are never actually compiled directly. We need
6293 to put statics on the list so we can deal with the label
6294 address extension. FIXME. */
6295 add_local_decl (cfun
, decl
);
6298 /* Convert the initializer to the type of DECL, if we have not
6299 already initialized DECL. */
6300 if (!DECL_INITIALIZED_P (decl
)
6301 /* If !DECL_EXTERNAL then DECL is being defined. In the
6302 case of a static data member initialized inside the
6303 class-specifier, there can be an initializer even if DECL
6304 is *not* defined. */
6305 && (!DECL_EXTERNAL (decl
) || init
))
6307 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6310 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6311 /* Allow libjava/prims.cc define primitive classes. */
6312 if (init
!= NULL_TREE
6313 || jclass
== NULL_TREE
6314 || TREE_CODE (jclass
) != TYPE_DECL
6315 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6316 || !same_type_ignoring_top_level_qualifiers_p
6317 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6318 error ("Java object %qD not allocated with %<new%>", decl
);
6321 cleanups
= make_tree_vector ();
6322 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6324 /* Check that the initializer for a static data member was a
6325 constant. Although we check in the parser that the
6326 initializer is an integral constant expression, we do not
6327 simplify division-by-zero at the point at which it
6328 occurs. Therefore, in:
6330 struct S { static const int i = 7 / 0; };
6332 we issue an error at this point. It would
6333 probably be better to forbid division by zero in
6334 integral constant expressions. */
6335 if (DECL_EXTERNAL (decl
) && init
)
6337 error ("%qD cannot be initialized by a non-constant expression"
6338 " when being declared", decl
);
6339 DECL_INITIALIZED_IN_CLASS_P (decl
) = 0;
6347 The memory occupied by any object of static storage
6348 duration is zero-initialized at program startup before
6349 any other initialization takes place.
6351 We cannot create an appropriate initializer until after
6352 the type of DECL is finalized. If DECL_INITIAL is set,
6353 then the DECL is statically initialized, and any
6354 necessary zero-initialization has already been performed. */
6355 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6356 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6357 /*nelts=*/NULL_TREE
,
6358 /*static_storage_p=*/true);
6359 /* Remember that the initialization for this variable has
6361 DECL_INITIALIZED_P (decl
) = 1;
6362 /* This declaration is the definition of this variable,
6363 unless we are initializing a static data member within
6364 the class specifier. */
6365 if (!DECL_EXTERNAL (decl
))
6366 var_definition_p
= true;
6368 /* If the variable has an array type, lay out the type, even if
6369 there is no initializer. It is valid to index through the
6370 array, and we must get TYPE_ALIGN set correctly on the array
6372 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6375 if (TREE_STATIC (decl
)
6376 && !at_function_scope_p ()
6377 && current_function_decl
== NULL
)
6378 /* So decl is a global variable or a static member of a
6379 non local class. Record the types it uses
6380 so that we can decide later to emit debug info for them. */
6381 record_types_used_by_current_var_decl (decl
);
6383 else if (TREE_CODE (decl
) == FIELD_DECL
6384 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6385 error ("non-static data member %qD has Java class type", decl
);
6387 /* Add this declaration to the statement-tree. This needs to happen
6388 after the call to check_initializer so that the DECL_EXPR for a
6389 reference temp is added before the DECL_EXPR for the reference itself. */
6390 if (DECL_FUNCTION_SCOPE_P (decl
))
6391 add_decl_expr (decl
);
6393 /* Let the middle end know about variables and functions -- but not
6394 static data members in uninstantiated class templates. */
6395 if (TREE_CODE (decl
) == VAR_DECL
6396 || TREE_CODE (decl
) == FUNCTION_DECL
)
6398 if (TREE_CODE (decl
) == VAR_DECL
)
6400 layout_var_decl (decl
);
6401 maybe_commonize_var (decl
);
6404 /* This needs to happen after the linkage is set. */
6405 determine_visibility (decl
);
6407 if (var_definition_p
&& TREE_STATIC (decl
))
6409 /* If a TREE_READONLY variable needs initialization
6410 at runtime, it is no longer readonly and we need to
6411 avoid MEM_READONLY_P being set on RTL created for it. */
6414 if (TREE_READONLY (decl
))
6415 TREE_READONLY (decl
) = 0;
6418 else if (was_readonly
)
6419 TREE_READONLY (decl
) = 1;
6421 /* Likewise if it needs destruction. */
6422 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6423 TREE_READONLY (decl
) = 0;
6426 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6428 /* Check for abstractness of the type. Notice that there is no
6429 need to strip array types here since the check for those types
6430 is already done within create_array_type_for_decl. */
6431 if (TREE_CODE (type
) == FUNCTION_TYPE
6432 || TREE_CODE (type
) == METHOD_TYPE
)
6433 abstract_virtuals_error (decl
, TREE_TYPE (type
));
6435 abstract_virtuals_error (decl
, type
);
6437 if (TREE_TYPE (decl
) == error_mark_node
)
6438 /* No initialization required. */
6440 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6444 if (init
== ridpointers
[(int)RID_DEFAULT
])
6446 /* An out-of-class default definition is defined at
6447 the point where it is explicitly defaulted. */
6448 if (DECL_DELETED_FN (decl
))
6449 maybe_explain_implicit_delete (decl
);
6450 else if (DECL_INITIAL (decl
) == error_mark_node
)
6451 synthesize_method (decl
);
6454 error ("function %q#D is initialized like a variable", decl
);
6456 /* else no initialization required. */
6458 else if (DECL_EXTERNAL (decl
)
6459 && ! (DECL_LANG_SPECIFIC (decl
)
6460 && DECL_NOT_REALLY_EXTERN (decl
)))
6463 DECL_INITIAL (decl
) = init
;
6465 /* A variable definition. */
6466 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6467 /* Initialize the local variable. */
6468 initialize_local_var (decl
, init
);
6470 /* If a variable is defined, and then a subsequent
6471 definition with external linkage is encountered, we will
6472 get here twice for the same variable. We want to avoid
6473 calling expand_static_init more than once. For variables
6474 that are not static data members, we can call
6475 expand_static_init only when we actually process the
6476 initializer. It is not legal to redeclare a static data
6477 member, so this issue does not arise in that case. */
6478 else if (var_definition_p
&& TREE_STATIC (decl
))
6479 expand_static_init (decl
, init
);
6482 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6483 reference, insert it in the statement-tree now. */
6487 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6488 push_cleanup (decl
, t
, false);
6489 release_tree_vector (cleanups
);
6493 TREE_READONLY (decl
) = 1;
6495 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6498 /* Returns a declaration for a VAR_DECL as if:
6500 extern "C" TYPE NAME;
6502 had been seen. Used to create compiler-generated global
6506 declare_global_var (tree name
, tree type
)
6510 push_to_top_level ();
6511 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6512 TREE_PUBLIC (decl
) = 1;
6513 DECL_EXTERNAL (decl
) = 1;
6514 DECL_ARTIFICIAL (decl
) = 1;
6515 /* If the user has explicitly declared this variable (perhaps
6516 because the code we are compiling is part of a low-level runtime
6517 library), then it is possible that our declaration will be merged
6518 with theirs by pushdecl. */
6519 decl
= pushdecl (decl
);
6520 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6521 pop_from_top_level ();
6526 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6527 if "__cxa_atexit" is not being used) corresponding to the function
6528 to be called when the program exits. */
6531 get_atexit_fn_ptr_type (void)
6535 if (!atexit_fn_ptr_type_node
)
6538 if (flag_use_cxa_atexit
6539 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6540 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6541 arg_type
= ptr_type_node
;
6543 /* The parameter to "atexit" is "void (*)(void)". */
6544 arg_type
= NULL_TREE
;
6546 fn_type
= build_function_type_list (void_type_node
,
6547 arg_type
, NULL_TREE
);
6548 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6551 return atexit_fn_ptr_type_node
;
6554 /* Returns a pointer to the `atexit' function. Note that if
6555 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6556 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6559 get_atexit_node (void)
6565 bool use_aeabi_atexit
;
6570 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6572 /* The declaration for `__cxa_atexit' is:
6574 int __cxa_atexit (void (*)(void *), void *, void *)
6576 We build up the argument types and then the function type
6578 tree argtype0
, argtype1
, argtype2
;
6580 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6581 /* First, build the pointer-to-function type for the first
6583 fn_ptr_type
= get_atexit_fn_ptr_type ();
6584 /* Then, build the rest of the argument types. */
6585 argtype2
= ptr_type_node
;
6586 if (use_aeabi_atexit
)
6588 argtype1
= fn_ptr_type
;
6589 argtype0
= ptr_type_node
;
6593 argtype1
= ptr_type_node
;
6594 argtype0
= fn_ptr_type
;
6596 /* And the final __cxa_atexit type. */
6597 fn_type
= build_function_type_list (integer_type_node
,
6598 argtype0
, argtype1
, argtype2
,
6600 if (use_aeabi_atexit
)
6601 name
= "__aeabi_atexit";
6603 name
= "__cxa_atexit";
6607 /* The declaration for `atexit' is:
6609 int atexit (void (*)());
6611 We build up the argument types and then the function type
6613 fn_ptr_type
= get_atexit_fn_ptr_type ();
6614 /* Build the final atexit type. */
6615 fn_type
= build_function_type_list (integer_type_node
,
6616 fn_ptr_type
, NULL_TREE
);
6620 /* Now, build the function declaration. */
6621 push_lang_context (lang_name_c
);
6622 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
6623 mark_used (atexit_fndecl
);
6624 pop_lang_context ();
6625 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6630 /* Like get_atexit_node, but for thread-local cleanups. */
6633 get_thread_atexit_node (void)
6635 /* The declaration for `__cxa_thread_atexit' is:
6637 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6638 tree fn_type
= build_function_type_list (integer_type_node
,
6639 get_atexit_fn_ptr_type (),
6640 ptr_type_node
, ptr_type_node
,
6643 /* Now, build the function declaration. */
6644 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
);
6645 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6648 /* Returns the __dso_handle VAR_DECL. */
6651 get_dso_handle_node (void)
6653 if (dso_handle_node
)
6654 return dso_handle_node
;
6656 /* Declare the variable. */
6657 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6660 #ifdef HAVE_GAS_HIDDEN
6661 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6662 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6665 return dso_handle_node
;
6668 /* Begin a new function with internal linkage whose job will be simply
6669 to destroy some particular variable. */
6671 static GTY(()) int start_cleanup_cnt
;
6674 start_cleanup_fn (void)
6679 bool use_cxa_atexit
= flag_use_cxa_atexit
6680 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6682 push_to_top_level ();
6684 /* No need to mangle this. */
6685 push_lang_context (lang_name_c
);
6687 /* Build the name of the function. */
6688 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6689 /* Build the function declaration. */
6690 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6691 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6692 /* It's a function with internal linkage, generated by the
6694 TREE_PUBLIC (fndecl
) = 0;
6695 DECL_ARTIFICIAL (fndecl
) = 1;
6696 /* Make the function `inline' so that it is only emitted if it is
6697 actually needed. It is unlikely that it will be inlined, since
6698 it is only called via a function pointer, but we avoid unnecessary
6699 emissions this way. */
6700 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6701 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6702 /* Build the parameter. */
6707 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6708 DECL_CONTEXT (parmdecl
) = fndecl
;
6709 TREE_USED (parmdecl
) = 1;
6710 DECL_READ_P (parmdecl
) = 1;
6711 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6715 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6717 pop_lang_context ();
6719 return current_function_decl
;
6722 /* Finish the cleanup function begun by start_cleanup_fn. */
6725 end_cleanup_fn (void)
6727 expand_or_defer_fn (finish_function (0));
6729 pop_from_top_level ();
6732 /* Generate code to handle the destruction of DECL, an object with
6733 static storage duration. */
6736 register_dtor_fn (tree decl
)
6743 bool ob_parm
, dso_parm
, use_dtor
;
6744 tree arg0
, arg1
, arg2
;
6747 type
= TREE_TYPE (decl
);
6748 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6749 return void_zero_node
;
6751 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
6752 "__aeabi_atexit"), and DECL is a class object, we can just pass the
6753 destructor to "__cxa_atexit"; we don't have to build a temporary
6754 function to do the cleanup. */
6755 ob_parm
= (DECL_THREAD_LOCAL_P (decl
)
6756 || (flag_use_cxa_atexit
6757 && !targetm
.cxx
.use_atexit_for_cxa_atexit ()));
6759 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
6764 /* Find the destructor. */
6765 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6766 gcc_assert (idx
>= 0);
6767 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
6768 /* Make sure it is accessible. */
6769 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
6770 tf_warning_or_error
);
6774 /* Call build_cleanup before we enter the anonymous function so
6775 that any access checks will be done relative to the current
6776 scope, rather than the scope of the anonymous function. */
6777 build_cleanup (decl
);
6779 /* Now start the function. */
6780 cleanup
= start_cleanup_fn ();
6782 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6783 to the original function, rather than the anonymous one. That
6784 will make the back end think that nested functions are in use,
6785 which causes confusion. */
6786 push_deferring_access_checks (dk_no_check
);
6787 fcall
= build_cleanup (decl
);
6788 pop_deferring_access_checks ();
6790 /* Create the body of the anonymous function. */
6791 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6792 finish_expr_stmt (fcall
);
6793 finish_compound_stmt (compound_stmt
);
6797 /* Call atexit with the cleanup function. */
6798 mark_used (cleanup
);
6799 cleanup
= build_address (cleanup
);
6801 if (DECL_THREAD_LOCAL_P (decl
))
6802 atex_node
= get_thread_atexit_node ();
6804 atex_node
= get_atexit_node ();
6808 /* We must convert CLEANUP to the type that "__cxa_atexit"
6810 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6811 /* "__cxa_atexit" will pass the address of DECL to the
6812 cleanup function. */
6814 addr
= build_address (decl
);
6815 /* The declared type of the parameter to "__cxa_atexit" is
6816 "void *". For plain "T*", we could just let the
6817 machinery in cp_build_function_call convert it -- but if the
6818 type is "cv-qualified T *", then we need to convert it
6819 before passing it in, to avoid spurious errors. */
6820 addr
= build_nop (ptr_type_node
, addr
);
6823 /* Since the cleanup functions we build ignore the address
6824 they're given, there's no reason to pass the actual address
6825 in, and, in general, it's cheaper to pass NULL than any
6827 addr
= null_pointer_node
;
6830 arg2
= cp_build_addr_expr (get_dso_handle_node (),
6831 tf_warning_or_error
);
6837 if (!DECL_THREAD_LOCAL_P (decl
)
6838 && targetm
.cxx
.use_aeabi_atexit ())
6854 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
6855 arg0
, arg1
, arg2
, NULL_TREE
);
6858 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6859 is its initializer. Generate code to handle the construction
6860 and destruction of DECL. */
6863 expand_static_init (tree decl
, tree init
)
6865 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
6866 gcc_assert (TREE_STATIC (decl
));
6868 /* Some variables require no dynamic initialization. */
6870 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6873 if (DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
6874 && !DECL_FUNCTION_SCOPE_P (decl
))
6877 error ("non-local variable %qD declared %<__thread%> "
6878 "needs dynamic initialization", decl
);
6880 error ("non-local variable %qD declared %<__thread%> "
6881 "has a non-trivial destructor", decl
);
6882 static bool informed
;
6885 inform (DECL_SOURCE_LOCATION (decl
),
6886 "C++11 %<thread_local%> allows dynamic initialization "
6893 if (DECL_FUNCTION_SCOPE_P (decl
))
6895 /* Emit code to perform this initialization but once. */
6896 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6897 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6898 tree guard
, guard_addr
;
6900 /* We don't need thread-safety code for thread-local vars. */
6901 bool thread_guard
= (flag_threadsafe_statics
6902 && !DECL_THREAD_LOCAL_P (decl
));
6904 /* Emit code to perform this initialization but once. This code
6907 static <type> guard;
6908 if (!guard.first_byte) {
6909 if (__cxa_guard_acquire (&guard)) {
6912 // Do initialization.
6913 flag = true; __cxa_guard_release (&guard);
6914 // Register variable for destruction at end of program.
6916 if (!flag) __cxa_guard_abort (&guard);
6920 Note that the `flag' variable is only set to 1 *after* the
6921 initialization is complete. This ensures that an exception,
6922 thrown during the construction, will cause the variable to
6923 reinitialized when we pass through this code again, as per:
6927 If the initialization exits by throwing an exception, the
6928 initialization is not complete, so it will be tried again
6929 the next time control enters the declaration.
6931 This process should be thread-safe, too; multiple threads
6932 should not be able to initialize the variable more than
6935 /* Create the guard variable. */
6936 guard
= get_guard (decl
);
6938 /* This optimization isn't safe on targets with relaxed memory
6939 consistency. On such targets we force synchronization in
6940 __cxa_guard_acquire. */
6941 if (!targetm
.relaxed_ordering
|| !thread_guard
)
6943 /* Begin the conditional initialization. */
6944 if_stmt
= begin_if_stmt ();
6945 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
6946 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6951 tree vfntype
= NULL_TREE
;
6952 tree acquire_name
, release_name
, abort_name
;
6953 tree acquire_fn
, release_fn
, abort_fn
;
6954 guard_addr
= build_address (guard
);
6956 acquire_name
= get_identifier ("__cxa_guard_acquire");
6957 release_name
= get_identifier ("__cxa_guard_release");
6958 abort_name
= get_identifier ("__cxa_guard_abort");
6959 acquire_fn
= identifier_global_value (acquire_name
);
6960 release_fn
= identifier_global_value (release_name
);
6961 abort_fn
= identifier_global_value (abort_name
);
6963 acquire_fn
= push_library_fn
6964 (acquire_name
, build_function_type_list (integer_type_node
,
6965 TREE_TYPE (guard_addr
),
6968 if (!release_fn
|| !abort_fn
)
6969 vfntype
= build_function_type_list (void_type_node
,
6970 TREE_TYPE (guard_addr
),
6973 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
);
6975 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
);
6977 inner_if_stmt
= begin_if_stmt ();
6978 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
6981 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6982 begin
= get_target_expr (boolean_false_node
);
6983 flag
= TARGET_EXPR_SLOT (begin
);
6985 TARGET_EXPR_CLEANUP (begin
)
6986 = build3 (COND_EXPR
, void_type_node
, flag
,
6988 build_call_n (abort_fn
, 1, guard_addr
));
6989 CLEANUP_EH_ONLY (begin
) = 1;
6991 /* Do the initialization itself. */
6992 init
= add_stmt_to_compound (begin
, init
);
6993 init
= add_stmt_to_compound
6994 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
6995 init
= add_stmt_to_compound
6996 (init
, build_call_n (release_fn
, 1, guard_addr
));
6999 init
= add_stmt_to_compound (init
, set_guard (guard
));
7001 /* Use atexit to register a function for destroying this static
7003 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7005 finish_expr_stmt (init
);
7009 finish_compound_stmt (inner_then_clause
);
7010 finish_then_clause (inner_if_stmt
);
7011 finish_if_stmt (inner_if_stmt
);
7014 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7016 finish_compound_stmt (then_clause
);
7017 finish_then_clause (if_stmt
);
7018 finish_if_stmt (if_stmt
);
7021 else if (DECL_THREAD_LOCAL_P (decl
))
7022 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7024 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7028 /* Make TYPE a complete type based on INITIAL_VALUE.
7029 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7030 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7031 3 if the initializer list is empty (in pedantic mode). */
7034 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7037 tree type
, elt_type
;
7041 unsigned HOST_WIDE_INT i
;
7044 /* An array of character type can be initialized from a
7045 brace-enclosed string constant.
7047 FIXME: this code is duplicated from reshape_init. Probably
7048 we should just call reshape_init here? */
7049 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7050 && TREE_CODE (initial_value
) == CONSTRUCTOR
7051 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7053 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7054 tree value
= (*v
)[0].value
;
7056 if (TREE_CODE (value
) == STRING_CST
7057 && v
->length () == 1)
7058 initial_value
= value
;
7061 /* If any of the elements are parameter packs, we can't actually
7062 complete this type now because the array size is dependent. */
7063 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7065 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7068 if (PACK_EXPANSION_P (value
))
7074 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7076 /* We can create the array before the element type is complete, which
7077 means that we didn't have these two bits set in the original type
7078 either. In completing the type, we are expected to propagate these
7079 bits. See also complete_type which does the same thing for arrays
7082 if (TYPE_DOMAIN (type
))
7084 elt_type
= TREE_TYPE (type
);
7085 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7086 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7087 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7093 /* As above, but either give an error or reject zero-size arrays, depending
7097 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7098 bool do_default
, tsubst_flags_t complain
)
7101 bool sfinae
= !(complain
& tf_error
);
7102 /* In SFINAE context we can't be lenient about zero-size arrays. */
7105 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7111 /* Not an error. */;
7112 else if (failure
== 1)
7113 error ("initializer fails to determine size of %qT", *ptype
);
7114 else if (failure
== 2)
7117 error ("array size missing in %qT", *ptype
);
7119 else if (failure
== 3)
7120 error ("zero-size array %qT", *ptype
);
7121 *ptype
= error_mark_node
;
7126 /* Return zero if something is declared to be a member of type
7127 CTYPE when in the context of CUR_TYPE. STRING is the error
7128 message to print in that case. Otherwise, quietly return 1. */
7131 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7133 if (ctype
&& ctype
!= cur_type
)
7135 if (flags
== DTOR_FLAG
)
7136 error ("destructor for alien class %qT cannot be a member", ctype
);
7138 error ("constructor for alien class %qT cannot be a member", ctype
);
7144 /* Subroutine of `grokdeclarator'. */
7146 /* Generate errors possibly applicable for a given set of specifiers.
7147 This is for ARM $7.1.2. */
7150 bad_specifiers (tree object
,
7151 enum bad_spec_place type
,
7162 error ("%qD declared as a %<virtual%> variable", object
);
7164 error ("%qD declared as an %<inline%> variable", object
);
7166 error ("%<const%> and %<volatile%> function specifiers on "
7167 "%qD invalid in variable declaration", object
);
7171 error ("%qD declared as a %<virtual%> parameter", object
);
7173 error ("%qD declared as an %<inline%> parameter", object
);
7175 error ("%<const%> and %<volatile%> function specifiers on "
7176 "%qD invalid in parameter declaration", object
);
7180 error ("%qD declared as a %<virtual%> type", object
);
7182 error ("%qD declared as an %<inline%> type", object
);
7184 error ("%<const%> and %<volatile%> function specifiers on "
7185 "%qD invalid in type declaration", object
);
7189 error ("%qD declared as a %<virtual%> field", object
);
7191 error ("%qD declared as an %<inline%> field", object
);
7193 error ("%<const%> and %<volatile%> function specifiers on "
7194 "%qD invalid in field declaration", object
);
7200 error ("%q+D declared as a friend", object
);
7202 && (TREE_CODE (object
) == TYPE_DECL
7203 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7204 && !TYPE_REFFN_P (TREE_TYPE (object
))
7205 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7206 error ("%q+D declared with an exception specification", object
);
7209 /* DECL is a member function or static data member and is presently
7210 being defined. Check that the definition is taking place in a
7214 check_class_member_definition_namespace (tree decl
)
7216 /* These checks only apply to member functions and static data
7218 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
7219 || TREE_CODE (decl
) == VAR_DECL
);
7220 /* We check for problems with specializations in pt.c in
7221 check_specialization_namespace, where we can issue better
7223 if (processing_specialization
)
7225 /* There are no restrictions on the placement of
7226 explicit instantiations. */
7227 if (processing_explicit_instantiation
)
7231 A member function definition that appears outside of the
7232 class definition shall appear in a namespace scope enclosing
7233 the class definition.
7237 The definition for a static data member shall appear in a
7238 namespace scope enclosing the member's class definition. */
7239 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7240 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7241 decl
, DECL_CONTEXT (decl
));
7244 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7245 METHOD_TYPE for a non-static member function; QUALS are the
7246 cv-qualifiers that apply to the function. */
7249 build_this_parm (tree type
, cp_cv_quals quals
)
7254 cp_cv_quals this_quals
;
7256 if (CLASS_TYPE_P (type
))
7259 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7260 this_type
= build_pointer_type (this_type
);
7263 this_type
= type_of_this_parm (type
);
7264 /* The `this' parameter is implicitly `const'; it cannot be
7266 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7267 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7268 parm
= build_artificial_parm (this_identifier
, qual_type
);
7269 cp_apply_type_quals_to_decl (this_quals
, parm
);
7273 /* DECL is a static member function. Complain if it was declared
7274 with function-cv-quals. */
7277 check_static_quals (tree decl
, cp_cv_quals quals
)
7279 if (quals
!= TYPE_UNQUALIFIED
)
7280 error ("static member function %q#D declared with type qualifiers",
7284 /* CTYPE is class type, or null if non-class.
7285 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7287 DECLARATOR is the function's name.
7288 PARMS is a chain of PARM_DECLs for the function.
7289 VIRTUALP is truthvalue of whether the function is virtual or not.
7290 FLAGS are to be passed through to `grokclassfn'.
7291 QUALS are qualifiers indicating whether the function is `const'
7293 RAISES is a list of exceptions that this function can raise.
7294 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7295 not look, and -1 if we should not call `grokclassfn' at all.
7297 SFK is the kind of special function (if any) for the new function.
7299 Returns `NULL_TREE' if something goes wrong, after issuing
7300 applicable error messages. */
7303 grokfndecl (tree ctype
,
7307 tree orig_declarator
,
7309 enum overload_flags flags
,
7316 special_function_kind sfk
,
7321 location_t location
)
7324 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7328 type
= build_exception_variant (type
, raises
);
7330 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7332 /* If we have an explicit location, use it, otherwise use whatever
7333 build_lang_decl used (probably input_location). */
7334 if (location
!= UNKNOWN_LOCATION
)
7335 DECL_SOURCE_LOCATION (decl
) = location
;
7337 if (TREE_CODE (type
) == METHOD_TYPE
)
7340 parm
= build_this_parm (type
, quals
);
7341 DECL_CHAIN (parm
) = parms
;
7344 DECL_ARGUMENTS (decl
) = parms
;
7345 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7346 DECL_CONTEXT (t
) = decl
;
7347 /* Propagate volatile out from type to decl. */
7348 if (TYPE_VOLATILE (type
))
7349 TREE_THIS_VOLATILE (decl
) = 1;
7351 /* Setup decl according to sfk. */
7354 case sfk_constructor
:
7355 case sfk_copy_constructor
:
7356 case sfk_move_constructor
:
7357 DECL_CONSTRUCTOR_P (decl
) = 1;
7359 case sfk_destructor
:
7360 DECL_DESTRUCTOR_P (decl
) = 1;
7366 /* If pointers to member functions use the least significant bit to
7367 indicate whether a function is virtual, ensure a pointer
7368 to this function will have that bit clear. */
7369 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7370 && TREE_CODE (type
) == METHOD_TYPE
7371 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7372 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7375 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7379 ("defining explicit specialization %qD in friend declaration",
7383 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7384 tree args
= TREE_OPERAND (orig_declarator
, 1);
7386 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7388 /* Something like `template <class T> friend void f<T>()'. */
7389 error ("invalid use of template-id %qD in declaration "
7390 "of primary template",
7396 /* A friend declaration of the form friend void f<>(). Record
7397 the information in the TEMPLATE_ID_EXPR. */
7398 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7400 if (TREE_CODE (fns
) == COMPONENT_REF
)
7402 /* Due to bison parser ickiness, we will have already looked
7403 up an operator_name or PFUNCNAME within the current class
7404 (see template_id in parse.y). If the current class contains
7405 such a name, we'll get a COMPONENT_REF here. Undo that. */
7407 gcc_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
7408 == current_class_type
);
7409 fns
= TREE_OPERAND (fns
, 1);
7411 gcc_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
7412 || TREE_CODE (fns
) == OVERLOAD
);
7413 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7415 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7416 if (TREE_PURPOSE (t
)
7417 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7419 error ("default arguments are not allowed in declaration "
7420 "of friend template specialization %qD",
7427 error ("%<inline%> is not allowed in declaration of friend "
7428 "template specialization %qD",
7435 /* If this decl has namespace scope, set that up. */
7437 set_decl_namespace (decl
, in_namespace
, friendp
);
7439 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7441 /* `main' and builtins have implicit 'C' linkage. */
7442 if ((MAIN_NAME_P (declarator
)
7443 || (IDENTIFIER_LENGTH (declarator
) > 10
7444 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7445 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7446 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
7447 && current_lang_name
== lang_name_cplusplus
7448 && ctype
== NULL_TREE
7449 && DECL_FILE_SCOPE_P (decl
))
7450 SET_DECL_LANGUAGE (decl
, lang_c
);
7452 /* Should probably propagate const out from type to decl I bet (mrs). */
7455 DECL_STATIC_FUNCTION_P (decl
) = 1;
7456 DECL_CONTEXT (decl
) = ctype
;
7461 DECL_CONTEXT (decl
) = ctype
;
7463 check_class_member_definition_namespace (decl
);
7466 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7468 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7469 error ("cannot declare %<::main%> to be a template");
7471 error ("cannot declare %<::main%> to be inline");
7473 error ("cannot declare %<::main%> to be static");
7478 /* Members of anonymous types and local classes have no linkage; make
7479 them internal. If a typedef is made later, this will be changed. */
7480 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
7481 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7484 if (publicp
&& cxx_dialect
== cxx98
)
7486 /* [basic.link]: A name with no linkage (notably, the name of a class
7487 or enumeration declared in a local scope) shall not be used to
7488 declare an entity with linkage.
7490 DR 757 relaxes this restriction for C++0x. */
7491 t
= no_linkage_check (TREE_TYPE (decl
),
7492 /*relaxed_p=*/false);
7495 if (TYPE_ANONYMOUS_P (t
))
7497 if (DECL_EXTERN_C_P (decl
))
7498 /* Allow this; it's pretty common in C. */;
7501 permerror (input_location
, "anonymous type with no linkage "
7502 "used to declare function %q#D with linkage",
7504 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7505 permerror (input_location
, "%q+#D does not refer to the unqualified "
7506 "type, so it is not used for linkage",
7511 permerror (input_location
, "type %qT with no linkage used to "
7512 "declare function %q#D with linkage", t
, decl
);
7516 TREE_PUBLIC (decl
) = publicp
;
7519 DECL_INTERFACE_KNOWN (decl
) = 1;
7520 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7523 /* If the declaration was declared inline, mark it as such. */
7525 DECL_DECLARED_INLINE_P (decl
) = 1;
7527 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7529 DECL_EXTERNAL (decl
) = 1;
7530 if (quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
7533 ? G_("static member function %qD cannot have cv-qualifier")
7534 : G_("non-member function %qD cannot have cv-qualifier"),
7536 quals
= TYPE_UNQUALIFIED
;
7539 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7540 && !grok_op_properties (decl
, /*complain=*/true))
7542 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7544 bool long_long_unsigned_p
;
7546 const char *suffix
= NULL
;
7547 /* [over.literal]/6: Literal operators shall not have C linkage. */
7548 if (DECL_LANGUAGE (decl
) == lang_c
)
7550 error ("literal operator with C linkage");
7554 if (DECL_NAMESPACE_SCOPE_P (decl
))
7556 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7559 error ("%qD has invalid argument list", decl
);
7563 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7564 if (long_long_unsigned_p
)
7566 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7567 warning (0, "integer suffix %<%s%>"
7568 " shadowed by implementation", suffix
);
7570 else if (long_double_p
)
7572 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7573 warning (0, "floating point suffix %<%s%>"
7574 " shadowed by implementation", suffix
);
7579 error ("%qD must be a non-member function", decl
);
7585 /* Make the init_value nonzero so pushdecl knows this is not
7586 tentative. error_mark_node is replaced later with the BLOCK. */
7587 DECL_INITIAL (decl
) = error_mark_node
;
7589 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7590 TREE_NOTHROW (decl
) = 1;
7592 /* Caller will do the rest of this. */
7596 if (ctype
!= NULL_TREE
)
7597 grokclassfn (ctype
, decl
, flags
);
7600 if (cxx_dialect
>= cxx0x
7601 && DECL_DESTRUCTOR_P (decl
)
7602 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7603 && !processing_template_decl
)
7604 deduce_noexcept_on_destructor (decl
);
7606 decl
= check_explicit_specialization (orig_declarator
, decl
,
7609 4 * (friendp
!= 0));
7610 if (decl
== error_mark_node
)
7613 if (DECL_STATIC_FUNCTION_P (decl
))
7614 check_static_quals (decl
, quals
);
7618 cplus_decl_attributes (&decl
, *attrlist
, 0);
7619 *attrlist
= NULL_TREE
;
7622 /* Check main's type after attributes have been applied. */
7623 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7625 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7628 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7630 error ("%<::main%> must return %<int%>");
7631 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7632 TREE_TYPE (decl
) = newtype
;
7635 check_main_parameter_types (decl
);
7638 if (ctype
!= NULL_TREE
7639 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
7642 tree old_decl
= check_classfn (ctype
, decl
,
7643 (processing_template_decl
7644 > template_class_depth (ctype
))
7645 ? current_template_parms
7648 if (old_decl
== error_mark_node
)
7656 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
7657 /* Because grokfndecl is always supposed to return a
7658 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7659 here. We depend on our callers to figure out that its
7660 really a template that's being returned. */
7661 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
7663 if (DECL_STATIC_FUNCTION_P (old_decl
)
7664 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7666 /* Remove the `this' parm added by grokclassfn. */
7667 revert_static_member_fn (decl
);
7668 check_static_quals (decl
, quals
);
7670 if (DECL_ARTIFICIAL (old_decl
))
7672 error ("definition of implicitly-declared %qD", old_decl
);
7675 else if (DECL_DEFAULTED_FN (old_decl
))
7677 error ("definition of explicitly-defaulted %q+D", decl
);
7678 error ("%q+#D explicitly defaulted here", old_decl
);
7682 /* Since we've smashed OLD_DECL to its
7683 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7684 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7685 decl
= DECL_TEMPLATE_RESULT (decl
);
7687 /* Attempt to merge the declarations. This can fail, in
7688 the case of some invalid specialization declarations. */
7689 pushed_scope
= push_scope (ctype
);
7690 ok
= duplicate_decls (decl
, old_decl
, friendp
);
7692 pop_scope (pushed_scope
);
7695 error ("no %q#D member function declared in class %qT",
7703 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
7706 if (ctype
== NULL_TREE
|| check
)
7710 DECL_VIRTUAL_P (decl
) = 1;
7715 /* decl is a FUNCTION_DECL.
7716 specifiers are the parsed virt-specifiers.
7718 Set flags to reflect the virt-specifiers.
7723 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
7725 if (decl
== NULL_TREE
)
7727 if (specifiers
& VIRT_SPEC_OVERRIDE
)
7728 DECL_OVERRIDE_P (decl
) = 1;
7729 if (specifiers
& VIRT_SPEC_FINAL
)
7730 DECL_FINAL_P (decl
) = 1;
7734 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7735 the linkage that DECL will receive in the object file. */
7738 set_linkage_for_static_data_member (tree decl
)
7740 /* A static data member always has static storage duration and
7741 external linkage. Note that static data members are forbidden in
7742 local classes -- the only situation in which a class has
7743 non-external linkage. */
7744 TREE_PUBLIC (decl
) = 1;
7745 TREE_STATIC (decl
) = 1;
7746 /* For non-template classes, static data members are always put
7747 out in exactly those files where they are defined, just as
7748 with ordinary namespace-scope variables. */
7749 if (!processing_template_decl
)
7750 DECL_INTERFACE_KNOWN (decl
) = 1;
7753 /* Create a VAR_DECL named NAME with the indicated TYPE.
7755 If SCOPE is non-NULL, it is the class type or namespace containing
7756 the variable. If SCOPE is NULL, the variable should is created in
7757 the innermost enclosings scope. */
7760 grokvardecl (tree type
,
7762 const cp_decl_specifier_seq
*declspecs
,
7768 tree explicit_scope
;
7770 gcc_assert (!name
|| TREE_CODE (name
) == IDENTIFIER_NODE
);
7772 /* Compute the scope in which to place the variable, but remember
7773 whether or not that scope was explicitly specified by the user. */
7774 explicit_scope
= scope
;
7777 /* An explicit "extern" specifier indicates a namespace-scope
7779 if (declspecs
->storage_class
== sc_extern
)
7780 scope
= current_decl_namespace ();
7781 else if (!at_function_scope_p ())
7782 scope
= current_scope ();
7786 && (/* If the variable is a namespace-scope variable declared in a
7787 template, we need DECL_LANG_SPECIFIC. */
7788 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
7789 /* Similarly for namespace-scope variables with language linkage
7791 || (TREE_CODE (scope
) == NAMESPACE_DECL
7792 && current_lang_name
!= lang_name_cplusplus
)
7793 /* Similarly for static data members. */
7795 decl
= build_lang_decl (VAR_DECL
, name
, type
);
7797 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7799 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
7800 set_decl_namespace (decl
, explicit_scope
, 0);
7802 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
7804 if (declspecs
->storage_class
== sc_extern
)
7806 DECL_THIS_EXTERN (decl
) = 1;
7807 DECL_EXTERNAL (decl
) = !initialized
;
7810 if (DECL_CLASS_SCOPE_P (decl
))
7812 set_linkage_for_static_data_member (decl
);
7813 /* This function is only called with out-of-class definitions. */
7814 DECL_EXTERNAL (decl
) = 0;
7815 check_class_member_definition_namespace (decl
);
7817 /* At top level, either `static' or no s.c. makes a definition
7818 (perhaps tentative), and absence of `static' makes it public. */
7819 else if (toplevel_bindings_p ())
7821 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
7822 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7823 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7825 /* Not at top level, only `static' makes a static definition. */
7828 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
7829 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7832 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
7834 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
7835 if (declspecs
->gnu_thread_keyword_p
)
7836 DECL_GNU_TLS_P (decl
) = true;
7839 /* If the type of the decl has no linkage, make sure that we'll
7840 notice that in mark_used. */
7841 if (cxx_dialect
> cxx98
7842 && decl_linkage (decl
) != lk_none
7843 && DECL_LANG_SPECIFIC (decl
) == NULL
7844 && !DECL_EXTERN_C_P (decl
)
7845 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
7846 retrofit_lang_decl (decl
);
7848 if (TREE_PUBLIC (decl
))
7850 /* [basic.link]: A name with no linkage (notably, the name of a class
7851 or enumeration declared in a local scope) shall not be used to
7852 declare an entity with linkage.
7854 DR 757 relaxes this restriction for C++0x. */
7855 tree t
= (cxx_dialect
> cxx98
? NULL_TREE
7856 : no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false));
7859 if (TYPE_ANONYMOUS_P (t
))
7861 if (DECL_EXTERN_C_P (decl
))
7862 /* Allow this; it's pretty common in C. */
7866 /* DRs 132, 319 and 389 seem to indicate types with
7867 no linkage can only be used to declare extern "C"
7868 entities. Since it's not always an error in the
7869 ISO C++ 90 Standard, we only issue a warning. */
7870 warning (0, "anonymous type with no linkage used to declare "
7871 "variable %q#D with linkage", decl
);
7872 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7873 warning (0, "%q+#D does not refer to the unqualified "
7874 "type, so it is not used for linkage",
7879 warning (0, "type %qT with no linkage used to declare variable "
7880 "%q#D with linkage", t
, decl
);
7884 DECL_INTERFACE_KNOWN (decl
) = 1;
7889 /* Create and return a canonical pointer to member function type, for
7890 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7893 build_ptrmemfunc_type (tree type
)
7897 tree unqualified_variant
= NULL_TREE
;
7899 if (type
== error_mark_node
)
7902 /* If a canonical type already exists for this type, use it. We use
7903 this method instead of type_hash_canon, because it only does a
7904 simple equality check on the list of field members. */
7906 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
7909 /* Make sure that we always have the unqualified pointer-to-member
7911 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7913 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
7915 t
= make_class_type (RECORD_TYPE
);
7916 xref_basetypes (t
, NULL_TREE
);
7918 /* Let the front end know this is a pointer to member function... */
7919 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
7920 /* ... and not really a class type. */
7921 SET_CLASS_TYPE_P (t
, 0);
7923 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
7926 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
7928 DECL_CHAIN (field
) = fields
;
7931 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
7933 /* Zap out the name so that the back end will give us the debugging
7934 information for this anonymous RECORD_TYPE. */
7935 TYPE_NAME (t
) = NULL_TREE
;
7937 /* If this is not the unqualified form of this pointer-to-member
7938 type, set the TYPE_MAIN_VARIANT for this type to be the
7939 unqualified type. Since they are actually RECORD_TYPEs that are
7940 not variants of each other, we must do this manually.
7941 As we just built a new type there is no need to do yet another copy. */
7942 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7944 int type_quals
= cp_type_quals (type
);
7945 TYPE_READONLY (t
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
7946 TYPE_VOLATILE (t
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
7947 TYPE_RESTRICT (t
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
7948 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
7949 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
7950 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
7951 TREE_TYPE (TYPE_BINFO (t
)) = t
;
7954 /* Cache this pointer-to-member type so that we can find it again
7956 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
7958 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
7959 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7960 else if (TYPE_CANONICAL (type
) != type
)
7961 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
7966 /* Create and return a pointer to data member type. */
7969 build_ptrmem_type (tree class_type
, tree member_type
)
7971 if (TREE_CODE (member_type
) == METHOD_TYPE
)
7973 cp_cv_quals quals
= type_memfn_quals (member_type
);
7974 member_type
= build_memfn_type (member_type
, class_type
, quals
);
7975 return build_ptrmemfunc_type (build_pointer_type (member_type
));
7979 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
7980 return build_offset_type (class_type
, member_type
);
7984 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7985 Check to see that the definition is valid. Issue appropriate error
7986 messages. Return 1 if the definition is particularly bad, or 0
7990 check_static_variable_definition (tree decl
, tree type
)
7992 /* Can't check yet if we don't know the type. */
7993 if (dependent_type_p (type
))
7995 /* If DECL is declared constexpr, we'll do the appropriate checks
7996 in check_initializer. */
7997 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
7999 else if (cxx_dialect
>= cxx0x
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8001 if (!COMPLETE_TYPE_P (type
))
8002 error ("in-class initialization of static data member %q#D of "
8003 "incomplete type", decl
);
8004 else if (literal_type_p (type
))
8005 permerror (input_location
,
8006 "%<constexpr%> needed for in-class initialization of "
8007 "static data member %q#D of non-integral type", decl
);
8009 error ("in-class initialization of static data member %q#D of "
8010 "non-literal type", decl
);
8014 /* Motion 10 at San Diego: If a static const integral data member is
8015 initialized with an integral constant expression, the initializer
8016 may appear either in the declaration (within the class), or in
8017 the definition, but not both. If it appears in the class, the
8018 member is a member constant. The file-scope definition is always
8020 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8022 error ("invalid in-class initialization of static data member "
8023 "of non-integral type %qT",
8027 else if (!CP_TYPE_CONST_P (type
))
8028 error ("ISO C++ forbids in-class initialization of non-const "
8029 "static member %qD",
8031 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8032 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8033 "%qD of non-integral type %qT", decl
, type
);
8038 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8039 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8040 expressions out into temporary variables so that walk_tree doesn't
8041 step into them (c++/15764). */
8044 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8046 struct pointer_set_t
*pset
= (struct pointer_set_t
*)data
;
8047 tree expr
= *expr_p
;
8048 if (TREE_CODE (expr
) == SAVE_EXPR
)
8050 tree op
= TREE_OPERAND (expr
, 0);
8051 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8052 if (TREE_SIDE_EFFECTS (op
))
8053 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8056 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8061 /* Entry point for the above. */
8064 stabilize_vla_size (tree size
)
8066 struct pointer_set_t
*pset
= pointer_set_create ();
8067 /* Break out any function calls into temporary variables. */
8068 cp_walk_tree (&size
, stabilize_save_expr_r
, pset
, pset
);
8069 pointer_set_destroy (pset
);
8072 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8073 not inside of SAVE_EXPR and fold them. */
8076 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8078 tree expr
= *expr_p
;
8079 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8081 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8083 *(bool *)data
= true;
8084 if (SIZEOF_EXPR_TYPE_P (expr
))
8085 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8086 SIZEOF_EXPR
, false);
8087 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8088 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8091 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8093 if (expr
== error_mark_node
)
8094 expr
= size_one_node
;
8101 /* Given the SIZE (i.e., number of elements) in an array, compute an
8102 appropriate index type for the array. If non-NULL, NAME is the
8103 name of the thing being declared. */
8106 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8110 tree abi_1_itype
= NULL_TREE
;
8112 if (error_operand_p (size
))
8113 return error_mark_node
;
8115 if (!type_dependent_expression_p (size
))
8117 tree type
= TREE_TYPE (size
);
8119 mark_rvalue_use (size
);
8121 if (cxx_dialect
< cxx0x
&& TREE_CODE (size
) == NOP_EXPR
8122 && TREE_SIDE_EFFECTS (size
))
8123 /* In C++98, we mark a non-constant array bound with a magic
8124 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8127 size
= fold_non_dependent_expr_sfinae (size
, complain
);
8129 if (CLASS_TYPE_P (type
)
8130 && CLASSTYPE_LITERAL_P (type
))
8132 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8135 if (!(complain
& tf_error
))
8136 return error_mark_node
;
8138 error ("size of array %qD has non-integral type %qT",
8141 error ("size of array has non-integral type %qT", type
);
8142 size
= integer_one_node
;
8144 if (size
== error_mark_node
)
8145 return error_mark_node
;
8146 type
= TREE_TYPE (size
);
8147 /* We didn't support this case in GCC 3.2, so don't bother
8148 trying to model it now in ABI v1. */
8149 abi_1_itype
= error_mark_node
;
8152 size
= maybe_constant_value (size
);
8153 if (!TREE_CONSTANT (size
))
8157 if (error_operand_p (size
))
8158 return error_mark_node
;
8160 /* The array bound must be an integer type. */
8161 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8163 if (!(complain
& tf_error
))
8164 return error_mark_node
;
8166 error ("size of array %qD has non-integral type %qT", name
, type
);
8168 error ("size of array has non-integral type %qT", type
);
8169 size
= integer_one_node
;
8170 type
= TREE_TYPE (size
);
8174 /* A type is dependent if it is...an array type constructed from any
8175 dependent type or whose size is specified by a constant expression
8176 that is value-dependent. */
8177 /* We can only call value_dependent_expression_p on integral constant
8178 expressions; treat non-constant expressions as dependent, too. */
8179 if (processing_template_decl
8180 && (type_dependent_expression_p (size
)
8181 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8183 /* We cannot do any checking for a SIZE that isn't known to be
8184 constant. Just build the index type and mark that it requires
8185 structural equality checks. */
8186 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8187 size
, integer_one_node
));
8188 TYPE_DEPENDENT_P (itype
) = 1;
8189 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8190 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8194 if (!abi_version_at_least (2) && processing_template_decl
8195 && abi_1_itype
== NULL_TREE
)
8196 /* For abi-1, we handled all instances in templates the same way,
8197 even when they were non-dependent. This affects the manglings
8198 produced. So, we do the normal checking for non-dependent
8199 sizes, but at the end we'll return the same type that abi-1
8200 would have, but with TYPE_CANONICAL set to the "right"
8201 value that the current ABI would provide. */
8202 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8203 osize
, integer_one_node
));
8205 /* Normally, the array-bound will be a constant. */
8206 if (TREE_CODE (size
) == INTEGER_CST
)
8208 /* Check to see if the array bound overflowed. Make that an
8209 error, no matter how generous we're being. */
8210 constant_expression_error (size
);
8212 /* An array must have a positive number of elements. */
8213 if (INT_CST_LT (size
, integer_zero_node
))
8215 if (!(complain
& tf_error
))
8216 return error_mark_node
;
8218 error ("size of array %qD is negative", name
);
8220 error ("size of array is negative");
8221 size
= integer_one_node
;
8223 /* As an extension we allow zero-sized arrays. */
8224 else if (integer_zerop (size
))
8226 if (!(complain
& tf_error
))
8227 /* We must fail if performing argument deduction (as
8228 indicated by the state of complain), so that
8229 another substitution can be found. */
8230 return error_mark_node
;
8231 else if (in_system_header
)
8232 /* Allow them in system headers because glibc uses them. */;
8234 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8236 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8239 else if (TREE_CONSTANT (size
)
8240 /* We don't allow VLAs at non-function scopes, or during
8241 tentative template substitution. */
8242 || !at_function_scope_p () || !(complain
& tf_error
))
8244 if (!(complain
& tf_error
))
8245 return error_mark_node
;
8246 /* `(int) &fn' is not a valid array bound. */
8248 error ("size of array %qD is not an integral constant-expression",
8251 error ("size of array is not an integral constant-expression");
8252 size
= integer_one_node
;
8254 else if (pedantic
&& warn_vla
!= 0)
8257 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8259 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8261 else if (warn_vla
> 0)
8265 "variable length array %qD is used", name
);
8268 "variable length array is used");
8271 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8272 /* A variable sized array. */
8273 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8276 HOST_WIDE_INT saved_processing_template_decl
;
8278 /* Compute the index of the largest element in the array. It is
8279 one less than the number of elements in the array. We save
8280 and restore PROCESSING_TEMPLATE_DECL so that computations in
8281 cp_build_binary_op will be appropriately folded. */
8282 saved_processing_template_decl
= processing_template_decl
;
8283 processing_template_decl
= 0;
8284 itype
= cp_build_binary_op (input_location
,
8286 cp_convert (ssizetype
, size
, complain
),
8287 cp_convert (ssizetype
, integer_one_node
,
8290 itype
= fold (itype
);
8291 processing_template_decl
= saved_processing_template_decl
;
8293 if (!TREE_CONSTANT (itype
))
8295 /* A variable sized array. */
8296 itype
= variable_size (itype
);
8297 if (TREE_CODE (itype
) != SAVE_EXPR
)
8299 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8300 they might survive till gimplification. */
8301 tree newitype
= itype
;
8303 cp_walk_tree_without_duplicates (&newitype
,
8304 fold_sizeof_expr_r
, &found
);
8306 itype
= variable_size (fold (newitype
));
8309 /* Make sure that there was no overflow when creating to a signed
8310 index type. (For example, on a 32-bit machine, an array with
8311 size 2^32 - 1 is too big.) */
8312 else if (TREE_CODE (itype
) == INTEGER_CST
8313 && TREE_OVERFLOW (itype
))
8315 if (!(complain
& tf_error
))
8316 return error_mark_node
;
8317 error ("overflow in array dimension");
8318 TREE_OVERFLOW (itype
) = 0;
8322 /* Create and return the appropriate index type. */
8323 if (abi_1_itype
&& abi_1_itype
!= error_mark_node
)
8325 tree t
= build_index_type (itype
);
8326 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
8327 itype
= abi_1_itype
;
8330 itype
= build_index_type (itype
);
8332 /* If the index type were dependent, we would have returned early, so
8333 remember that it isn't. */
8334 TYPE_DEPENDENT_P (itype
) = 0;
8335 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8339 /* Returns the scope (if any) in which the entity declared by
8340 DECLARATOR will be located. If the entity was declared with an
8341 unqualified name, NULL_TREE is returned. */
8344 get_scope_of_declarator (const cp_declarator
*declarator
)
8346 while (declarator
&& declarator
->kind
!= cdk_id
)
8347 declarator
= declarator
->declarator
;
8349 /* If the declarator-id is a SCOPE_REF, the scope in which the
8350 declaration occurs is the first operand. */
8352 && declarator
->u
.id
.qualifying_scope
)
8353 return declarator
->u
.id
.qualifying_scope
;
8355 /* Otherwise, the declarator is not a qualified name; the entity will
8356 be declared in the current scope. */
8360 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8361 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8365 create_array_type_for_decl (tree name
, tree type
, tree size
)
8367 tree itype
= NULL_TREE
;
8369 /* If things have already gone awry, bail now. */
8370 if (type
== error_mark_node
|| size
== error_mark_node
)
8371 return error_mark_node
;
8373 /* 8.3.4/1: If the type of the identifier of D contains the auto
8374 type-specifier, the program is ill-formed. */
8375 if (pedantic
&& type_uses_auto (type
))
8376 pedwarn (input_location
, OPT_Wpedantic
,
8377 "declaration of %qD as array of %<auto%>", name
);
8379 /* If there are some types which cannot be array elements,
8380 issue an error-message and return. */
8381 switch (TREE_CODE (type
))
8385 error ("declaration of %qD as array of void", name
);
8387 error ("creating array of void");
8388 return error_mark_node
;
8392 error ("declaration of %qD as array of functions", name
);
8394 error ("creating array of functions");
8395 return error_mark_node
;
8397 case REFERENCE_TYPE
:
8399 error ("declaration of %qD as array of references", name
);
8401 error ("creating array of references");
8402 return error_mark_node
;
8406 error ("declaration of %qD as array of function members", name
);
8408 error ("creating array of function members");
8409 return error_mark_node
;
8417 The constant expressions that specify the bounds of the arrays
8418 can be omitted only for the first member of the sequence. */
8419 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8422 error ("declaration of %qD as multidimensional array must "
8423 "have bounds for all dimensions except the first",
8426 error ("multidimensional array must have bounds for all "
8427 "dimensions except the first");
8429 return error_mark_node
;
8432 /* Figure out the index type for the array. */
8434 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8437 T is called the array element type; this type shall not be [...] an
8438 abstract class type. */
8439 abstract_virtuals_error (name
, type
);
8441 return build_cplus_array_type (type
, itype
);
8444 /* Check that it's OK to declare a function with the indicated TYPE.
8445 SFK indicates the kind of special function (if any) that this
8446 function is. OPTYPE is the type given in a conversion operator
8447 declaration, or the class type for a constructor/destructor.
8448 Returns the actual return type of the function; that
8449 may be different than TYPE if an error occurs, or for certain
8450 special functions. */
8453 check_special_function_return_type (special_function_kind sfk
,
8459 case sfk_constructor
:
8461 error ("return type specification for constructor invalid");
8463 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8464 type
= build_pointer_type (optype
);
8466 type
= void_type_node
;
8469 case sfk_destructor
:
8471 error ("return type specification for destructor invalid");
8472 /* We can't use the proper return type here because we run into
8473 problems with ambiguous bases and covariant returns.
8474 Java classes are left unchanged because (void *) isn't a valid
8475 Java type, and we don't want to change the Java ABI. */
8476 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8477 type
= build_pointer_type (void_type_node
);
8479 type
= void_type_node
;
8482 case sfk_conversion
:
8484 error ("return type specified for %<operator %T%>", optype
);
8495 /* A variable or data member (whose unqualified name is IDENTIFIER)
8496 has been declared with the indicated TYPE. If the TYPE is not
8497 acceptable, issue an error message and return a type to use for
8498 error-recovery purposes. */
8501 check_var_type (tree identifier
, tree type
)
8503 if (VOID_TYPE_P (type
))
8506 error ("unnamed variable or field declared void");
8507 else if (TREE_CODE (identifier
) == IDENTIFIER_NODE
)
8509 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8510 error ("variable or field %qE declared void", identifier
);
8513 error ("variable or field declared void");
8514 type
= error_mark_node
;
8520 /* Functions for adjusting the visibility of a tagged type and its nested
8521 types when it gets a name for linkage purposes from a typedef. */
8523 static void bt_reset_linkage (binding_entry
, void *);
8525 reset_type_linkage (tree type
)
8527 set_linkage_according_to_type (type
, TYPE_MAIN_DECL (type
));
8528 if (CLASS_TYPE_P (type
))
8529 binding_table_foreach (CLASSTYPE_NESTED_UTDS (type
), bt_reset_linkage
, NULL
);
8532 bt_reset_linkage (binding_entry b
, void */
*data*/
)
8534 reset_type_linkage (b
->type
);
8537 /* Given declspecs and a declarator (abstract or otherwise), determine
8538 the name and type of the object declared and construct a DECL node
8541 DECLSPECS points to the representation of declaration-specifier
8542 sequence that precedes declarator.
8544 DECL_CONTEXT says which syntactic context this declaration is in:
8545 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8546 FUNCDEF for a function definition. Like NORMAL but a few different
8547 error messages in each case. Return value may be zero meaning
8548 this definition is too screwy to try to parse.
8549 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8550 handle member functions (which have FIELD context).
8551 Return value may be zero meaning this definition is too screwy to
8553 PARM for a parameter declaration (either within a function prototype
8554 or before a function body). Make a PARM_DECL, or return void_type_node.
8555 TPARM for a template parameter declaration.
8556 CATCHPARM for a parameter declaration before a catch clause.
8557 TYPENAME if for a typename (in a cast or sizeof).
8558 Don't make a DECL node; just return the ..._TYPE node.
8559 FIELD for a struct or union field; make a FIELD_DECL.
8560 BITFIELD for a field with specified width.
8562 INITIALIZED is as for start_decl.
8564 ATTRLIST is a pointer to the list of attributes, which may be NULL
8565 if there are none; *ATTRLIST may be modified if attributes from inside
8566 the declarator should be applied to the declaration.
8568 When this function is called, scoping variables (such as
8569 CURRENT_CLASS_TYPE) should reflect the scope in which the
8570 declaration occurs, not the scope in which the new declaration will
8571 be placed. For example, on:
8575 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8578 Returns a DECL (if a declarator is present), a TYPE (if there is no
8579 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8583 grokdeclarator (const cp_declarator
*declarator
,
8584 cp_decl_specifier_seq
*declspecs
,
8585 enum decl_context decl_context
,
8589 tree type
= NULL_TREE
;
8591 int explicit_int128
= 0;
8592 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8593 int explicit_int
= 0;
8594 int explicit_char
= 0;
8595 int defaulted_int
= 0;
8596 tree dependent_name
= NULL_TREE
;
8598 tree typedef_decl
= NULL_TREE
;
8599 const char *name
= NULL
;
8600 tree typedef_type
= NULL_TREE
;
8601 /* True if this declarator is a function definition. */
8602 bool funcdef_flag
= false;
8603 cp_declarator_kind innermost_code
= cdk_error
;
8606 /* See the code below that used this. */
8607 tree decl_attr
= NULL_TREE
;
8610 /* Keep track of what sort of function is being processed
8611 so that we can warn about default return values, or explicit
8612 return values which do not match prescribed defaults. */
8613 special_function_kind sfk
= sfk_none
;
8615 tree dname
= NULL_TREE
;
8616 tree ctor_return_type
= NULL_TREE
;
8617 enum overload_flags flags
= NO_SPECIAL
;
8618 /* cv-qualifiers that apply to the declarator, for a declaration of
8619 a member function. */
8620 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8621 /* virt-specifiers that apply to the declarator, for a declaration of
8622 a member function. */
8623 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8624 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8626 tree raises
= NULL_TREE
;
8627 int template_count
= 0;
8628 tree returned_attrs
= NULL_TREE
;
8629 tree parms
= NULL_TREE
;
8630 const cp_declarator
*id_declarator
;
8631 /* The unqualified name of the declarator; either an
8632 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8633 tree unqualified_id
;
8634 /* The class type, if any, in which this entity is located,
8635 or NULL_TREE if none. Note that this value may be different from
8636 the current class type; for example if an attempt is made to declare
8637 "A::f" inside "B", this value will be "A". */
8638 tree ctype
= current_class_type
;
8639 /* The NAMESPACE_DECL for the namespace in which this entity is
8640 located. If an unqualified name is used to declare the entity,
8641 this value will be NULL_TREE, even if the entity is located at
8643 tree in_namespace
= NULL_TREE
;
8644 cp_storage_class storage_class
;
8645 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8646 bool type_was_error_mark_node
= false;
8647 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8648 bool template_type_arg
= false;
8649 bool template_parm_flag
= false;
8650 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8653 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8654 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8655 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8656 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8657 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8658 explicit_int128
= declspecs
->explicit_int128_p
;
8659 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8661 if (decl_context
== FUNCDEF
)
8662 funcdef_flag
= true, decl_context
= NORMAL
;
8663 else if (decl_context
== MEMFUNCDEF
)
8664 funcdef_flag
= true, decl_context
= FIELD
;
8665 else if (decl_context
== BITFIELD
)
8666 bitfield
= 1, decl_context
= FIELD
;
8667 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8668 template_type_arg
= true, decl_context
= TYPENAME
;
8669 else if (decl_context
== TPARM
)
8670 template_parm_flag
= true, decl_context
= PARM
;
8672 if (initialized
> 1)
8673 funcdef_flag
= true;
8675 /* Look inside a declarator for the name being declared
8676 and get it as a string, for an error message. */
8677 for (id_declarator
= declarator
;
8679 id_declarator
= id_declarator
->declarator
)
8681 if (id_declarator
->kind
!= cdk_id
)
8682 innermost_code
= id_declarator
->kind
;
8684 switch (id_declarator
->kind
)
8687 if (id_declarator
->declarator
8688 && id_declarator
->declarator
->kind
== cdk_id
)
8690 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8691 if (sfk
== sfk_destructor
)
8698 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8699 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8702 if (qualifying_scope
)
8704 if (at_function_scope_p ())
8708 A declarator-id shall not be qualified except
8711 None of the cases are permitted in block
8713 if (qualifying_scope
== global_namespace
)
8714 error ("invalid use of qualified-name %<::%D%>",
8716 else if (TYPE_P (qualifying_scope
))
8717 error ("invalid use of qualified-name %<%T::%D%>",
8718 qualifying_scope
, decl
);
8720 error ("invalid use of qualified-name %<%D::%D%>",
8721 qualifying_scope
, decl
);
8722 return error_mark_node
;
8724 else if (TYPE_P (qualifying_scope
))
8726 ctype
= qualifying_scope
;
8727 if (!MAYBE_CLASS_TYPE_P (ctype
))
8729 error ("%q#T is not a class or a namespace", ctype
);
8732 else if (innermost_code
!= cdk_function
8733 && current_class_type
8734 && !uniquely_derived_from_p (ctype
,
8735 current_class_type
))
8737 error ("type %qT is not derived from type %qT",
8738 ctype
, current_class_type
);
8739 return error_mark_node
;
8742 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
8743 in_namespace
= qualifying_scope
;
8745 switch (TREE_CODE (decl
))
8751 if (innermost_code
!= cdk_function
)
8753 error ("declaration of %qD as non-function", decl
);
8754 return error_mark_node
;
8756 else if (!qualifying_scope
8757 && !(current_class_type
&& at_class_scope_p ()))
8759 error ("declaration of %qD as non-member", decl
);
8760 return error_mark_node
;
8763 type
= TREE_OPERAND (decl
, 0);
8765 type
= constructor_name (type
);
8766 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
8771 case TEMPLATE_ID_EXPR
:
8773 tree fns
= TREE_OPERAND (decl
, 0);
8776 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
8778 gcc_assert (is_overloaded_fn (dname
));
8779 dname
= DECL_NAME (get_first_fn (dname
));
8784 case IDENTIFIER_NODE
:
8785 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
8788 if (C_IS_RESERVED_WORD (dname
))
8790 error ("declarator-id missing; using reserved word %qD",
8792 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8794 else if (!IDENTIFIER_TYPENAME_P (dname
))
8795 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8798 gcc_assert (flags
== NO_SPECIAL
);
8799 flags
= TYPENAME_FLAG
;
8800 ctor_return_type
= TREE_TYPE (dname
);
8801 sfk
= sfk_conversion
;
8802 if (is_typename_at_global_scope (dname
))
8803 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8805 name
= "<invalid operator>";
8822 return error_mark_node
;
8827 if (id_declarator
->kind
== cdk_id
)
8833 The declarator in a function-definition shall have the form
8834 D1 ( parameter-declaration-clause) ... */
8835 if (funcdef_flag
&& innermost_code
!= cdk_function
)
8837 error ("function definition does not declare parameters");
8838 return error_mark_node
;
8841 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8842 && innermost_code
!= cdk_function
8843 && ! (ctype
&& !declspecs
->any_specifiers_p
))
8845 error ("declaration of %qD as non-function", dname
);
8846 return error_mark_node
;
8850 && TREE_CODE (dname
) == IDENTIFIER_NODE
8851 && UDLIT_OPER_P (dname
)
8852 && innermost_code
!= cdk_function
)
8854 error ("declaration of %qD as non-function", dname
);
8855 return error_mark_node
;
8858 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
8860 if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
8862 error ("declaration of %qD as %<typedef%>", dname
);
8863 return error_mark_node
;
8865 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8867 error ("declaration of %qD as parameter", dname
);
8868 return error_mark_node
;
8872 /* Anything declared one level down from the top level
8873 must be one of the parameters of a function
8874 (because the body is at least two levels down). */
8876 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8877 by not allowing C++ class definitions to specify their parameters
8878 with xdecls (must be spec.d in the parmlist).
8880 Since we now wait to push a class scope until we are sure that
8881 we are in a legitimate method context, we must set oldcname
8882 explicitly (since current_class_name is not yet alive).
8884 We also want to avoid calling this a PARM if it is in a namespace. */
8886 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
8888 cp_binding_level
*b
= current_binding_level
;
8889 current_binding_level
= b
->level_chain
;
8890 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8891 decl_context
= PARM
;
8892 current_binding_level
= b
;
8896 name
= decl_context
== PARM
? "parameter" : "type name";
8898 if (constexpr_p
&& decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
8900 error ("%<constexpr%> cannot appear in a typedef declaration");
8901 return error_mark_node
;
8904 /* If there were multiple types specified in the decl-specifier-seq,
8905 issue an error message. */
8906 if (declspecs
->multiple_types_p
)
8908 error ("two or more data types in declaration of %qs", name
);
8909 return error_mark_node
;
8912 if (declspecs
->conflicting_specifiers_p
)
8914 error ("conflicting specifiers in declaration of %qs", name
);
8915 return error_mark_node
;
8918 /* Extract the basic type from the decl-specifier-seq. */
8919 type
= declspecs
->type
;
8920 if (type
== error_mark_node
)
8923 type_was_error_mark_node
= true;
8925 /* If the entire declaration is itself tagged as deprecated then
8926 suppress reports of deprecated items. */
8927 if (type
&& TREE_DEPRECATED (type
)
8928 && deprecated_state
!= DEPRECATED_SUPPRESS
)
8929 warn_deprecated_use (type
, NULL_TREE
);
8930 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
8932 typedef_decl
= type
;
8933 type
= TREE_TYPE (typedef_decl
);
8934 if (TREE_DEPRECATED (type
)
8935 && DECL_ARTIFICIAL (typedef_decl
)
8936 && deprecated_state
!= DEPRECATED_SUPPRESS
)
8937 warn_deprecated_use (type
, NULL_TREE
);
8939 /* No type at all: default to `int', and set DEFAULTED_INT
8940 because it was not a user-defined typedef. */
8941 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
8943 /* These imply 'int'. */
8944 type
= integer_type_node
;
8948 explicit_int
= declspecs
->explicit_int_p
;
8949 explicit_char
= declspecs
->explicit_char_p
;
8952 /* See the code below that used this. */
8954 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
8956 typedef_type
= type
;
8959 if (sfk
!= sfk_conversion
)
8960 ctor_return_type
= ctype
;
8962 if (sfk
!= sfk_none
)
8963 type
= check_special_function_return_type (sfk
, type
,
8965 else if (type
== NULL_TREE
)
8971 /* We handle `main' specially here, because 'main () { }' is so
8972 common. With no options, it is allowed. With -Wreturn-type,
8973 it is a warning. It is only an error with -pedantic-errors. */
8974 is_main
= (funcdef_flag
8975 && dname
&& TREE_CODE (dname
) == IDENTIFIER_NODE
8976 && MAIN_NAME_P (dname
)
8977 && ctype
== NULL_TREE
8978 && in_namespace
== NULL_TREE
8979 && current_namespace
== global_namespace
);
8981 if (type_was_error_mark_node
)
8982 /* We've already issued an error, don't complain more. */;
8983 else if (in_system_header
|| flag_ms_extensions
)
8984 /* Allow it, sigh. */;
8986 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
8988 pedwarn (input_location
, OPT_Wpedantic
,
8989 "ISO C++ forbids declaration of %qs with no type", name
);
8991 warning (OPT_Wreturn_type
,
8992 "ISO C++ forbids declaration of %qs with no type", name
);
8994 type
= integer_type_node
;
8999 if (explicit_int128
)
9001 if (int128_integer_type_node
== NULL_TREE
)
9003 error ("%<__int128%> is not supported by this target");
9004 explicit_int128
= false;
9006 else if (pedantic
&& ! in_system_header
)
9007 pedwarn (input_location
, OPT_Wpedantic
,
9008 "ISO C++ does not support %<__int128%> for %qs", name
);
9011 /* Now process the modifiers that were specified
9012 and check for invalid combinations. */
9014 /* Long double is a special combination. */
9015 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9018 type
= cp_build_qualified_type (long_double_type_node
,
9019 cp_type_quals (type
));
9022 /* Check all other uses of type modifiers. */
9024 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9028 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9029 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9030 else if (signed_p
&& unsigned_p
)
9031 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9032 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9033 error ("%<long long%> invalid for %qs", name
);
9034 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9035 error ("%<long%> invalid for %qs", name
);
9036 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9037 error ("%<short%> invalid for %qs", name
);
9038 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9039 error ("%<long%> or %<short%> invalid for %qs", name
);
9040 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_int128
)
9041 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9042 else if ((long_p
|| short_p
) && explicit_char
)
9043 error ("%<long%> or %<short%> specified with char for %qs", name
);
9044 else if (long_p
&& short_p
)
9045 error ("%<long%> and %<short%> specified together for %qs", name
);
9046 else if (type
== char16_type_node
|| type
== char32_type_node
)
9048 if (signed_p
|| unsigned_p
)
9049 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9050 else if (short_p
|| long_p
)
9051 error ("%<short%> or %<long%> invalid for %qs", name
);
9056 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_int128
&& pedantic
)
9058 pedwarn (input_location
, OPT_Wpedantic
,
9059 "long, short, signed or unsigned used invalidly for %qs",
9061 if (flag_pedantic_errors
)
9066 /* Discard the type modifiers if they are invalid. */
9077 /* Decide whether an integer type is signed or not.
9078 Optionally treat bitfields as signed by default. */
9082 It is implementation-defined whether a plain (neither
9083 explicitly signed or unsigned) char, short, int, or long
9084 bit-field is signed or unsigned.
9086 Naturally, we extend this to long long as well. Note that
9087 this does not include wchar_t. */
9088 || (bitfield
&& !flag_signed_bitfields
9090 /* A typedef for plain `int' without `signed' can be
9091 controlled just like plain `int', but a typedef for
9092 `signed int' cannot be so controlled. */
9094 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9095 && TREE_CODE (type
) == INTEGER_TYPE
9096 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9098 if (explicit_int128
)
9099 type
= int128_unsigned_type_node
;
9101 type
= long_long_unsigned_type_node
;
9103 type
= long_unsigned_type_node
;
9105 type
= short_unsigned_type_node
;
9106 else if (type
== char_type_node
)
9107 type
= unsigned_char_type_node
;
9108 else if (typedef_decl
)
9109 type
= unsigned_type_for (type
);
9111 type
= unsigned_type_node
;
9113 else if (signed_p
&& type
== char_type_node
)
9114 type
= signed_char_type_node
;
9115 else if (explicit_int128
)
9116 type
= int128_integer_type_node
;
9118 type
= long_long_integer_type_node
;
9120 type
= long_integer_type_node
;
9122 type
= short_integer_type_node
;
9124 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9126 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9127 error ("complex invalid for %qs", name
);
9128 /* If we just have "complex", it is equivalent to
9129 "complex double", but if any modifiers at all are specified it is
9130 the complex form of TYPE. E.g, "complex short" is
9131 "complex short int". */
9132 else if (defaulted_int
&& ! longlong
&& ! explicit_int128
9133 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
9134 type
= complex_double_type_node
;
9135 else if (type
== integer_type_node
)
9136 type
= complex_integer_type_node
;
9137 else if (type
== float_type_node
)
9138 type
= complex_float_type_node
;
9139 else if (type
== double_type_node
)
9140 type
= complex_double_type_node
;
9141 else if (type
== long_double_type_node
)
9142 type
= complex_long_double_type_node
;
9144 type
= build_complex_type (type
);
9147 type_quals
= TYPE_UNQUALIFIED
;
9148 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9149 type_quals
|= TYPE_QUAL_CONST
;
9150 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9151 type_quals
|= TYPE_QUAL_VOLATILE
;
9152 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9153 type_quals
|= TYPE_QUAL_RESTRICT
;
9154 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9155 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9158 /* If we're using the injected-class-name to form a compound type or a
9159 declaration, replace it with the underlying class so we don't get
9160 redundant typedefs in the debug output. But if we are returning the
9161 type unchanged, leave it alone so that it's available to
9162 maybe_get_template_decl_from_type_decl. */
9163 if (CLASS_TYPE_P (type
)
9164 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9165 && type
== TREE_TYPE (TYPE_NAME (type
))
9166 && (declarator
|| type_quals
))
9167 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9169 type_quals
|= cp_type_quals (type
);
9170 type
= cp_build_qualified_type_real
9171 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
9172 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9173 /* We might have ignored or rejected some of the qualifiers. */
9174 type_quals
= cp_type_quals (type
);
9177 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9178 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9179 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9181 storage_class
= declspecs
->storage_class
;
9182 if (storage_class
== sc_static
)
9183 staticp
= 1 + (decl_context
== FIELD
);
9185 if (virtualp
&& staticp
== 2)
9187 error ("member %qD cannot be declared both virtual and static", dname
);
9188 storage_class
= sc_none
;
9191 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9193 if (dependent_name
&& !friendp
)
9195 error ("%<%T::%D%> is not a valid declarator", ctype
, dependent_name
);
9196 return error_mark_node
;
9199 /* Issue errors about use of storage classes for parameters. */
9200 if (decl_context
== PARM
)
9202 if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
9204 error ("typedef declaration invalid in parameter declaration");
9205 return error_mark_node
;
9207 else if (template_parm_flag
&& storage_class
!= sc_none
)
9209 error ("storage class specified for template parameter %qs", name
);
9210 return error_mark_node
;
9212 else if (storage_class
== sc_static
9213 || storage_class
== sc_extern
9215 error ("storage class specifiers invalid in parameter declarations");
9217 /* Function parameters cannot be constexpr. If we saw one, moan
9218 and pretend it wasn't there. */
9221 error ("a parameter cannot be declared %<constexpr%>");
9226 /* Give error if `virtual' is used outside of class declaration. */
9228 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9230 error ("%<virtual%> outside class declaration");
9234 /* Static anonymous unions are dealt with here. */
9235 if (staticp
&& decl_context
== TYPENAME
9237 && ANON_AGGR_TYPE_P (declspecs
->type
))
9238 decl_context
= FIELD
;
9240 /* Warn about storage classes that are invalid for certain
9241 kinds of declarations (parameters, typenames, etc.). */
9244 && storage_class
!= sc_extern
9245 && storage_class
!= sc_static
)
9246 || decl_spec_seq_has_spec_p (declspecs
, ds_typedef
)))
9248 error ("multiple storage classes in declaration of %qs", name
);
9251 if (decl_context
!= NORMAL
9252 && ((storage_class
!= sc_none
9253 && storage_class
!= sc_mutable
)
9256 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9257 && (storage_class
== sc_register
9258 || storage_class
== sc_auto
))
9260 else if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
9262 else if (decl_context
== FIELD
9263 /* C++ allows static class elements. */
9264 && storage_class
== sc_static
)
9265 /* C++ also allows inlines and signed and unsigned elements,
9266 but in those cases we don't come in here. */
9270 if (decl_context
== FIELD
)
9271 error ("storage class specified for %qs", name
);
9274 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9275 error ("storage class specified for parameter %qs", name
);
9277 error ("storage class specified for typename");
9279 if (storage_class
== sc_register
9280 || storage_class
== sc_auto
9281 || storage_class
== sc_extern
9283 storage_class
= sc_none
;
9286 else if (storage_class
== sc_extern
&& funcdef_flag
9287 && ! toplevel_bindings_p ())
9288 error ("nested function %qs declared %<extern%>", name
);
9289 else if (toplevel_bindings_p ())
9291 if (storage_class
== sc_auto
)
9292 error ("top-level declaration of %qs specifies %<auto%>", name
);
9295 && storage_class
!= sc_extern
9296 && storage_class
!= sc_static
)
9298 if (declspecs
->gnu_thread_keyword_p
)
9299 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9300 "declared %<__thread%>", name
);
9302 /* When thread_local is applied to a variable of block scope the
9303 storage-class-specifier static is implied if it does not appear
9305 storage_class
= declspecs
->storage_class
= sc_static
;
9309 if (storage_class
&& friendp
)
9311 error ("storage class specifiers invalid in friend function declarations");
9312 storage_class
= sc_none
;
9317 unqualified_id
= NULL_TREE
;
9320 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9321 switch (TREE_CODE (unqualified_id
))
9324 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9325 if (TYPE_P (unqualified_id
))
9326 unqualified_id
= constructor_name (unqualified_id
);
9329 case IDENTIFIER_NODE
:
9330 case TEMPLATE_ID_EXPR
:
9338 if (declspecs
->std_attributes
)
9340 /* Apply the c++11 attributes to the type preceding them. */
9341 source_location saved_loc
= input_location
;
9342 input_location
= declspecs
->locations
[ds_std_attribute
];
9343 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9344 input_location
= saved_loc
;
9347 /* Determine the type of the entity declared by recurring on the
9349 for (; declarator
; declarator
= declarator
->declarator
)
9351 const cp_declarator
*inner_declarator
;
9354 if (type
== error_mark_node
)
9355 return error_mark_node
;
9357 attrs
= declarator
->attributes
;
9363 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9364 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9365 if (declarator
->kind
== cdk_function
)
9366 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9367 if (declarator
->kind
== cdk_array
)
9368 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9369 returned_attrs
= decl_attributes (&type
,
9370 chainon (returned_attrs
, attrs
),
9374 if (declarator
->kind
== cdk_id
)
9377 inner_declarator
= declarator
->declarator
;
9379 switch (declarator
->kind
)
9382 type
= create_array_type_for_decl (dname
, type
,
9383 declarator
->u
.array
.bounds
);
9384 if (declarator
->std_attributes
)
9387 The optional attribute-specifier-seq appertains to the
9389 returned_attrs
= chainon (returned_attrs
,
9390 declarator
->std_attributes
);
9398 /* Declaring a function type.
9399 Make sure we have a valid type for the function to return. */
9401 if (type_quals
!= TYPE_UNQUALIFIED
)
9403 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9404 warning (OPT_Wignored_qualifiers
,
9405 "type qualifiers ignored on function return type");
9406 /* We now know that the TYPE_QUALS don't apply to the
9407 decl, but to its return type. */
9408 type_quals
= TYPE_UNQUALIFIED
;
9410 errmsg
= targetm
.invalid_return_type (type
);
9414 type
= integer_type_node
;
9417 /* Error about some types functions can't return. */
9419 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9421 error ("%qs declared as function returning a function", name
);
9422 return error_mark_node
;
9424 if (TREE_CODE (type
) == ARRAY_TYPE
)
9426 error ("%qs declared as function returning an array", name
);
9427 return error_mark_node
;
9429 /* When decl_context == NORMAL we emit a better error message
9430 later in abstract_virtuals_error. */
9431 if (decl_context
== TYPENAME
&& ABSTRACT_CLASS_TYPE_P (type
))
9432 error ("%qs declared as function returning an abstract "
9433 "class type", name
);
9435 /* Pick up type qualifiers which should be applied to `this'. */
9436 memfn_quals
= declarator
->u
.function
.qualifiers
;
9437 /* Pick up virt-specifiers. */
9438 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9439 /* Pick up the exception specifications. */
9440 raises
= declarator
->u
.function
.exception_specification
;
9441 /* If the exception-specification is ill-formed, let's pretend
9442 there wasn't one. */
9443 if (raises
== error_mark_node
)
9446 /* Say it's a definition only for the CALL_EXPR
9447 closest to the identifier. */
9448 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9450 /* Handle a late-specified return type. */
9453 if (type_uses_auto (type
))
9455 if (!declarator
->u
.function
.late_return_type
)
9457 if (current_class_type
9458 && LAMBDA_TYPE_P (current_class_type
))
9459 /* OK for C++11 lambdas. */;
9460 else if (cxx_dialect
< cxx1y
)
9461 pedwarn (input_location
, 0, "%qs function uses "
9462 "%<auto%> type specifier without trailing "
9463 "return type", name
);
9465 else if (!is_auto (type
))
9467 error ("%qs function with trailing return type has"
9468 " %qT as its type rather than plain %<auto%>",
9470 return error_mark_node
;
9473 else if (declarator
->u
.function
.late_return_type
)
9475 if (cxx_dialect
< cxx0x
)
9476 /* Not using maybe_warn_cpp0x because this should
9477 always be an error. */
9478 error ("trailing return type only available with "
9479 "-std=c++11 or -std=gnu++11");
9481 error ("%qs function with trailing return type not "
9482 "declared with %<auto%> type specifier", name
);
9483 return error_mark_node
;
9486 type
= splice_late_return_type
9487 (type
, declarator
->u
.function
.late_return_type
);
9488 if (type
== error_mark_node
)
9489 return error_mark_node
;
9491 if (ctype
== NULL_TREE
9492 && decl_context
== FIELD
9494 && (friendp
== 0 || dname
== current_class_name
))
9495 ctype
= current_class_type
;
9497 if (ctype
&& (sfk
== sfk_constructor
9498 || sfk
== sfk_destructor
))
9500 /* We are within a class's scope. If our declarator name
9501 is the same as the class name, and we are defining
9502 a function, then it is a constructor/destructor, and
9503 therefore returns a void type. */
9505 /* ISO C++ 12.4/2. A destructor may not be declared
9506 const or volatile. A destructor may not be
9509 ISO C++ 12.1. A constructor may not be declared
9510 const or volatile. A constructor may not be
9511 virtual. A constructor may not be static. */
9513 error ((flags
== DTOR_FLAG
)
9514 ? G_("destructor cannot be static member function")
9515 : G_("constructor cannot be static member function"));
9518 error ((flags
== DTOR_FLAG
)
9519 ? G_("destructors may not be cv-qualified")
9520 : G_("constructors may not be cv-qualified"));
9521 memfn_quals
= TYPE_UNQUALIFIED
;
9524 if (decl_context
== FIELD
9525 && !member_function_or_else (ctype
,
9528 return error_mark_node
;
9530 if (flags
!= DTOR_FLAG
)
9532 /* It's a constructor. */
9537 permerror (input_location
, "constructors cannot be declared virtual");
9540 if (decl_context
== FIELD
9541 && sfk
!= sfk_constructor
)
9542 return error_mark_node
;
9544 if (decl_context
== FIELD
)
9550 error ("can%'t initialize friend function %qs", name
);
9553 /* Cannot be both friend and virtual. */
9554 error ("virtual functions cannot be friends");
9557 if (decl_context
== NORMAL
)
9558 error ("friend declaration not in class definition");
9559 if (current_function_decl
&& funcdef_flag
)
9560 error ("can%'t define friend function %qs in a local "
9564 else if (ctype
&& sfk
== sfk_conversion
)
9568 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9573 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9576 if (inner_declarator
9577 && inner_declarator
->kind
== cdk_id
9578 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9579 && arg_types
!= void_list_node
)
9581 error ("destructors may not have parameters");
9582 arg_types
= void_list_node
;
9586 type
= build_function_type (type
, arg_types
);
9587 if (declarator
->std_attributes
)
9590 The optional attribute-specifier-seq appertains to
9591 the function type. */
9592 decl_attributes (&type
, declarator
->std_attributes
,
9600 /* Filter out pointers-to-references and references-to-references.
9601 We can get these if a TYPE_DECL is used. */
9603 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9605 if (declarator
->kind
!= cdk_reference
)
9607 error ("cannot declare pointer to %q#T", type
);
9608 type
= TREE_TYPE (type
);
9611 /* In C++0x, we allow reference to reference declarations
9612 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9613 and template type arguments [14.3.1/4 temp.arg.type]. The
9614 check for direct reference to reference declarations, which
9615 are still forbidden, occurs below. Reasoning behind the change
9616 can be found in DR106, DR540, and the rvalue reference
9618 else if (cxx_dialect
== cxx98
)
9620 error ("cannot declare reference to %q#T", type
);
9621 type
= TREE_TYPE (type
);
9624 else if (VOID_TYPE_P (type
))
9626 if (declarator
->kind
== cdk_reference
)
9627 error ("cannot declare reference to %q#T", type
);
9628 else if (declarator
->kind
== cdk_ptrmem
)
9629 error ("cannot declare pointer to %q#T member", type
);
9632 /* We now know that the TYPE_QUALS don't apply to the decl,
9633 but to the target of the pointer. */
9634 type_quals
= TYPE_UNQUALIFIED
;
9636 if (declarator
->kind
== cdk_ptrmem
9637 && (TREE_CODE (type
) == FUNCTION_TYPE
9638 || (memfn_quals
&& TREE_CODE (type
) == METHOD_TYPE
)))
9640 memfn_quals
|= type_memfn_quals (type
);
9641 type
= build_memfn_type (type
,
9642 declarator
->u
.pointer
.class_type
,
9644 if (type
== error_mark_node
)
9645 return error_mark_node
;
9646 memfn_quals
= TYPE_UNQUALIFIED
;
9649 if (TREE_CODE (type
) == FUNCTION_TYPE
9650 && type_memfn_quals (type
) != TYPE_UNQUALIFIED
)
9651 error (declarator
->kind
== cdk_reference
9652 ? G_("cannot declare reference to qualified function type %qT")
9653 : G_("cannot declare pointer to qualified function type %qT"),
9656 /* When the pointed-to type involves components of variable size,
9657 care must be taken to ensure that the size evaluation code is
9658 emitted early enough to dominate all the possible later uses
9659 and late enough for the variables on which it depends to have
9662 This is expected to happen automatically when the pointed-to
9663 type has a name/declaration of it's own, but special attention
9664 is required if the type is anonymous.
9666 We handle the NORMAL and FIELD contexts here by inserting a
9667 dummy statement that just evaluates the size at a safe point
9668 and ensures it is not deferred until e.g. within a deeper
9669 conditional context (c++/43555).
9671 We expect nothing to be needed here for PARM or TYPENAME.
9672 Evaluating the size at this point for TYPENAME would
9673 actually be incorrect, as we might be in the middle of an
9674 expression with side effects on the pointed-to type size
9675 "arguments" prior to the pointer declaration point and the
9676 size evaluation could end up prior to the side effects. */
9678 if (!TYPE_NAME (type
)
9679 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9680 && at_function_scope_p ()
9681 && variably_modified_type_p (type
, NULL_TREE
))
9683 /* First break out any side-effects. */
9684 stabilize_vla_size (TYPE_SIZE (type
));
9685 /* And then force evaluation of the SAVE_EXPR. */
9686 finish_expr_stmt (TYPE_SIZE (type
));
9689 if (declarator
->kind
== cdk_reference
)
9691 /* In C++0x, the type we are creating a reference to might be
9692 a typedef which is itself a reference type. In that case,
9693 we follow the reference collapsing rules in
9694 [7.1.3/8 dcl.typedef] to create the final reference type:
9696 "If a typedef TD names a type that is a reference to a type
9697 T, an attempt to create the type 'lvalue reference to cv TD'
9698 creates the type 'lvalue reference to T,' while an attempt
9699 to create the type "rvalue reference to cv TD' creates the
9702 if (VOID_TYPE_P (type
))
9703 /* We already gave an error. */;
9704 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9706 if (declarator
->u
.reference
.rvalue_ref
)
9707 /* Leave type alone. */;
9709 type
= cp_build_reference_type (TREE_TYPE (type
), false);
9712 type
= cp_build_reference_type
9713 (type
, declarator
->u
.reference
.rvalue_ref
);
9715 /* In C++0x, we need this check for direct reference to
9716 reference declarations, which are forbidden by
9717 [8.3.2/5 dcl.ref]. Reference to reference declarations
9718 are only allowed indirectly through typedefs and template
9719 type arguments. Example:
9721 void foo(int & &); // invalid ref-to-ref decl
9723 typedef int & int_ref;
9724 void foo(int_ref &); // valid ref-to-ref decl
9726 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
9727 error ("cannot declare reference to %q#T, which is not "
9728 "a typedef or a template type argument", type
);
9730 else if (TREE_CODE (type
) == METHOD_TYPE
)
9731 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9732 else if (declarator
->kind
== cdk_ptrmem
)
9734 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
9736 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
9737 /* We will already have complained. */
9738 type
= error_mark_node
;
9740 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
9744 type
= build_pointer_type (type
);
9746 /* Process a list of type modifier keywords (such as
9747 const or volatile) that were given inside the `*' or `&'. */
9749 if (declarator
->u
.pointer
.qualifiers
)
9752 = cp_build_qualified_type (type
,
9753 declarator
->u
.pointer
.qualifiers
);
9754 type_quals
= cp_type_quals (type
);
9757 /* Apply C++11 attributes to the pointer, and not to the
9758 type pointed to. This is unlike what is done for GNU
9759 attributes above. It is to comply with [dcl.ptr]/1:
9761 [the optional attribute-specifier-seq (7.6.1) appertains
9762 to the pointer and not to the object pointed to]. */
9763 if (declarator
->std_attributes
)
9764 decl_attributes (&type
, declarator
->std_attributes
,
9778 /* We need to stabilize side-effects in VLA sizes for regular array
9779 declarations too, not just pointers to arrays. */
9780 if (type
!= error_mark_node
&& !TYPE_NAME (type
)
9781 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9782 && at_function_scope_p ()
9783 && variably_modified_type_p (type
, NULL_TREE
))
9784 stabilize_vla_size (TYPE_SIZE (type
));
9786 /* A `constexpr' specifier used in an object declaration declares
9787 the object as `const'. */
9788 if (constexpr_p
&& innermost_code
!= cdk_function
)
9790 if (type_quals
& TYPE_QUAL_VOLATILE
)
9791 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9792 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9794 type_quals
|= TYPE_QUAL_CONST
;
9795 type
= cp_build_qualified_type (type
, type_quals
);
9799 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
9800 && TREE_CODE (type
) != FUNCTION_TYPE
9801 && TREE_CODE (type
) != METHOD_TYPE
)
9803 error ("template-id %qD used as a declarator",
9805 unqualified_id
= dname
;
9808 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9809 qualified with a class-name, turn it into a METHOD_TYPE, unless
9810 we know that the function is static. We take advantage of this
9811 opportunity to do other processing that pertains to entities
9812 explicitly declared to be class members. Note that if DECLARATOR
9813 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9814 would not have exited the loop above. */
9816 && declarator
->u
.id
.qualifying_scope
9817 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
9819 ctype
= declarator
->u
.id
.qualifying_scope
;
9820 ctype
= TYPE_MAIN_VARIANT (ctype
);
9821 template_count
= num_template_headers_for_class (ctype
);
9823 if (ctype
== current_class_type
)
9827 permerror (input_location
, "member functions are implicitly friends of their class");
9831 permerror (declarator
->id_loc
,
9832 "extra qualification %<%T::%> on member %qs",
9835 else if (/* If the qualifying type is already complete, then we
9836 can skip the following checks. */
9837 !COMPLETE_TYPE_P (ctype
)
9838 && (/* If the function is being defined, then
9839 qualifying type must certainly be complete. */
9841 /* A friend declaration of "T::f" is OK, even if
9842 "T" is a template parameter. But, if this
9843 function is not a friend, the qualifying type
9845 || (!friendp
&& !CLASS_TYPE_P (ctype
))
9846 /* For a declaration, the type need not be
9847 complete, if either it is dependent (since there
9848 is no meaningful definition of complete in that
9849 case) or the qualifying class is currently being
9851 || !(dependent_type_p (ctype
)
9852 || currently_open_class (ctype
)))
9853 /* Check that the qualifying type is complete. */
9854 && !complete_type_or_else (ctype
, NULL_TREE
))
9855 return error_mark_node
;
9856 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9858 if (current_class_type
9859 && (!friendp
|| funcdef_flag
))
9862 ? G_("cannot define member function %<%T::%s%> "
9864 : G_("cannot declare member function %<%T::%s%> "
9866 ctype
, name
, current_class_type
);
9867 return error_mark_node
;
9870 else if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
)
9871 && current_class_type
)
9873 error ("cannot declare member %<%T::%s%> within %qT",
9874 ctype
, name
, current_class_type
);
9875 return error_mark_node
;
9879 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
9880 ctype
= current_class_type
;
9882 /* Now TYPE has the actual type. */
9887 *attrlist
= chainon (returned_attrs
, *attrlist
);
9889 attrlist
= &returned_attrs
;
9893 && declarator
->kind
== cdk_id
9894 && declarator
->std_attributes
)
9895 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
9896 a declarator-id appertains to the entity that is declared. */
9897 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
9899 /* Handle parameter packs. */
9900 if (parameter_pack_p
)
9902 if (decl_context
== PARM
)
9903 /* Turn the type into a pack expansion.*/
9904 type
= make_pack_expansion (type
);
9906 error ("non-parameter %qs cannot be a parameter pack", name
);
9909 /* Did array size calculations overflow or does the array cover more
9910 than half of the address-space? */
9911 if (TREE_CODE (type
) == ARRAY_TYPE
9912 && COMPLETE_TYPE_P (type
)
9913 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
9914 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
9916 error ("size of array %qs is too large", name
);
9917 /* If we proceed with the array type as it is, we'll eventually
9918 crash in tree_low_cst(). */
9919 type
= error_mark_node
;
9922 if ((decl_context
== FIELD
|| decl_context
== PARM
)
9923 && !processing_template_decl
9924 && variably_modified_type_p (type
, NULL_TREE
))
9926 if (decl_context
== FIELD
)
9927 error ("data member may not have variably modified type %qT", type
);
9929 error ("parameter may not have variably modified type %qT", type
);
9930 type
= error_mark_node
;
9933 if (explicitp
== 1 || (explicitp
&& friendp
))
9935 /* [dcl.fct.spec] The explicit specifier shall only be used in
9936 declarations of constructors within a class definition. */
9937 error ("only declarations of constructors can be %<explicit%>");
9941 if (storage_class
== sc_mutable
)
9943 if (decl_context
!= FIELD
|| friendp
)
9945 error ("non-member %qs cannot be declared %<mutable%>", name
);
9946 storage_class
= sc_none
;
9948 else if (decl_context
== TYPENAME
9949 || decl_spec_seq_has_spec_p (declspecs
, ds_typedef
))
9951 error ("non-object member %qs cannot be declared %<mutable%>", name
);
9952 storage_class
= sc_none
;
9954 else if (TREE_CODE (type
) == FUNCTION_TYPE
9955 || TREE_CODE (type
) == METHOD_TYPE
)
9957 error ("function %qs cannot be declared %<mutable%>", name
);
9958 storage_class
= sc_none
;
9962 error ("static %qs cannot be declared %<mutable%>", name
);
9963 storage_class
= sc_none
;
9965 else if (type_quals
& TYPE_QUAL_CONST
)
9967 error ("const %qs cannot be declared %<mutable%>", name
);
9968 storage_class
= sc_none
;
9970 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9972 permerror (input_location
, "reference %qs cannot be declared "
9973 "%<mutable%>", name
);
9974 storage_class
= sc_none
;
9978 /* If this is declaring a typedef name, return a TYPE_DECL. */
9979 if (decl_spec_seq_has_spec_p (declspecs
, ds_typedef
) && decl_context
!= TYPENAME
)
9983 /* Note that the grammar rejects storage classes
9984 in typenames, fields or parameters. */
9985 if (current_lang_name
== lang_name_java
)
9986 TYPE_FOR_JAVA (type
) = 1;
9988 /* This declaration:
9990 typedef void f(int) const;
9992 declares a function type which is not a member of any
9993 particular class, but which is cv-qualified; for
9994 example "f S::*" declares a pointer to a const-qualified
9995 member function of S. We record the cv-qualification in the
9997 if (memfn_quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
9999 type
= apply_memfn_quals (type
, memfn_quals
);
10001 /* We have now dealt with these qualifiers. */
10002 memfn_quals
= TYPE_UNQUALIFIED
;
10005 if (type_uses_auto (type
))
10007 error ("typedef declared %<auto%>");
10008 type
= error_mark_node
;
10011 if (decl_context
== FIELD
)
10012 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10014 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10015 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10016 error_at (DECL_SOURCE_LOCATION (decl
),
10017 "typedef name may not be a nested-name-specifier");
10018 TREE_TYPE (decl
) = error_mark_node
;
10021 if (decl_context
!= FIELD
)
10023 if (!current_function_decl
)
10024 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10025 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10026 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10027 (current_function_decl
)))
10028 /* The TYPE_DECL is "abstract" because there will be
10029 clones of this constructor/destructor, and there will
10030 be copies of this TYPE_DECL generated in those
10032 DECL_ABSTRACT (decl
) = 1;
10034 else if (current_class_type
10035 && constructor_name_p (unqualified_id
, current_class_type
))
10036 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10037 "as enclosing class",
10040 /* If the user declares "typedef struct {...} foo" then the
10041 struct will have an anonymous name. Fill that name in now.
10042 Nothing can refer to it, so nothing needs know about the name
10044 if (type
!= error_mark_node
10046 && TYPE_NAME (type
)
10047 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10048 && TYPE_ANONYMOUS_P (type
)
10049 && declspecs
->type_definition_p
10050 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10054 /* Replace the anonymous name with the real name everywhere. */
10055 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10057 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10058 /* We do not rename the debug info representing the
10059 anonymous tagged type because the standard says in
10060 [dcl.typedef] that the naming applies only for
10061 linkage purposes. */
10062 /*debug_hooks->set_name (t, decl);*/
10063 TYPE_NAME (t
) = decl
;
10066 if (TYPE_LANG_SPECIFIC (type
))
10067 TYPE_WAS_ANONYMOUS (type
) = 1;
10069 /* If this is a typedef within a template class, the nested
10070 type is a (non-primary) template. The name for the
10071 template needs updating as well. */
10072 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10073 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10074 = TYPE_IDENTIFIER (type
);
10076 /* Adjust linkage now that we aren't anonymous anymore. */
10077 reset_type_linkage (type
);
10079 /* FIXME remangle member functions; member functions of a
10080 type with external linkage have external linkage. */
10084 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10085 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10087 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10088 memfn_quals
!= TYPE_UNQUALIFIED
,
10089 inlinep
, friendp
, raises
!= NULL_TREE
);
10091 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10092 /* Acknowledge that this was written:
10093 `using analias = atype;'. */
10094 TYPE_DECL_ALIAS_P (decl
) = 1;
10099 /* Detect the case of an array type of unspecified size
10100 which came, as such, direct from a typedef name.
10101 We must copy the type, so that the array's domain can be
10102 individually set by the object's initializer. */
10104 if (type
&& typedef_type
10105 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10106 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10107 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10109 /* Detect where we're using a typedef of function type to declare a
10110 function. PARMS will not be set, so we must create it now. */
10112 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10114 tree decls
= NULL_TREE
;
10117 for (args
= TYPE_ARG_TYPES (type
);
10118 args
&& args
!= void_list_node
;
10119 args
= TREE_CHAIN (args
))
10121 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10123 DECL_CHAIN (decl
) = decls
;
10127 parms
= nreverse (decls
);
10129 if (decl_context
!= TYPENAME
)
10131 /* A cv-qualifier-seq shall only be part of the function type
10132 for a non-static member function. [8.3.5/4 dcl.fct] */
10133 if (type_memfn_quals (type
) != TYPE_UNQUALIFIED
10134 && (current_class_type
== NULL_TREE
|| staticp
) )
10137 ? G_("qualified function types cannot be used to "
10138 "declare static member functions")
10139 : G_("qualified function types cannot be used to "
10140 "declare free functions"));
10141 type
= TYPE_MAIN_VARIANT (type
);
10144 /* The qualifiers on the function type become the qualifiers on
10145 the non-static member function. */
10146 memfn_quals
|= type_memfn_quals (type
);
10147 type_quals
= TYPE_UNQUALIFIED
;
10151 /* If this is a type name (such as, in a cast or sizeof),
10152 compute the type and return it now. */
10154 if (decl_context
== TYPENAME
)
10156 /* Note that the grammar rejects storage classes
10157 in typenames, fields or parameters. */
10158 if (type_quals
!= TYPE_UNQUALIFIED
)
10159 type_quals
= TYPE_UNQUALIFIED
;
10161 /* Special case: "friend class foo" looks like a TYPENAME context. */
10164 if (type_quals
!= TYPE_UNQUALIFIED
)
10166 error ("type qualifiers specified for friend class declaration");
10167 type_quals
= TYPE_UNQUALIFIED
;
10171 error ("%<inline%> specified for friend class declaration");
10177 /* Don't allow friend declaration without a class-key. */
10178 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10179 permerror (input_location
, "template parameters cannot be friends");
10180 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10181 permerror (input_location
, "friend declaration requires class-key, "
10182 "i.e. %<friend class %T::%D%>",
10183 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10185 permerror (input_location
, "friend declaration requires class-key, "
10186 "i.e. %<friend %#T%>",
10190 /* Only try to do this stuff if we didn't already give up. */
10191 if (type
!= integer_type_node
)
10193 /* A friendly class? */
10194 if (current_class_type
)
10195 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10196 /*complain=*/true);
10198 error ("trying to make class %qT a friend of global scope",
10201 type
= void_type_node
;
10204 else if (memfn_quals
)
10206 if (ctype
== NULL_TREE
10207 && TREE_CODE (type
) == METHOD_TYPE
)
10208 ctype
= TYPE_METHOD_BASETYPE (type
);
10211 type
= build_memfn_type (type
, ctype
, memfn_quals
);
10212 /* Core issue #547: need to allow this in template type args. */
10213 else if (template_type_arg
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10214 type
= apply_memfn_quals (type
, memfn_quals
);
10216 error ("invalid qualifiers on non-member function type");
10221 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10222 && decl_context
!= CATCHPARM
10223 && TREE_CODE (type
) != UNION_TYPE
10226 error ("abstract declarator %qT used as declaration", type
);
10227 return error_mark_node
;
10230 /* Only functions may be declared using an operator-function-id. */
10232 && IDENTIFIER_OPNAME_P (unqualified_id
)
10233 && TREE_CODE (type
) != FUNCTION_TYPE
10234 && TREE_CODE (type
) != METHOD_TYPE
)
10236 error ("declaration of %qD as non-function", unqualified_id
);
10237 return error_mark_node
;
10240 /* We don't check parameter types here because we can emit a better
10241 error message later. */
10242 if (decl_context
!= PARM
)
10244 type
= check_var_type (unqualified_id
, type
);
10245 if (type
== error_mark_node
)
10246 return error_mark_node
;
10249 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10250 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10252 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10254 if (ctype
|| in_namespace
)
10255 error ("cannot use %<::%> in parameter declaration");
10257 if (type_uses_auto (type
))
10259 error ("parameter declared %<auto%>");
10260 type
= error_mark_node
;
10263 /* A parameter declared as an array of T is really a pointer to T.
10264 One declared as a function is really a pointer to a function.
10265 One declared as a member is really a pointer to member. */
10267 if (TREE_CODE (type
) == ARRAY_TYPE
)
10269 /* Transfer const-ness of array into that of type pointed to. */
10270 type
= build_pointer_type (TREE_TYPE (type
));
10271 type_quals
= TYPE_UNQUALIFIED
;
10273 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10274 type
= build_pointer_type (type
);
10277 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10278 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10280 cp_cv_quals real_quals
= memfn_quals
;
10281 if (constexpr_p
&& sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10282 real_quals
|= TYPE_QUAL_CONST
;
10283 type
= build_memfn_type (type
, ctype
, real_quals
);
10289 if (decl_context
== PARM
)
10291 decl
= cp_build_parm_decl (unqualified_id
, type
);
10293 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10294 memfn_quals
!= TYPE_UNQUALIFIED
,
10295 inlinep
, friendp
, raises
!= NULL_TREE
);
10297 else if (decl_context
== FIELD
)
10299 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10300 && type_uses_auto (type
))
10302 error ("non-static data member declared %<auto%>");
10303 type
= error_mark_node
;
10306 /* The C99 flexible array extension. */
10307 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10308 && TYPE_DOMAIN (type
) == NULL_TREE
)
10310 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10311 tf_warning_or_error
);
10312 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10315 if (type
== error_mark_node
)
10317 /* Happens when declaring arrays of sizes which
10318 are error_mark_node, for example. */
10321 else if (in_namespace
&& !friendp
)
10323 /* Something like struct S { int N::j; }; */
10324 error ("invalid use of %<::%>");
10325 return error_mark_node
;
10327 else if (TREE_CODE (type
) == FUNCTION_TYPE
10328 || TREE_CODE (type
) == METHOD_TYPE
)
10331 tree function_context
;
10335 /* This should never happen in pure C++ (the check
10336 could be an assert). It could happen in
10337 Objective-C++ if someone writes invalid code that
10338 uses a function declaration for an instance
10339 variable or property (instance variables and
10340 properties are parsed as FIELD_DECLs, but they are
10341 part of an Objective-C class, not a C++ class).
10342 That code is invalid and is caught by this
10346 error ("declaration of function %qD in invalid context",
10348 return error_mark_node
;
10351 /* ``A union may [ ... ] not [ have ] virtual functions.''
10353 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10355 error ("function %qD declared virtual inside a union",
10357 return error_mark_node
;
10360 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10364 error ("%qD cannot be declared virtual, since it "
10365 "is always static",
10372 /* Check that the name used for a destructor makes sense. */
10373 if (sfk
== sfk_destructor
)
10375 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10379 gcc_assert (friendp
);
10380 error ("expected qualified name in friend declaration "
10381 "for destructor %qD", uqname
);
10382 return error_mark_node
;
10385 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10387 error ("declaration of %qD as member of %qT",
10389 return error_mark_node
;
10393 error ("a destructor cannot be %<constexpr%>");
10394 return error_mark_node
;
10397 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10399 error ("expected qualified name in friend declaration "
10400 "for constructor %qD",
10401 id_declarator
->u
.id
.unqualified_name
);
10402 return error_mark_node
;
10405 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10406 function_context
= (ctype
!= NULL_TREE
) ?
10407 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10408 publicp
= (! friendp
|| ! staticp
)
10409 && function_context
== NULL_TREE
;
10410 decl
= grokfndecl (ctype
, type
,
10411 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10412 ? unqualified_id
: dname
,
10415 virtualp
, flags
, memfn_quals
, raises
,
10416 friendp
? -1 : 0, friendp
, publicp
,
10417 inlinep
| (2 * constexpr_p
),
10419 funcdef_flag
, template_count
, in_namespace
,
10420 attrlist
, declarator
->id_loc
);
10421 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10422 if (decl
== NULL_TREE
)
10423 return error_mark_node
;
10425 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10426 /* The decl and setting of decl_attr is also turned off. */
10427 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10430 /* [class.conv.ctor]
10432 A constructor declared without the function-specifier
10433 explicit that can be called with a single parameter
10434 specifies a conversion from the type of its first
10435 parameter to the type of its class. Such a constructor
10436 is called a converting constructor. */
10437 if (explicitp
== 2)
10438 DECL_NONCONVERTING_P (decl
) = 1;
10440 else if (!staticp
&& !dependent_type_p (type
)
10441 && !COMPLETE_TYPE_P (complete_type (type
))
10442 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10444 if (unqualified_id
)
10445 error ("field %qD has incomplete type", unqualified_id
);
10447 error ("name %qT has incomplete type", type
);
10449 /* If we're instantiating a template, tell them which
10450 instantiation made the field's type be incomplete. */
10451 if (current_class_type
10452 && TYPE_NAME (current_class_type
)
10453 && IDENTIFIER_TEMPLATE (current_class_name
)
10455 && declspecs
->type
== type
)
10456 error (" in instantiation of template %qT",
10457 current_class_type
);
10459 return error_mark_node
;
10465 error ("%qE is neither function nor member function; "
10466 "cannot be declared friend", unqualified_id
);
10474 /* Friends are treated specially. */
10475 if (ctype
== current_class_type
)
10476 ; /* We already issued a permerror. */
10477 else if (decl
&& DECL_NAME (decl
))
10479 if (template_class_depth (current_class_type
) == 0)
10481 decl
= check_explicit_specialization
10482 (unqualified_id
, decl
, template_count
,
10483 2 * funcdef_flag
+ 4);
10484 if (decl
== error_mark_node
)
10485 return error_mark_node
;
10488 decl
= do_friend (ctype
, unqualified_id
, decl
,
10494 return error_mark_node
;
10497 /* Structure field. It may not be a function, except for C++. */
10499 if (decl
== NULL_TREE
)
10503 /* C++ allows static class members. All other work
10504 for this is done by grokfield. */
10505 decl
= build_lang_decl_loc (declarator
->id_loc
,
10506 VAR_DECL
, unqualified_id
, type
);
10507 set_linkage_for_static_data_member (decl
);
10508 /* Even if there is an in-class initialization, DECL
10509 is considered undefined until an out-of-class
10510 definition is provided. */
10511 DECL_EXTERNAL (decl
) = 1;
10515 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
10516 if (declspecs
->gnu_thread_keyword_p
)
10517 DECL_GNU_TLS_P (decl
) = true;
10520 if (constexpr_p
&& !initialized
)
10522 error ("constexpr static data member %qD must have an "
10523 "initializer", decl
);
10524 constexpr_p
= false;
10531 error ("non-static data member %qE declared %<constexpr%>",
10533 constexpr_p
= false;
10535 decl
= build_decl (input_location
,
10536 FIELD_DECL
, unqualified_id
, type
);
10537 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10538 if (bitfield
&& !unqualified_id
)
10539 TREE_NO_WARNING (decl
) = 1;
10541 if (storage_class
== sc_mutable
)
10543 DECL_MUTABLE_P (decl
) = 1;
10544 storage_class
= sc_none
;
10549 /* An attempt is being made to initialize a non-static
10550 member. This is new in C++11. */
10551 maybe_warn_cpp0x (CPP0X_NSDMI
);
10553 /* If this has been parsed with static storage class, but
10554 errors forced staticp to be cleared, ensure NSDMI is
10556 if (declspecs
->storage_class
== sc_static
)
10557 DECL_INITIAL (decl
) = error_mark_node
;
10561 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10562 memfn_quals
!= TYPE_UNQUALIFIED
,
10563 inlinep
, friendp
, raises
!= NULL_TREE
);
10566 else if (TREE_CODE (type
) == FUNCTION_TYPE
10567 || TREE_CODE (type
) == METHOD_TYPE
)
10569 tree original_name
;
10572 if (!unqualified_id
)
10573 return error_mark_node
;
10575 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10576 original_name
= dname
;
10578 original_name
= unqualified_id
;
10580 if (storage_class
== sc_auto
)
10581 error ("storage class %<auto%> invalid for function %qs", name
);
10582 else if (storage_class
== sc_register
)
10583 error ("storage class %<register%> invalid for function %qs", name
);
10586 if (declspecs
->gnu_thread_keyword_p
)
10587 error ("storage class %<__thread%> invalid for function %qs",
10590 error ("storage class %<thread_local%> invalid for function %qs",
10594 if (virt_specifiers
)
10595 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10596 /* Function declaration not at top level.
10597 Storage classes other than `extern' are not allowed
10598 and `extern' makes no difference. */
10599 if (! toplevel_bindings_p ()
10600 && (storage_class
== sc_static
10601 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10604 if (storage_class
== sc_static
)
10605 pedwarn (input_location
, OPT_Wpedantic
,
10606 "%<static%> specified invalid for function %qs "
10607 "declared out of global scope", name
);
10609 pedwarn (input_location
, OPT_Wpedantic
,
10610 "%<inline%> specifier invalid for function %qs "
10611 "declared out of global scope", name
);
10614 if (ctype
== NULL_TREE
)
10618 error ("virtual non-class function %qs", name
);
10621 else if (sfk
== sfk_constructor
10622 || sfk
== sfk_destructor
)
10624 error (funcdef_flag
10625 ? G_("%qs defined in a non-class scope")
10626 : G_("%qs declared in a non-class scope"), name
);
10631 /* Record presence of `static'. */
10632 publicp
= (ctype
!= NULL_TREE
10633 || storage_class
== sc_extern
10634 || storage_class
!= sc_static
);
10636 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10637 virtualp
, flags
, memfn_quals
, raises
,
10639 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10641 template_count
, in_namespace
, attrlist
,
10642 declarator
->id_loc
);
10643 if (decl
== NULL_TREE
)
10644 return error_mark_node
;
10648 int invalid_static
= 0;
10650 /* Don't allow a static member function in a class, and forbid
10651 declaring main to be static. */
10652 if (TREE_CODE (type
) == METHOD_TYPE
)
10654 permerror (input_location
, "cannot declare member function %qD to have "
10655 "static linkage", decl
);
10656 invalid_static
= 1;
10658 else if (current_function_decl
)
10660 /* FIXME need arm citation */
10661 error ("cannot declare static function inside another function");
10662 invalid_static
= 1;
10665 if (invalid_static
)
10668 storage_class
= sc_none
;
10674 /* It's a variable. */
10676 /* An uninitialized decl with `extern' is a reference. */
10677 decl
= grokvardecl (type
, unqualified_id
,
10680 (type_quals
& TYPE_QUAL_CONST
) != 0,
10681 ctype
? ctype
: in_namespace
);
10682 bad_specifiers (decl
, BSP_VAR
, virtualp
,
10683 memfn_quals
!= TYPE_UNQUALIFIED
,
10684 inlinep
, friendp
, raises
!= NULL_TREE
);
10688 DECL_CONTEXT (decl
) = ctype
;
10691 permerror (input_location
, "%<static%> may not be used when defining "
10692 "(as opposed to declaring) a static data member");
10694 storage_class
= sc_none
;
10696 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
10698 error ("static member %qD declared %<register%>", decl
);
10699 storage_class
= sc_none
;
10701 if (storage_class
== sc_extern
&& pedantic
)
10703 pedwarn (input_location
, OPT_Wpedantic
,
10704 "cannot explicitly declare member %q#D to have "
10705 "extern linkage", decl
);
10706 storage_class
= sc_none
;
10709 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
10711 error ("declaration of constexpr variable %qD is not a definition",
10713 constexpr_p
= false;
10717 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
10719 if (toplevel_bindings_p ())
10721 /* It's common practice (and completely valid) to have a const
10722 be initialized and declared extern. */
10723 if (!(type_quals
& TYPE_QUAL_CONST
))
10724 warning (0, "%qs initialized and declared %<extern%>", name
);
10728 error ("%qs has both %<extern%> and initializer", name
);
10729 return error_mark_node
;
10733 /* Record `register' declaration for warnings on &
10734 and in case doing stupid register allocation. */
10736 if (storage_class
== sc_register
)
10737 DECL_REGISTER (decl
) = 1;
10738 else if (storage_class
== sc_extern
)
10739 DECL_THIS_EXTERN (decl
) = 1;
10740 else if (storage_class
== sc_static
)
10741 DECL_THIS_STATIC (decl
) = 1;
10743 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10744 if (constexpr_p
&& TREE_CODE (decl
) == VAR_DECL
)
10745 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
10747 /* Record constancy and volatility on the DECL itself . There's
10748 no need to do this when processing a template; we'll do this
10749 for the instantiated declaration based on the type of DECL. */
10750 if (!processing_template_decl
)
10751 cp_apply_type_quals_to_decl (type_quals
, decl
);
10757 /* Subroutine of start_function. Ensure that each of the parameter
10758 types (as listed in PARMS) is complete, as is required for a
10759 function definition. */
10762 require_complete_types_for_parms (tree parms
)
10764 for (; parms
; parms
= DECL_CHAIN (parms
))
10766 if (dependent_type_p (TREE_TYPE (parms
)))
10768 if (!VOID_TYPE_P (TREE_TYPE (parms
))
10769 && complete_type_or_else (TREE_TYPE (parms
), parms
))
10771 relayout_decl (parms
);
10772 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
10775 /* grokparms or complete_type_or_else will have already issued
10777 TREE_TYPE (parms
) = error_mark_node
;
10781 /* Returns nonzero if T is a local variable. */
10784 local_variable_p (const_tree t
)
10786 if ((TREE_CODE (t
) == VAR_DECL
10787 /* A VAR_DECL with a context that is a _TYPE is a static data
10789 && !TYPE_P (CP_DECL_CONTEXT (t
))
10790 /* Any other non-local variable must be at namespace scope. */
10791 && !DECL_NAMESPACE_SCOPE_P (t
))
10792 || (TREE_CODE (t
) == PARM_DECL
))
10798 /* Like local_variable_p, but suitable for use as a tree-walking
10802 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
10805 /* Check DECL_NAME to avoid including temporaries. We don't check
10806 DECL_ARTIFICIAL because we do want to complain about 'this'. */
10807 if (local_variable_p (*tp
) && DECL_NAME (*tp
))
10809 else if (TYPE_P (*tp
))
10810 *walk_subtrees
= 0;
10815 /* Check that ARG, which is a default-argument expression for a
10816 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10817 something goes wrong. DECL may also be a _TYPE node, rather than a
10818 DECL, if there is no DECL available. */
10821 check_default_argument (tree decl
, tree arg
)
10826 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10827 /* We get a DEFAULT_ARG when looking at an in-class declaration
10828 with a default argument. Ignore the argument for now; we'll
10829 deal with it after the class is complete. */
10838 decl_type
= TREE_TYPE (decl
);
10840 if (arg
== error_mark_node
10841 || decl
== error_mark_node
10842 || TREE_TYPE (arg
) == error_mark_node
10843 || decl_type
== error_mark_node
)
10844 /* Something already went wrong. There's no need to check
10846 return error_mark_node
;
10848 /* [dcl.fct.default]
10850 A default argument expression is implicitly converted to the
10852 ++cp_unevaluated_operand
;
10853 perform_implicit_conversion_flags (decl_type
, arg
, tf_warning_or_error
,
10855 --cp_unevaluated_operand
;
10857 if (warn_zero_as_null_pointer_constant
10858 && c_inhibit_evaluation_warnings
== 0
10859 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
10860 && null_ptr_cst_p (arg
)
10861 && !NULLPTR_TYPE_P (TREE_TYPE (arg
)))
10863 warning (OPT_Wzero_as_null_pointer_constant
,
10864 "zero as null pointer constant");
10865 return nullptr_node
;
10868 /* [dcl.fct.default]
10870 Local variables shall not be used in default argument
10873 The keyword `this' shall not be used in a default argument of a
10874 member function. */
10875 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
10878 if (DECL_NAME (var
) == this_identifier
)
10879 permerror (input_location
, "default argument %qE uses %qD", arg
, var
);
10881 error ("default argument %qE uses local variable %qD", arg
, var
);
10882 return error_mark_node
;
10889 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
10892 type_is_deprecated (tree type
)
10894 enum tree_code code
;
10895 if (TREE_DEPRECATED (type
))
10897 if (TYPE_NAME (type
)
10898 && TREE_DEPRECATED (TYPE_NAME (type
)))
10901 /* Do warn about using typedefs to a deprecated class. */
10902 if (TAGGED_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
10903 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
10905 code
= TREE_CODE (type
);
10907 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
10908 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
10909 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
10910 return type_is_deprecated (TREE_TYPE (type
));
10912 if (TYPE_PTRMEMFUNC_P (type
))
10913 return type_is_deprecated
10914 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
10919 /* Decode the list of parameter types for a function type.
10920 Given the list of things declared inside the parens,
10921 return a list of types.
10923 If this parameter does not end with an ellipsis, we append
10926 *PARMS is set to the chain of PARM_DECLs created. */
10929 grokparms (tree parmlist
, tree
*parms
)
10931 tree result
= NULL_TREE
;
10932 tree decls
= NULL_TREE
;
10936 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
10938 tree type
= NULL_TREE
;
10939 tree init
= TREE_PURPOSE (parm
);
10940 tree decl
= TREE_VALUE (parm
);
10941 const char *errmsg
;
10943 if (parm
== void_list_node
)
10946 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
10949 type
= TREE_TYPE (decl
);
10950 if (VOID_TYPE_P (type
))
10952 if (same_type_p (type
, void_type_node
)
10953 && DECL_SELF_REFERENCE_P (type
)
10954 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
10955 /* this is a parmlist of `(void)', which is ok. */
10957 cxx_incomplete_type_error (decl
, type
);
10958 /* It's not a good idea to actually create parameters of
10959 type `void'; other parts of the compiler assume that a
10960 void type terminates the parameter list. */
10961 type
= error_mark_node
;
10962 TREE_TYPE (decl
) = error_mark_node
;
10965 if (type
!= error_mark_node
10966 && TYPE_FOR_JAVA (type
)
10967 && MAYBE_CLASS_TYPE_P (type
))
10969 error ("parameter %qD has Java class type", decl
);
10970 type
= error_mark_node
;
10971 TREE_TYPE (decl
) = error_mark_node
;
10975 if (type
!= error_mark_node
10976 && (errmsg
= targetm
.invalid_parameter_type (type
)))
10979 type
= error_mark_node
;
10980 TREE_TYPE (decl
) = error_mark_node
;
10983 if (type
!= error_mark_node
)
10985 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
10987 tree deptype
= type_is_deprecated (type
);
10989 warn_deprecated_use (deptype
, NULL_TREE
);
10992 /* Top-level qualifiers on the parameters are
10993 ignored for function types. */
10994 type
= cp_build_qualified_type (type
, 0);
10995 if (TREE_CODE (type
) == METHOD_TYPE
)
10997 error ("parameter %qD invalidly declared method type", decl
);
10998 type
= build_pointer_type (type
);
10999 TREE_TYPE (decl
) = type
;
11001 else if (abstract_virtuals_error (decl
, type
))
11002 any_error
= 1; /* Seems like a good idea. */
11003 else if (POINTER_TYPE_P (type
))
11005 /* [dcl.fct]/6, parameter types cannot contain pointers
11006 (references) to arrays of unknown bound. */
11007 tree t
= TREE_TYPE (type
);
11008 int ptr
= TYPE_PTR_P (type
);
11012 if (TYPE_PTR_P (t
))
11014 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11016 else if (!TYPE_DOMAIN (t
))
11020 if (TREE_CODE (t
) == ARRAY_TYPE
)
11022 ? G_("parameter %qD includes pointer to array of "
11023 "unknown bound %qT")
11024 : G_("parameter %qD includes reference to array of "
11025 "unknown bound %qT"),
11031 else if (init
&& !processing_template_decl
)
11032 init
= check_default_argument (decl
, init
);
11035 DECL_CHAIN (decl
) = decls
;
11037 result
= tree_cons (init
, type
, result
);
11039 decls
= nreverse (decls
);
11040 result
= nreverse (result
);
11042 result
= chainon (result
, void_list_node
);
11049 /* D is a constructor or overloaded `operator='.
11051 Let T be the class in which D is declared. Then, this function
11054 -1 if D's is an ill-formed constructor or copy assignment operator
11055 whose first parameter is of type `T'.
11056 0 if D is not a copy constructor or copy assignment
11058 1 if D is a copy constructor or copy assignment operator whose
11059 first parameter is a reference to non-const qualified T.
11060 2 if D is a copy constructor or copy assignment operator whose
11061 first parameter is a reference to const qualified T.
11063 This function can be used as a predicate. Positive values indicate
11064 a copy constructor and nonzero values indicate a copy assignment
11068 copy_fn_p (const_tree d
)
11074 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11076 if (TREE_CODE (d
) == TEMPLATE_DECL
11077 || (DECL_TEMPLATE_INFO (d
)
11078 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11079 /* Instantiations of template member functions are never copy
11080 functions. Note that member functions of templated classes are
11081 represented as template functions internally, and we must
11082 accept those as copy functions. */
11085 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11089 arg_type
= TREE_VALUE (args
);
11090 if (arg_type
== error_mark_node
)
11093 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11095 /* Pass by value copy assignment operator. */
11098 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11099 && !TYPE_REF_IS_RVALUE (arg_type
)
11100 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11102 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11108 args
= TREE_CHAIN (args
);
11110 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11111 /* There are more non-optional args. */
11117 /* D is a constructor or overloaded `operator='.
11119 Let T be the class in which D is declared. Then, this function
11120 returns true when D is a move constructor or move assignment
11121 operator, false otherwise. */
11124 move_fn_p (const_tree d
)
11126 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11128 if (cxx_dialect
== cxx98
)
11129 /* There are no move constructors if we are in C++98 mode. */
11132 if (TREE_CODE (d
) == TEMPLATE_DECL
11133 || (DECL_TEMPLATE_INFO (d
)
11134 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11135 /* Instantiations of template member functions are never move
11136 functions. Note that member functions of templated classes are
11137 represented as template functions internally, and we must
11138 accept those as move functions. */
11141 return move_signature_fn_p (d
);
11144 /* D is a constructor or overloaded `operator='.
11146 Then, this function returns true when D has the same signature as a move
11147 constructor or move assignment operator (because either it is such a
11148 ctor/op= or it is a template specialization with the same signature),
11149 false otherwise. */
11152 move_signature_fn_p (const_tree d
)
11156 bool result
= false;
11158 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11162 arg_type
= TREE_VALUE (args
);
11163 if (arg_type
== error_mark_node
)
11166 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11167 && TYPE_REF_IS_RVALUE (arg_type
)
11168 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11172 args
= TREE_CHAIN (args
);
11174 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11175 /* There are more non-optional args. */
11181 /* Remember any special properties of member function DECL. */
11184 grok_special_member_properties (tree decl
)
11188 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11191 class_type
= DECL_CONTEXT (decl
);
11192 if (DECL_CONSTRUCTOR_P (decl
))
11194 int ctor
= copy_fn_p (decl
);
11196 if (!DECL_ARTIFICIAL (decl
))
11197 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11203 A non-template constructor for class X is a copy
11204 constructor if its first parameter is of type X&, const
11205 X&, volatile X& or const volatile X&, and either there
11206 are no other parameters or else all other parameters have
11207 default arguments. */
11208 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11209 if (user_provided_p (decl
))
11210 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11212 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11214 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11216 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11217 if (user_provided_p (decl
))
11218 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
11220 else if (move_fn_p (decl
) && user_provided_p (decl
))
11221 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11222 else if (is_list_ctor (decl
))
11223 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11225 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11226 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11227 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11229 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11233 A non-template assignment operator for class X is a copy
11234 assignment operator if its parameter is of type X, X&, const
11235 X&, volatile X& or const volatile X&. */
11237 int assop
= copy_fn_p (decl
);
11241 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11242 if (user_provided_p (decl
))
11243 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11245 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11247 else if (move_fn_p (decl
) && user_provided_p (decl
))
11248 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11250 /* Destructors are handled in check_methods. */
11253 /* Check a constructor DECL has the correct form. Complains
11254 if the class has a constructor of the form X(X). */
11257 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11259 int ctor_parm
= copy_fn_p (decl
);
11265 A declaration of a constructor for a class X is ill-formed if
11266 its first parameter is of type (optionally cv-qualified) X
11267 and either there are no other parameters or else all other
11268 parameters have default arguments.
11270 We *don't* complain about member template instantiations that
11271 have this form, though; they can occur as we try to decide
11272 what constructor to use during overload resolution. Since
11273 overload resolution will never prefer such a constructor to
11274 the non-template copy constructor (which is either explicitly
11275 or implicitly defined), there's no need to worry about their
11276 existence. Theoretically, they should never even be
11277 instantiated, but that's hard to forestall. */
11278 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11286 /* An operator with this code is unary, but can also be binary. */
11289 ambi_op_p (enum tree_code code
)
11291 return (code
== INDIRECT_REF
11292 || code
== ADDR_EXPR
11293 || code
== UNARY_PLUS_EXPR
11294 || code
== NEGATE_EXPR
11295 || code
== PREINCREMENT_EXPR
11296 || code
== PREDECREMENT_EXPR
);
11299 /* An operator with this name can only be unary. */
11302 unary_op_p (enum tree_code code
)
11304 return (code
== TRUTH_NOT_EXPR
11305 || code
== BIT_NOT_EXPR
11306 || code
== COMPONENT_REF
11307 || code
== TYPE_EXPR
);
11310 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11311 errors are issued for invalid declarations. */
11314 grok_op_properties (tree decl
, bool complain
)
11316 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11318 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11319 tree name
= DECL_NAME (decl
);
11320 enum tree_code operator_code
;
11325 /* Count the number of arguments and check for ellipsis. */
11326 for (argtype
= argtypes
, arity
= 0;
11327 argtype
&& argtype
!= void_list_node
;
11328 argtype
= TREE_CHAIN (argtype
))
11330 ellipsis_p
= !argtype
;
11332 class_type
= DECL_CONTEXT (decl
);
11333 if (class_type
&& !CLASS_TYPE_P (class_type
))
11334 class_type
= NULL_TREE
;
11336 if (DECL_CONV_FN_P (decl
))
11337 operator_code
= TYPE_EXPR
;
11341 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11342 if (ansi_opname (CODE) == name) \
11344 operator_code = (CODE); \
11347 else if (ansi_assopname (CODE) == name) \
11349 operator_code = (CODE); \
11350 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11354 #include "operators.def"
11355 #undef DEF_OPERATOR
11357 gcc_unreachable ();
11360 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11361 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11364 switch (operator_code
)
11367 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11371 TYPE_GETS_DELETE (class_type
) |= 1;
11375 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11378 case VEC_DELETE_EXPR
:
11379 TYPE_GETS_DELETE (class_type
) |= 2;
11386 /* [basic.std.dynamic.allocation]/1:
11388 A program is ill-formed if an allocation function is declared
11389 in a namespace scope other than global scope or declared static
11392 The same also holds true for deallocation functions. */
11393 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11394 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11396 if (DECL_NAMESPACE_SCOPE_P (decl
))
11398 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11400 error ("%qD may not be declared within a namespace", decl
);
11403 else if (!TREE_PUBLIC (decl
))
11405 error ("%qD may not be declared as static", decl
);
11411 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11413 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11414 DECL_IS_OPERATOR_NEW (decl
) = 1;
11416 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11417 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11420 /* An operator function must either be a non-static member function
11421 or have at least one parameter of a class, a reference to a class,
11422 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11423 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11425 if (operator_code
== TYPE_EXPR
11426 || operator_code
== CALL_EXPR
11427 || operator_code
== COMPONENT_REF
11428 || operator_code
== ARRAY_REF
11429 || operator_code
== NOP_EXPR
)
11431 error ("%qD must be a nonstatic member function", decl
);
11438 if (DECL_STATIC_FUNCTION_P (decl
))
11440 error ("%qD must be either a non-static member "
11441 "function or a non-member function", decl
);
11445 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11447 tree arg
= non_reference (TREE_VALUE (p
));
11448 if (arg
== error_mark_node
)
11451 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11452 because these checks are performed even on
11453 template functions. */
11454 if (MAYBE_CLASS_TYPE_P (arg
)
11455 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11459 if (!p
|| p
== void_list_node
)
11462 error ("%qD must have an argument of class or "
11463 "enumerated type", decl
);
11469 /* There are no restrictions on the arguments to an overloaded
11471 if (operator_code
== CALL_EXPR
)
11474 /* Warn about conversion operators that will never be used. */
11475 if (IDENTIFIER_TYPENAME_P (name
)
11476 && ! DECL_TEMPLATE_INFO (decl
)
11478 /* Warn only declaring the function; there is no need to
11479 warn again about out-of-class definitions. */
11480 && class_type
== current_class_type
)
11482 tree t
= TREE_TYPE (name
);
11483 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11486 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11488 if (TREE_CODE (t
) == VOID_TYPE
)
11489 warning (OPT_Wconversion
,
11491 ? G_("conversion to a reference to void "
11492 "will never use a type conversion operator")
11493 : G_("conversion to void "
11494 "will never use a type conversion operator"));
11495 else if (class_type
)
11497 if (t
== class_type
)
11498 warning (OPT_Wconversion
,
11500 ? G_("conversion to a reference to the same type "
11501 "will never use a type conversion operator")
11502 : G_("conversion to the same type "
11503 "will never use a type conversion operator"));
11504 /* Don't force t to be complete here. */
11505 else if (MAYBE_CLASS_TYPE_P (t
)
11506 && COMPLETE_TYPE_P (t
)
11507 && DERIVED_FROM_P (t
, class_type
))
11508 warning (OPT_Wconversion
,
11510 ? G_("conversion to a reference to a base class "
11511 "will never use a type conversion operator")
11512 : G_("conversion to a base class "
11513 "will never use a type conversion operator"));
11518 if (operator_code
== COND_EXPR
)
11521 error ("ISO C++ prohibits overloading operator ?:");
11524 else if (ellipsis_p
)
11526 error ("%qD must not have variable number of arguments", decl
);
11529 else if (ambi_op_p (operator_code
))
11532 /* We pick the one-argument operator codes by default, so
11533 we don't have to change anything. */
11535 else if (arity
== 2)
11537 /* If we thought this was a unary operator, we now know
11538 it to be a binary operator. */
11539 switch (operator_code
)
11542 operator_code
= MULT_EXPR
;
11546 operator_code
= BIT_AND_EXPR
;
11549 case UNARY_PLUS_EXPR
:
11550 operator_code
= PLUS_EXPR
;
11554 operator_code
= MINUS_EXPR
;
11557 case PREINCREMENT_EXPR
:
11558 operator_code
= POSTINCREMENT_EXPR
;
11561 case PREDECREMENT_EXPR
:
11562 operator_code
= POSTDECREMENT_EXPR
;
11566 gcc_unreachable ();
11569 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11571 if ((operator_code
== POSTINCREMENT_EXPR
11572 || operator_code
== POSTDECREMENT_EXPR
)
11573 && ! processing_template_decl
11574 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11577 error ("postfix %qD must take %<int%> as its argument",
11580 error ("postfix %qD must take %<int%> as its second "
11588 error ("%qD must take either zero or one argument", decl
);
11590 error ("%qD must take either one or two arguments", decl
);
11594 /* More Effective C++ rule 6. */
11596 && (operator_code
== POSTINCREMENT_EXPR
11597 || operator_code
== POSTDECREMENT_EXPR
11598 || operator_code
== PREINCREMENT_EXPR
11599 || operator_code
== PREDECREMENT_EXPR
))
11601 tree arg
= TREE_VALUE (argtypes
);
11602 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11603 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11604 arg
= TREE_TYPE (arg
);
11605 arg
= TYPE_MAIN_VARIANT (arg
);
11606 if (operator_code
== PREINCREMENT_EXPR
11607 || operator_code
== PREDECREMENT_EXPR
)
11609 if (TREE_CODE (ret
) != REFERENCE_TYPE
11610 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11612 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11613 build_reference_type (arg
));
11617 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11618 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11622 else if (unary_op_p (operator_code
))
11627 error ("%qD must take %<void%>", decl
);
11629 error ("%qD must take exactly one argument", decl
);
11633 else /* if (binary_op_p (operator_code)) */
11638 error ("%qD must take exactly one argument", decl
);
11640 error ("%qD must take exactly two arguments", decl
);
11644 /* More Effective C++ rule 7. */
11646 && (operator_code
== TRUTH_ANDIF_EXPR
11647 || operator_code
== TRUTH_ORIF_EXPR
11648 || operator_code
== COMPOUND_EXPR
))
11649 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11653 /* Effective C++ rule 23. */
11656 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11657 && (operator_code
== PLUS_EXPR
11658 || operator_code
== MINUS_EXPR
11659 || operator_code
== TRUNC_DIV_EXPR
11660 || operator_code
== MULT_EXPR
11661 || operator_code
== TRUNC_MOD_EXPR
)
11662 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11663 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11665 /* [over.oper]/8 */
11666 for (; argtypes
&& argtypes
!= void_list_node
;
11667 argtypes
= TREE_CHAIN (argtypes
))
11668 if (TREE_PURPOSE (argtypes
))
11670 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11671 if (operator_code
== POSTINCREMENT_EXPR
11672 || operator_code
== POSTDECREMENT_EXPR
)
11674 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
11679 error ("%qD cannot have default arguments", decl
);
11687 /* Return a string giving the keyword associate with CODE. */
11689 static const char *
11690 tag_name (enum tag_types code
)
11702 case typename_type
:
11705 gcc_unreachable ();
11709 /* Name lookup in an elaborated-type-specifier (after the keyword
11710 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11711 elaborated-type-specifier is invalid, issue a diagnostic and return
11712 error_mark_node; otherwise, return the *_TYPE to which it referred.
11713 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11716 check_elaborated_type_specifier (enum tag_types tag_code
,
11718 bool allow_template_p
)
11722 if (decl
== error_mark_node
)
11723 return error_mark_node
;
11727 struct S { struct S *p; };
11729 name lookup will find the TYPE_DECL for the implicit "S::S"
11730 typedef. Adjust for that here. */
11731 if (DECL_SELF_REFERENCE_P (decl
))
11732 decl
= TYPE_NAME (TREE_TYPE (decl
));
11734 type
= TREE_TYPE (decl
);
11736 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11737 is false for this case as well. */
11738 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11740 error ("using template type parameter %qT after %qs",
11741 type
, tag_name (tag_code
));
11742 return error_mark_node
;
11744 /* Accept template template parameters. */
11745 else if (allow_template_p
11746 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
11747 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
11751 If the identifier resolves to a typedef-name or the
11752 simple-template-id resolves to an alias template
11753 specialization, the elaborated-type-specifier is ill-formed.
11755 In other words, the only legitimate declaration to use in the
11756 elaborated type specifier is the implicit typedef created when
11757 the type is declared. */
11758 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
11759 && !DECL_SELF_REFERENCE_P (decl
)
11760 && tag_code
!= typename_type
)
11762 if (alias_template_specialization_p (type
))
11763 error ("using alias template specialization %qT after %qs",
11764 type
, tag_name (tag_code
));
11766 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
11767 inform (DECL_SOURCE_LOCATION (decl
),
11768 "%qD has a previous declaration here", decl
);
11769 return error_mark_node
;
11771 else if (TREE_CODE (type
) != RECORD_TYPE
11772 && TREE_CODE (type
) != UNION_TYPE
11773 && tag_code
!= enum_type
11774 && tag_code
!= typename_type
)
11776 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
11777 error ("%q+T has a previous declaration here", type
);
11778 return error_mark_node
;
11780 else if (TREE_CODE (type
) != ENUMERAL_TYPE
11781 && tag_code
== enum_type
)
11783 error ("%qT referred to as enum", type
);
11784 error ("%q+T has a previous declaration here", type
);
11785 return error_mark_node
;
11787 else if (!allow_template_p
11788 && TREE_CODE (type
) == RECORD_TYPE
11789 && CLASSTYPE_IS_TEMPLATE (type
))
11791 /* If a class template appears as elaborated type specifier
11792 without a template header such as:
11794 template <class T> class C {};
11795 void f(class C); // No template header here
11797 then the required template argument is missing. */
11798 error ("template argument required for %<%s %T%>",
11799 tag_name (tag_code
),
11800 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
11801 return error_mark_node
;
11807 /* Lookup NAME in elaborate type specifier in scope according to
11808 SCOPE and issue diagnostics if necessary.
11809 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11810 found, and ERROR_MARK_NODE for type error. */
11813 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
11814 tag_scope scope
, bool template_header_p
)
11818 if (scope
== ts_global
)
11820 /* First try ordinary name lookup, ignoring hidden class name
11821 injected via friend declaration. */
11822 decl
= lookup_name_prefer_type (name
, 2);
11823 /* If that fails, the name will be placed in the smallest
11824 non-class, non-function-prototype scope according to 3.3.1/5.
11825 We may already have a hidden name declared as friend in this
11826 scope. So lookup again but not ignoring hidden names.
11827 If we find one, that name will be made visible rather than
11828 creating a new tag. */
11830 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
11833 decl
= lookup_type_scope (name
, scope
);
11836 && (DECL_CLASS_TEMPLATE_P (decl
)
11837 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl
)))
11838 decl
= DECL_TEMPLATE_RESULT (decl
);
11840 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
11842 /* Look for invalid nested type:
11846 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
11848 error ("%qD has the same name as the class in which it is "
11851 return error_mark_node
;
11854 /* Two cases we need to consider when deciding if a class
11855 template is allowed as an elaborated type specifier:
11856 1. It is a self reference to its own class.
11857 2. It comes with a template header.
11861 template <class T> class C {
11862 class C *c1; // DECL_SELF_REFERENCE_P is true
11865 template <class U> class C; // template_header_p is true
11866 template <class T> class C<T>::D {
11867 class C *c2; // DECL_SELF_REFERENCE_P is true
11870 t
= check_elaborated_type_specifier (tag_code
,
11873 | DECL_SELF_REFERENCE_P (decl
));
11876 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
11878 error ("reference to %qD is ambiguous", name
);
11879 print_candidates (decl
);
11880 return error_mark_node
;
11886 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
11887 Define the tag as a forward-reference if it is not defined.
11889 If a declaration is given, process it here, and report an error if
11890 multiple declarations are not identical.
11892 SCOPE is TS_CURRENT when this is also a definition. Only look in
11893 the current frame for the name (since C++ allows new names in any
11894 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
11895 declaration. Only look beginning from the current scope outward up
11896 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
11898 TEMPLATE_HEADER_P is true when this declaration is preceded by
11899 a set of template parameters. */
11902 xref_tag_1 (enum tag_types tag_code
, tree name
,
11903 tag_scope scope
, bool template_header_p
)
11905 enum tree_code code
;
11907 tree context
= NULL_TREE
;
11909 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
11915 code
= RECORD_TYPE
;
11921 code
= ENUMERAL_TYPE
;
11924 gcc_unreachable ();
11927 /* In case of anonymous name, xref_tag is only called to
11928 make type node and push name. Name lookup is not required. */
11929 if (ANON_AGGRNAME_P (name
))
11932 t
= lookup_and_check_tag (tag_code
, name
,
11933 scope
, template_header_p
);
11935 if (t
== error_mark_node
)
11936 return error_mark_node
;
11938 if (scope
!= ts_current
&& t
&& current_class_type
11939 && template_class_depth (current_class_type
)
11940 && template_header_p
)
11942 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
11945 /* Since SCOPE is not TS_CURRENT, we are not looking at a
11946 definition of this tag. Since, in addition, we are currently
11947 processing a (member) template declaration of a template
11948 class, we must be very careful; consider:
11955 { template <class V>
11956 friend struct S1; };
11958 Here, the S2::S1 declaration should not be confused with the
11959 outer declaration. In particular, the inner version should
11960 have a template parameter of level 2, not level 1. This
11961 would be particularly important if the member declaration
11964 template <class V = U> friend struct S1;
11966 say, when we should tsubst into `U' when instantiating
11967 S2. On the other hand, when presented with:
11977 we must find the inner binding eventually. We
11978 accomplish this by making sure that the new type we
11979 create to represent this declaration has the right
11981 context
= TYPE_CONTEXT (t
);
11987 /* If no such tag is yet defined, create a forward-reference node
11988 and record it as the "definition".
11989 When a real declaration of this type is found,
11990 the forward-reference will be altered into a real type. */
11991 if (code
== ENUMERAL_TYPE
)
11993 error ("use of enum %q#D without previous declaration", name
);
11994 return error_mark_node
;
11998 t
= make_class_type (code
);
11999 TYPE_CONTEXT (t
) = context
;
12000 t
= pushtag (name
, t
, scope
);
12005 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12007 if (!redeclare_class_template (t
, current_template_parms
))
12008 return error_mark_node
;
12010 else if (!processing_template_decl
12011 && CLASS_TYPE_P (t
)
12012 && CLASSTYPE_IS_TEMPLATE (t
))
12014 error ("redeclaration of %qT as a non-template", t
);
12015 error ("previous declaration %q+D", t
);
12016 return error_mark_node
;
12019 /* Make injected friend class visible. */
12020 if (scope
!= ts_within_enclosing_non_class
12021 && hidden_name_p (TYPE_NAME (t
)))
12023 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12024 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12026 if (TYPE_TEMPLATE_INFO (t
))
12028 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12029 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12037 /* Wrapper for xref_tag_1. */
12040 xref_tag (enum tag_types tag_code
, tree name
,
12041 tag_scope scope
, bool template_header_p
)
12045 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12046 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12047 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12053 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12055 enum tag_types tag_kind
;
12057 if (TREE_CODE (old
) == RECORD_TYPE
)
12058 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12060 tag_kind
= union_type
;
12062 if (id
== NULL_TREE
)
12063 id
= TYPE_IDENTIFIER (old
);
12065 return xref_tag (tag_kind
, id
, scope
, false);
12068 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12069 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12070 access_* node, and the TREE_VALUE is the type of the base-class.
12071 Non-NULL TREE_TYPE indicates virtual inheritance.
12073 Returns true if the binfo hierarchy was successfully created,
12074 false if an error was detected. */
12077 xref_basetypes (tree ref
, tree base_list
)
12080 tree binfo
, base_binfo
;
12081 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12082 unsigned max_bases
= 0; /* Maximum direct bases. */
12084 tree default_access
;
12085 tree igo_prev
; /* Track Inheritance Graph Order. */
12087 if (ref
== error_mark_node
)
12090 /* The base of a derived class is private by default, all others are
12092 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12093 && CLASSTYPE_DECLARED_CLASS (ref
)
12094 ? access_private_node
: access_public_node
);
12096 /* First, make sure that any templates in base-classes are
12097 instantiated. This ensures that if we call ourselves recursively
12098 we do not get confused about which classes are marked and which
12100 basep
= &base_list
;
12103 tree basetype
= TREE_VALUE (*basep
);
12105 /* The dependent_type_p call below should really be dependent_scope_p
12106 so that we give a hard error about using an incomplete type as a
12107 base, but we allow it with a pedwarn for backward
12109 if (processing_template_decl
12110 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12111 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12112 if (!dependent_type_p (basetype
)
12113 && !complete_type_or_else (basetype
, NULL
))
12114 /* An incomplete type. Remove it from the list. */
12115 *basep
= TREE_CHAIN (*basep
);
12119 if (TREE_TYPE (*basep
))
12121 if (CLASS_TYPE_P (basetype
))
12122 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12123 basep
= &TREE_CHAIN (*basep
);
12127 TYPE_MARKED_P (ref
) = 1;
12129 /* The binfo slot should be empty, unless this is an (ill-formed)
12131 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12133 error ("redefinition of %q#T", ref
);
12137 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12139 binfo
= make_tree_binfo (max_bases
);
12141 TYPE_BINFO (ref
) = binfo
;
12142 BINFO_OFFSET (binfo
) = size_zero_node
;
12143 BINFO_TYPE (binfo
) = ref
;
12145 /* Apply base-class info set up to the variants of this type. */
12146 fixup_type_variants (ref
);
12150 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12151 /* An aggregate cannot have baseclasses. */
12152 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12154 if (TREE_CODE (ref
) == UNION_TYPE
)
12156 error ("derived union %qT invalid", ref
);
12163 if (TYPE_FOR_JAVA (ref
))
12165 error ("Java class %qT cannot have multiple bases", ref
);
12172 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12174 if (TYPE_FOR_JAVA (ref
))
12176 error ("Java class %qT cannot have virtual bases", ref
);
12181 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12183 tree access
= TREE_PURPOSE (base_list
);
12184 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12185 tree basetype
= TREE_VALUE (base_list
);
12187 if (access
== access_default_node
)
12188 access
= default_access
;
12190 if (PACK_EXPANSION_P (basetype
))
12191 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12192 if (TREE_CODE (basetype
) == TYPE_DECL
)
12193 basetype
= TREE_TYPE (basetype
);
12194 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12196 error ("base type %qT fails to be a struct or class type",
12201 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12202 TYPE_FOR_JAVA (ref
) = 1;
12204 base_binfo
= NULL_TREE
;
12205 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12207 base_binfo
= TYPE_BINFO (basetype
);
12208 /* The original basetype could have been a typedef'd type. */
12209 basetype
= BINFO_TYPE (base_binfo
);
12211 /* Inherit flags from the base. */
12212 TYPE_HAS_NEW_OPERATOR (ref
)
12213 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12214 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12215 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12216 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12217 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12218 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12219 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12220 CLASSTYPE_REPEATED_BASE_P (ref
)
12221 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12224 /* We must do this test after we've seen through a typedef
12226 if (TYPE_MARKED_P (basetype
))
12228 if (basetype
== ref
)
12229 error ("recursive type %qT undefined", basetype
);
12231 error ("duplicate base type %qT invalid", basetype
);
12235 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12236 /* Regenerate the pack expansion for the bases. */
12237 basetype
= make_pack_expansion (basetype
);
12239 TYPE_MARKED_P (basetype
) = 1;
12241 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12242 &igo_prev
, via_virtual
);
12243 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12244 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12246 BINFO_BASE_APPEND (binfo
, base_binfo
);
12247 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12250 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12251 /* If we didn't get max_vbases vbases, we must have shared at
12252 least one of them, and are therefore diamond shaped. */
12253 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12255 /* Unmark all the types. */
12256 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12257 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12258 TYPE_MARKED_P (ref
) = 0;
12260 /* Now see if we have a repeated base type. */
12261 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12263 for (base_binfo
= binfo
; base_binfo
;
12264 base_binfo
= TREE_CHAIN (base_binfo
))
12266 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12268 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12271 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12273 for (base_binfo
= binfo
; base_binfo
;
12274 base_binfo
= TREE_CHAIN (base_binfo
))
12275 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12276 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12285 /* Copies the enum-related properties from type SRC to type DST.
12286 Used with the underlying type of an enum and the enum itself. */
12288 copy_type_enum (tree dst
, tree src
)
12291 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12293 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12294 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12295 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12296 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12297 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12298 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12299 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12300 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12301 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12305 /* Begin compiling the definition of an enumeration type.
12308 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12310 UNDERLYING_TYPE is the type that will be used as the storage for
12311 the enumeration type. This should be NULL_TREE if no storage type
12314 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12316 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12318 Returns the type object, as yet incomplete.
12319 Also records info about it so that build_enumerator
12320 may be used to declare the individual values as they are read. */
12323 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12324 bool scoped_enum_p
, bool *is_new
)
12326 tree prevtype
= NULL_TREE
;
12327 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
12331 /* [C++0x dcl.enum]p5:
12333 If not explicitly specified, the underlying type of a scoped
12334 enumeration type is int. */
12335 if (!underlying_type
&& scoped_enum_p
)
12336 underlying_type
= integer_type_node
;
12338 if (underlying_type
)
12339 underlying_type
= cv_unqualified (underlying_type
);
12341 /* If this is the real definition for a previous forward reference,
12342 fill in the contents in the same object that used to be the
12343 forward reference. */
12345 enumtype
= lookup_and_check_tag (enum_type
, name
,
12346 /*tag_scope=*/ts_current
,
12347 /*template_header_p=*/false);
12349 /* In case of a template_decl, the only check that should be deferred
12350 to instantiation time is the comparison of underlying types. */
12351 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12353 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12355 error_at (input_location
, "scoped/unscoped mismatch "
12356 "in enum %q#T", enumtype
);
12357 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12358 "previous definition here");
12359 enumtype
= error_mark_node
;
12361 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12363 error_at (input_location
, "underlying type mismatch "
12364 "in enum %q#T", enumtype
);
12365 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12366 "previous definition here");
12367 enumtype
= error_mark_node
;
12369 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12370 && !dependent_type_p (underlying_type
)
12371 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12372 && !same_type_p (underlying_type
,
12373 ENUM_UNDERLYING_TYPE (enumtype
)))
12375 error_at (input_location
, "different underlying type "
12376 "in enum %q#T", enumtype
);
12377 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12378 "previous definition here");
12379 underlying_type
= NULL_TREE
;
12383 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12384 || processing_template_decl
)
12386 /* In case of error, make a dummy enum to allow parsing to
12388 if (enumtype
== error_mark_node
)
12390 name
= make_anon_name ();
12391 enumtype
= NULL_TREE
;
12394 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12395 of an opaque enum, or an opaque enum of an already defined
12396 enumeration (C++0x only).
12397 In any other case, it'll be NULL_TREE. */
12403 prevtype
= enumtype
;
12405 /* Do not push the decl more than once, unless we need to
12406 compare underlying types at instantiation time */
12408 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12409 || (underlying_type
12410 && dependent_type_p (underlying_type
))
12411 || (ENUM_UNDERLYING_TYPE (enumtype
)
12412 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12414 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12415 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12418 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12421 if (enumtype
== error_mark_node
)
12422 return error_mark_node
;
12424 /* The enum is considered opaque until the opening '{' of the
12425 enumerator list. */
12426 SET_OPAQUE_ENUM_P (enumtype
, true);
12427 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12430 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12432 if (underlying_type
)
12434 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12436 copy_type_enum (enumtype
, underlying_type
);
12437 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12439 else if (dependent_type_p (underlying_type
))
12440 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12442 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12443 underlying_type
, enumtype
);
12446 /* If into a template class, the returned enum is always the first
12447 declaration (opaque or not) seen. This way all the references to
12448 this type will be to the same declaration. The following ones are used
12449 only to check for definition errors. */
12450 if (prevtype
&& processing_template_decl
)
12456 /* After processing and defining all the values of an enumeration type,
12457 install their decls in the enumeration type.
12458 ENUMTYPE is the type object. */
12461 finish_enum_value_list (tree enumtype
)
12464 tree underlying_type
;
12467 tree minnode
, maxnode
;
12470 bool fixed_underlying_type_p
12471 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12473 /* We built up the VALUES in reverse order. */
12474 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12476 /* For an enum defined in a template, just set the type of the values;
12477 all further processing is postponed until the template is
12478 instantiated. We need to set the type so that tsubst of a CONST_DECL
12480 if (processing_template_decl
)
12482 for (values
= TYPE_VALUES (enumtype
);
12484 values
= TREE_CHAIN (values
))
12485 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12489 /* Determine the minimum and maximum values of the enumerators. */
12490 if (TYPE_VALUES (enumtype
))
12492 minnode
= maxnode
= NULL_TREE
;
12494 for (values
= TYPE_VALUES (enumtype
);
12496 values
= TREE_CHAIN (values
))
12498 decl
= TREE_VALUE (values
);
12500 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12501 each enumerator has the type of its enumeration. Prior to the
12502 closing brace, the type of each enumerator is the type of its
12503 initializing value. */
12504 TREE_TYPE (decl
) = enumtype
;
12506 /* Update the minimum and maximum values, if appropriate. */
12507 value
= DECL_INITIAL (decl
);
12508 if (value
== error_mark_node
)
12509 value
= integer_zero_node
;
12510 /* Figure out what the minimum and maximum values of the
12511 enumerators are. */
12513 minnode
= maxnode
= value
;
12514 else if (tree_int_cst_lt (maxnode
, value
))
12516 else if (tree_int_cst_lt (value
, minnode
))
12523 If the enumerator-list is empty, the underlying type is as if
12524 the enumeration had a single enumerator with value 0. */
12525 minnode
= maxnode
= integer_zero_node
;
12527 if (!fixed_underlying_type_p
)
12529 /* Compute the number of bits require to represent all values of the
12530 enumeration. We must do this before the type of MINNODE and
12531 MAXNODE are transformed, since tree_int_cst_min_precision relies
12532 on the TREE_TYPE of the value it is passed. */
12533 bool unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12534 int lowprec
= tree_int_cst_min_precision (minnode
, unsignedp
);
12535 int highprec
= tree_int_cst_min_precision (maxnode
, unsignedp
);
12536 int precision
= MAX (lowprec
, highprec
);
12538 bool use_short_enum
;
12540 /* Determine the underlying type of the enumeration.
12544 The underlying type of an enumeration is an integral type that
12545 can represent all the enumerator values defined in the
12546 enumeration. It is implementation-defined which integral type is
12547 used as the underlying type for an enumeration except that the
12548 underlying type shall not be larger than int unless the value of
12549 an enumerator cannot fit in an int or unsigned int.
12551 We use "int" or an "unsigned int" as the underlying type, even if
12552 a smaller integral type would work, unless the user has
12553 explicitly requested that we use the smallest possible type. The
12554 user can request that for all enumerations with a command line
12555 flag, or for just one enumeration with an attribute. */
12557 use_short_enum
= flag_short_enums
12558 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12560 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12564 underlying_type
= integer_types
[itk
];
12565 if (underlying_type
!= NULL_TREE
12566 && TYPE_PRECISION (underlying_type
) >= precision
12567 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
12570 if (itk
== itk_none
)
12574 IF no integral type can represent all the enumerator values, the
12575 enumeration is ill-formed. */
12576 error ("no integral type can represent all of the enumerator values "
12577 "for %qT", enumtype
);
12578 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12579 underlying_type
= integer_types
[itk_unsigned_long_long
];
12584 The value of sizeof() applied to an enumeration type, an object
12585 of an enumeration type, or an enumerator, is the value of sizeof()
12586 applied to the underlying type. */
12587 copy_type_enum (enumtype
, underlying_type
);
12589 /* Compute the minimum and maximum values for the type.
12593 For an enumeration where emin is the smallest enumerator and emax
12594 is the largest, the values of the enumeration are the values of the
12595 underlying type in the range bmin to bmax, where bmin and bmax are,
12596 respectively, the smallest and largest values of the smallest bit-
12597 field that can store emin and emax. */
12599 /* The middle-end currently assumes that types with TYPE_PRECISION
12600 narrower than their underlying type are suitably zero or sign
12601 extended to fill their mode. Similarly, it assumes that the front
12602 end assures that a value of a particular type must be within
12603 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12605 We used to set these fields based on bmin and bmax, but that led
12606 to invalid assumptions like optimizing away bounds checking. So
12607 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12608 TYPE_MAX_VALUE to the values for the mode above and only restrict
12609 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12610 ENUM_UNDERLYING_TYPE (enumtype
)
12611 = build_distinct_type_copy (underlying_type
);
12612 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12613 set_min_and_max_values_for_integral_type
12614 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, unsignedp
);
12616 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12617 if (flag_strict_enums
)
12618 set_min_and_max_values_for_integral_type (enumtype
, precision
,
12622 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12624 /* Convert each of the enumerators to the type of the underlying
12625 type of the enumeration. */
12626 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12628 location_t saved_location
;
12630 decl
= TREE_VALUE (values
);
12631 saved_location
= input_location
;
12632 input_location
= DECL_SOURCE_LOCATION (decl
);
12633 if (fixed_underlying_type_p
)
12634 /* If the enumeration type has a fixed underlying type, we
12635 already checked all of the enumerator values. */
12636 value
= DECL_INITIAL (decl
);
12638 value
= perform_implicit_conversion (underlying_type
,
12639 DECL_INITIAL (decl
),
12640 tf_warning_or_error
);
12641 input_location
= saved_location
;
12643 /* Do not clobber shared ints. */
12644 value
= copy_node (value
);
12646 TREE_TYPE (value
) = enumtype
;
12647 DECL_INITIAL (decl
) = value
;
12650 /* Fix up all variant types of this enum type. */
12651 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12652 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12654 if (at_class_scope_p ()
12655 && COMPLETE_TYPE_P (current_class_type
)
12656 && UNSCOPED_ENUM_P (enumtype
))
12657 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
12658 current_class_type
);
12660 /* Finish debugging output for this type. */
12661 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12664 /* Finishes the enum type. This is called only the first time an
12665 enumeration is seen, be it opaque or odinary.
12666 ENUMTYPE is the type object. */
12669 finish_enum (tree enumtype
)
12671 if (processing_template_decl
)
12673 if (at_function_scope_p ())
12674 add_stmt (build_min (TAG_DEFN
, enumtype
));
12678 /* If this is a forward declaration, there should not be any variants,
12679 though we can get a variant in the middle of an enum-specifier with
12680 wacky code like 'enum E { e = sizeof(const E*) };' */
12681 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
12682 && (TYPE_VALUES (enumtype
)
12683 || !TYPE_NEXT_VARIANT (enumtype
)));
12686 /* Build and install a CONST_DECL for an enumeration constant of the
12687 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12688 LOC is the location of NAME.
12689 Assignment of sequential values by default is handled here. */
12692 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
12698 /* If the VALUE was erroneous, pretend it wasn't there; that will
12699 result in the enum being assigned the next value in sequence. */
12700 if (value
== error_mark_node
)
12703 /* Remove no-op casts from the value. */
12705 STRIP_TYPE_NOPS (value
);
12707 if (! processing_template_decl
)
12709 /* Validate and default VALUE. */
12710 if (value
!= NULL_TREE
)
12712 value
= cxx_constant_value (value
);
12714 if (TREE_CODE (value
) != INTEGER_CST
12715 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
12717 error ("enumerator value for %qD is not an integer constant",
12723 /* Default based on previous value. */
12724 if (value
== NULL_TREE
)
12726 if (TYPE_VALUES (enumtype
))
12731 /* C++03 7.2/4: If no initializer is specified for the first
12732 enumerator, the type is an unspecified integral
12733 type. Otherwise the type is the same as the type of the
12734 initializing value of the preceding enumerator unless the
12735 incremented value is not representable in that type, in
12736 which case the type is an unspecified integral type
12737 sufficient to contain the incremented value. */
12738 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12739 if (error_operand_p (prev_value
))
12740 value
= error_mark_node
;
12743 double_int di
= TREE_INT_CST (prev_value
)
12744 .add_with_sign (double_int_one
,
12745 false, &overflowed
);
12748 tree type
= TREE_TYPE (prev_value
);
12749 bool pos
= TYPE_UNSIGNED (type
) || !di
.is_negative ();
12750 if (!double_int_fits_to_tree_p (type
, di
))
12753 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
12755 type
= integer_types
[itk
];
12756 if (type
!= NULL_TREE
12757 && (pos
|| !TYPE_UNSIGNED (type
))
12758 && double_int_fits_to_tree_p (type
, di
))
12761 if (type
&& cxx_dialect
< cxx0x
12762 && itk
> itk_unsigned_long
)
12763 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
12764 incremented enumerator value is too large for %<unsigned long%>" : "\
12765 incremented enumerator value is too large for %<long%>");
12767 if (type
== NULL_TREE
)
12770 value
= double_int_to_tree (type
, di
);
12775 error ("overflow in enumeration values at %qD", name
);
12776 value
= error_mark_node
;
12781 value
= integer_zero_node
;
12784 /* Remove no-op casts from the value. */
12785 STRIP_TYPE_NOPS (value
);
12787 /* If the underlying type of the enum is fixed, check whether
12788 the enumerator values fits in the underlying type. If it
12789 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12790 if (ENUM_UNDERLYING_TYPE (enumtype
)
12792 && TREE_CODE (value
) == INTEGER_CST
12793 && !int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
12795 error ("enumerator value %E is too large for underlying type %<%T%>",
12796 value
, ENUM_UNDERLYING_TYPE (enumtype
));
12798 /* Silently convert the value so that we can continue. */
12799 value
= perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype
),
12804 /* C++ associates enums with global, function, or class declarations. */
12805 context
= current_scope ();
12807 /* Build the actual enumeration constant. Note that the enumeration
12808 constants have the underlying type of the enum (if it is fixed)
12809 or the type of their initializer (if the underlying type of the
12810 enum is not fixed):
12814 If the underlying type is fixed, the type of each enumerator
12815 prior to the closing brace is the underlying type; if the
12816 initializing value of an enumerator cannot be represented by
12817 the underlying type, the program is ill-formed. If the
12818 underlying type is not fixed, the type of each enumerator is
12819 the type of its initializing value.
12821 If the underlying type is not fixed, it will be computed by
12822 finish_enum and we will reset the type of this enumerator. Of
12823 course, if we're processing a template, there may be no value. */
12824 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12826 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
12828 DECL_CONTEXT (decl
) = enumtype
;
12829 TREE_CONSTANT (decl
) = 1;
12830 TREE_READONLY (decl
) = 1;
12831 DECL_INITIAL (decl
) = value
;
12833 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
12834 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12835 on the TYPE_FIELDS list for `S'. (That's so that you can say
12836 things like `S::i' later.) */
12837 finish_member_declaration (decl
);
12841 /* Add this enumeration constant to the list for this type. */
12842 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12845 /* Look for an enumerator with the given NAME within the enumeration
12846 type ENUMTYPE. This routine is used primarily for qualified name
12847 lookup into an enumerator in C++0x, e.g.,
12849 enum class Color { Red, Green, Blue };
12851 Color color = Color::Red;
12853 Returns the value corresponding to the enumerator, or
12854 NULL_TREE if no such enumerator was found. */
12856 lookup_enumerator (tree enumtype
, tree name
)
12859 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
12861 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
12862 return e
? TREE_VALUE (e
) : NULL_TREE
;
12866 /* We're defining DECL. Make sure that its type is OK. */
12869 check_function_type (tree decl
, tree current_function_parms
)
12871 tree fntype
= TREE_TYPE (decl
);
12872 tree return_type
= complete_type (TREE_TYPE (fntype
));
12874 /* In a function definition, arg types must be complete. */
12875 require_complete_types_for_parms (current_function_parms
);
12877 if (dependent_type_p (return_type
)
12878 || type_uses_auto (return_type
))
12880 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
12881 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
12883 tree args
= TYPE_ARG_TYPES (fntype
);
12885 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
12886 error ("return type %q#T is incomplete", return_type
);
12888 error ("return type has Java class type %q#T", return_type
);
12890 /* Make it return void instead. */
12891 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12892 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
12894 TREE_CHAIN (args
));
12896 fntype
= build_function_type (void_type_node
, args
);
12898 = build_exception_variant (fntype
,
12899 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
12900 fntype
= (cp_build_type_attribute_variant
12901 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
12902 TREE_TYPE (decl
) = fntype
;
12905 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
12908 /* Create the FUNCTION_DECL for a function definition.
12909 DECLSPECS and DECLARATOR are the parts of the declaration;
12910 they describe the function's name and the type it returns,
12911 but twisted together in a fashion that parallels the syntax of C.
12913 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12914 DECLARATOR is really the DECL for the function we are about to
12915 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12916 indicating that the function is an inline defined in-class.
12918 This function creates a binding context for the function body
12919 as well as setting up the FUNCTION_DECL in current_function_decl.
12921 For C++, we must first check whether that datum makes any sense.
12922 For example, "class A local_a(1,2);" means that variable local_a
12923 is an aggregate of type A, which should have a constructor
12924 applied to it with the argument list [1, 2].
12926 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
12927 or may be a BLOCK if the function has been defined previously
12928 in this translation unit. On exit, DECL_INITIAL (decl1) will be
12929 error_mark_node if the function has never been defined, or
12930 a BLOCK if the function has been defined somewhere. */
12933 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
12935 tree ctype
= NULL_TREE
;
12938 int doing_friend
= 0;
12939 cp_binding_level
*bl
;
12940 tree current_function_parms
;
12941 struct c_fileinfo
*finfo
12942 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
12943 bool honor_interface
;
12945 /* Sanity check. */
12946 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
);
12947 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
12949 fntype
= TREE_TYPE (decl1
);
12950 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12951 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12953 /* ISO C++ 11.4/5. A friend function defined in a class is in
12954 the (lexical) scope of the class in which it is defined. */
12955 if (!ctype
&& DECL_FRIEND_P (decl1
))
12957 ctype
= DECL_FRIEND_CONTEXT (decl1
);
12959 /* CTYPE could be null here if we're dealing with a template;
12960 for example, `inline friend float foo()' inside a template
12961 will have no CTYPE set. */
12962 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
12968 if (DECL_DECLARED_INLINE_P (decl1
)
12969 && lookup_attribute ("noinline", attrs
))
12970 warning (0, "inline function %q+D given attribute noinline", decl1
);
12972 /* Handle gnu_inline attribute. */
12973 if (GNU_INLINE_P (decl1
))
12975 DECL_EXTERNAL (decl1
) = 1;
12976 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
12977 DECL_INTERFACE_KNOWN (decl1
) = 1;
12978 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
12981 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
12982 /* This is a constructor, we must ensure that any default args
12983 introduced by this definition are propagated to the clones
12984 now. The clones are used directly in overload resolution. */
12985 adjust_clone_args (decl1
);
12987 /* Sometimes we don't notice that a function is a static member, and
12988 build a METHOD_TYPE for it. Fix that up now. */
12989 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
12990 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
12992 /* Set up current_class_type, and enter the scope of the class, if
12995 push_nested_class (ctype
);
12996 else if (DECL_STATIC_FUNCTION_P (decl1
))
12997 push_nested_class (DECL_CONTEXT (decl1
));
12999 /* Now that we have entered the scope of the class, we must restore
13000 the bindings for any template parameters surrounding DECL1, if it
13001 is an inline member template. (Order is important; consider the
13002 case where a template parameter has the same name as a field of
13003 the class.) It is not until after this point that
13004 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13005 if (flags
& SF_INCLASS_INLINE
)
13006 maybe_begin_member_template_processing (decl1
);
13008 /* Effective C++ rule 15. */
13010 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13011 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
13012 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13014 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13015 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13016 if (!DECL_INITIAL (decl1
))
13017 DECL_INITIAL (decl1
) = error_mark_node
;
13019 /* This function exists in static storage.
13020 (This does not mean `static' in the C sense!) */
13021 TREE_STATIC (decl1
) = 1;
13023 /* We must call push_template_decl after current_class_type is set
13024 up. (If we are processing inline definitions after exiting a
13025 class scope, current_class_type will be NULL_TREE until set above
13026 by push_nested_class.) */
13027 if (processing_template_decl
)
13029 /* FIXME: Handle error_mark_node more gracefully. */
13030 tree newdecl1
= push_template_decl (decl1
);
13031 if (newdecl1
!= error_mark_node
)
13035 /* We are now in the scope of the function being defined. */
13036 current_function_decl
= decl1
;
13038 /* Save the parm names or decls from this function's declarator
13039 where store_parm_decls will find them. */
13040 current_function_parms
= DECL_ARGUMENTS (decl1
);
13042 /* Make sure the parameter and return types are reasonable. When
13043 you declare a function, these types can be incomplete, but they
13044 must be complete when you define the function. */
13045 check_function_type (decl1
, current_function_parms
);
13047 /* Build the return declaration for the function. */
13048 restype
= TREE_TYPE (fntype
);
13050 if (DECL_RESULT (decl1
) == NULL_TREE
)
13054 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13055 DECL_ARTIFICIAL (resdecl
) = 1;
13056 DECL_IGNORED_P (resdecl
) = 1;
13057 DECL_RESULT (decl1
) = resdecl
;
13059 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13062 /* Let the user know we're compiling this function. */
13063 announce_function (decl1
);
13065 /* Record the decl so that the function name is defined.
13066 If we already have a decl for this name, and it is a FUNCTION_DECL,
13067 use the old decl. */
13068 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13070 /* A specialization is not used to guide overload resolution. */
13071 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13072 && !(DECL_USE_TEMPLATE (decl1
) &&
13073 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13075 tree olddecl
= pushdecl (decl1
);
13077 if (olddecl
== error_mark_node
)
13078 /* If something went wrong when registering the declaration,
13079 use DECL1; we have to have a FUNCTION_DECL to use when
13080 parsing the body of the function. */
13084 /* Otherwise, OLDDECL is either a previous declaration
13085 of the same function or DECL1 itself. */
13087 if (warn_missing_declarations
13088 && olddecl
== decl1
13089 && !DECL_MAIN_P (decl1
)
13090 && TREE_PUBLIC (decl1
)
13091 && !DECL_DECLARED_INLINE_P (decl1
))
13095 /* Check whether DECL1 is in an anonymous
13097 for (context
= DECL_CONTEXT (decl1
);
13099 context
= DECL_CONTEXT (context
))
13101 if (TREE_CODE (context
) == NAMESPACE_DECL
13102 && DECL_NAME (context
) == NULL_TREE
)
13106 if (context
== NULL
)
13107 warning (OPT_Wmissing_declarations
,
13108 "no previous declaration for %q+D", decl1
);
13116 /* We need to set the DECL_CONTEXT. */
13117 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13118 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13120 fntype
= TREE_TYPE (decl1
);
13122 /* If #pragma weak applies, mark the decl appropriately now.
13123 The pragma only applies to global functions. Because
13124 determining whether or not the #pragma applies involves
13125 computing the mangled name for the declaration, we cannot
13126 apply the pragma until after we have merged this declaration
13127 with any previous declarations; if the original declaration
13128 has a linkage specification, that specification applies to
13129 the definition as well, and may affect the mangled name. */
13130 if (DECL_FILE_SCOPE_P (decl1
))
13131 maybe_apply_pragma_weak (decl1
);
13134 /* Reset this in case the call to pushdecl changed it. */
13135 current_function_decl
= decl1
;
13137 gcc_assert (DECL_INITIAL (decl1
));
13139 /* This function may already have been parsed, in which case just
13140 return; our caller will skip over the body without parsing. */
13141 if (DECL_INITIAL (decl1
) != error_mark_node
)
13144 /* Initialize RTL machinery. We cannot do this until
13145 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13146 even when processing a template; this is how we get
13147 CFUN set up, and our per-function variables initialized.
13148 FIXME factor out the non-RTL stuff. */
13149 bl
= current_binding_level
;
13150 allocate_struct_function (decl1
, processing_template_decl
);
13152 /* Initialize the language data structures. Whenever we start
13153 a new function, we destroy temporaries in the usual way. */
13154 cfun
->language
= ggc_alloc_cleared_language_function ();
13155 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13156 current_binding_level
= bl
;
13158 if (!processing_template_decl
&& type_uses_auto (restype
))
13160 FNDECL_USED_AUTO (decl1
) = true;
13161 current_function_auto_return_pattern
= restype
;
13164 /* Start the statement-tree, start the tree now. */
13165 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13167 /* If we are (erroneously) defining a function that we have already
13168 defined before, wipe out what we knew before. */
13169 if (!DECL_PENDING_INLINE_P (decl1
))
13170 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13172 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13174 /* We know that this was set up by `grokclassfn'. We do not
13175 wait until `store_parm_decls', since evil parse errors may
13176 never get us to that point. Here we keep the consistency
13177 between `current_class_type' and `current_class_ptr'. */
13178 tree t
= DECL_ARGUMENTS (decl1
);
13180 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13181 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
);
13183 cp_function_chain
->x_current_class_ref
13184 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13185 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13186 cp_function_chain
->x_current_class_ptr
= t
;
13188 /* Constructors and destructors need to know whether they're "in
13189 charge" of initializing virtual base classes. */
13190 t
= DECL_CHAIN (t
);
13191 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13193 current_in_charge_parm
= t
;
13194 t
= DECL_CHAIN (t
);
13196 if (DECL_HAS_VTT_PARM_P (decl1
))
13198 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13199 current_vtt_parm
= t
;
13203 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13204 /* Implicitly-defined methods (like the
13205 destructor for a class in which no destructor
13206 is explicitly declared) must not be defined
13207 until their definition is needed. So, we
13208 ignore interface specifications for
13209 compiler-generated functions. */
13210 && !DECL_ARTIFICIAL (decl1
));
13212 if (processing_template_decl
)
13213 /* Don't mess with interface flags. */;
13214 else if (DECL_INTERFACE_KNOWN (decl1
))
13216 tree ctx
= decl_function_context (decl1
);
13218 if (DECL_NOT_REALLY_EXTERN (decl1
))
13219 DECL_EXTERNAL (decl1
) = 0;
13221 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13222 /* This is a function in a local class in an extern inline
13223 or template function. */
13224 comdat_linkage (decl1
);
13226 /* If this function belongs to an interface, it is public.
13227 If it belongs to someone else's interface, it is also external.
13228 This only affects inlines and template instantiations. */
13229 else if (!finfo
->interface_unknown
&& honor_interface
)
13231 if (DECL_DECLARED_INLINE_P (decl1
)
13232 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13234 DECL_EXTERNAL (decl1
)
13235 = (finfo
->interface_only
13236 || (DECL_DECLARED_INLINE_P (decl1
)
13237 && ! flag_implement_inlines
13238 && !DECL_VINDEX (decl1
)));
13240 /* For WIN32 we also want to put these in linkonce sections. */
13241 maybe_make_one_only (decl1
);
13244 DECL_EXTERNAL (decl1
) = 0;
13245 DECL_INTERFACE_KNOWN (decl1
) = 1;
13246 /* If this function is in an interface implemented in this file,
13247 make sure that the back end knows to emit this function
13249 if (!DECL_EXTERNAL (decl1
))
13250 mark_needed (decl1
);
13252 else if (finfo
->interface_unknown
&& finfo
->interface_only
13253 && honor_interface
)
13255 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13256 interface, we will have both finfo->interface_unknown and
13257 finfo->interface_only set. In that case, we don't want to
13258 use the normal heuristics because someone will supply a
13259 #pragma implementation elsewhere, and deducing it here would
13260 produce a conflict. */
13261 comdat_linkage (decl1
);
13262 DECL_EXTERNAL (decl1
) = 0;
13263 DECL_INTERFACE_KNOWN (decl1
) = 1;
13264 DECL_DEFER_OUTPUT (decl1
) = 1;
13268 /* This is a definition, not a reference.
13269 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13270 if (!GNU_INLINE_P (decl1
))
13271 DECL_EXTERNAL (decl1
) = 0;
13273 if ((DECL_DECLARED_INLINE_P (decl1
)
13274 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13275 && ! DECL_INTERFACE_KNOWN (decl1
))
13276 DECL_DEFER_OUTPUT (decl1
) = 1;
13278 DECL_INTERFACE_KNOWN (decl1
) = 1;
13281 /* Determine the ELF visibility attribute for the function. We must not
13282 do this before calling "pushdecl", as we must allow "duplicate_decls"
13283 to merge any attributes appropriately. We also need to wait until
13285 if (!DECL_CLONED_FUNCTION_P (decl1
))
13286 determine_visibility (decl1
);
13288 begin_scope (sk_function_parms
, decl1
);
13292 if (DECL_DESTRUCTOR_P (decl1
)
13293 || (DECL_CONSTRUCTOR_P (decl1
)
13294 && targetm
.cxx
.cdtor_returns_this ()))
13296 cdtor_label
= build_decl (input_location
,
13297 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13298 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13301 start_fname_decls ();
13303 store_parm_decls (current_function_parms
);
13307 /* Like start_preparsed_function, except that instead of a
13308 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13310 Returns 1 on success. If the DECLARATOR is not suitable for a function
13311 (it defines a datum instead), we return 0, which tells
13312 yyparse to report a parse error. */
13315 start_function (cp_decl_specifier_seq
*declspecs
,
13316 const cp_declarator
*declarator
,
13321 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13322 if (decl1
== error_mark_node
)
13324 /* If the declarator is not suitable for a function definition,
13325 cause a syntax error. */
13326 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13328 error ("invalid function declaration");
13332 if (DECL_MAIN_P (decl1
))
13333 /* main must return int. grokfndecl should have corrected it
13334 (and issued a diagnostic) if the user got it wrong. */
13335 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13336 integer_type_node
));
13338 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13343 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13347 use_eh_spec_block (tree fn
)
13349 return (flag_exceptions
&& flag_enforce_eh_specs
13350 && !processing_template_decl
13351 && !type_throw_all_p (TREE_TYPE (fn
))
13352 /* We insert the EH_SPEC_BLOCK only in the original
13353 function; then, it is copied automatically to the
13355 && !DECL_CLONED_FUNCTION_P (fn
)
13356 /* Implicitly-generated constructors and destructors have
13357 exception specifications. However, those specifications
13358 are the union of the possible exceptions specified by the
13359 constructors/destructors for bases and members, so no
13360 unallowed exception will ever reach this function. By
13361 not creating the EH_SPEC_BLOCK we save a little memory,
13362 and we avoid spurious warnings about unreachable
13364 && !DECL_DEFAULTED_FN (fn
));
13367 /* Store the parameter declarations into the current function declaration.
13368 This is called after parsing the parameter declarations, before
13369 digesting the body of the function.
13371 Also install to binding contour return value identifier, if any. */
13374 store_parm_decls (tree current_function_parms
)
13376 tree fndecl
= current_function_decl
;
13379 /* This is a chain of any other decls that came in among the parm
13380 declarations. If a parm is declared with enum {foo, bar} x;
13381 then CONST_DECLs for foo and bar are put here. */
13382 tree nonparms
= NULL_TREE
;
13384 if (current_function_parms
)
13386 /* This case is when the function was defined with an ANSI prototype.
13387 The parms already have decls, so we need not do anything here
13388 except record them as in effect
13389 and complain if any redundant old-style parm decls were written. */
13391 tree specparms
= current_function_parms
;
13394 /* Must clear this because it might contain TYPE_DECLs declared
13396 current_binding_level
->names
= NULL
;
13398 /* If we're doing semantic analysis, then we'll call pushdecl
13399 for each of these. We must do them in reverse order so that
13400 they end in the correct forward order. */
13401 specparms
= nreverse (specparms
);
13403 for (parm
= specparms
; parm
; parm
= next
)
13405 next
= DECL_CHAIN (parm
);
13406 if (TREE_CODE (parm
) == PARM_DECL
)
13408 if (DECL_NAME (parm
) == NULL_TREE
13409 || TREE_CODE (parm
) != VOID_TYPE
)
13412 error ("parameter %qD declared void", parm
);
13416 /* If we find an enum constant or a type tag,
13417 put it aside for the moment. */
13418 TREE_CHAIN (parm
) = NULL_TREE
;
13419 nonparms
= chainon (nonparms
, parm
);
13423 /* Get the decls in their original chain order and record in the
13424 function. This is all and only the PARM_DECLs that were
13425 pushed into scope by the loop above. */
13426 DECL_ARGUMENTS (fndecl
) = getdecls ();
13429 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13431 /* Now store the final chain of decls for the arguments
13432 as the decl-chain of the current lexical scope.
13433 Put the enumerators in as well, at the front so that
13434 DECL_ARGUMENTS is not modified. */
13435 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13437 if (use_eh_spec_block (current_function_decl
))
13438 current_eh_spec_block
= begin_eh_spec_block ();
13442 /* We have finished doing semantic analysis on DECL, but have not yet
13443 generated RTL for its body. Save away our current state, so that
13444 when we want to generate RTL later we know what to do. */
13447 save_function_data (tree decl
)
13449 struct language_function
*f
;
13451 /* Save the language-specific per-function data so that we can
13452 get it back when we really expand this function. */
13453 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13456 f
= ggc_alloc_language_function ();
13457 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13458 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13460 /* Clear out the bits we don't need. */
13461 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13462 f
->bindings
= NULL
;
13463 f
->x_local_names
= NULL
;
13464 f
->base
.local_typedefs
= NULL
;
13468 /* Set the return value of the constructor (if present). */
13471 finish_constructor_body (void)
13476 if (targetm
.cxx
.cdtor_returns_this ()
13477 && (! TYPE_FOR_JAVA (current_class_type
)))
13479 /* Any return from a constructor will end up here. */
13480 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13482 val
= DECL_ARGUMENTS (current_function_decl
);
13483 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13484 DECL_RESULT (current_function_decl
), val
);
13485 /* Return the address of the object. */
13486 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13487 add_stmt (exprstmt
);
13491 /* Do all the processing for the beginning of a destructor; set up the
13492 vtable pointers and cleanups for bases and members. */
13495 begin_destructor_body (void)
13497 tree compound_stmt
;
13499 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13500 issued an error message. We still want to try to process the
13501 body of the function, but initialize_vtbl_ptrs will crash if
13502 TYPE_BINFO is NULL. */
13503 if (COMPLETE_TYPE_P (current_class_type
))
13505 compound_stmt
= begin_compound_stmt (0);
13506 /* Make all virtual function table pointers in non-virtual base
13507 classes point to CURRENT_CLASS_TYPE's virtual function
13509 initialize_vtbl_ptrs (current_class_ptr
);
13510 finish_compound_stmt (compound_stmt
);
13512 /* And insert cleanups for our bases and members so that they
13513 will be properly destroyed if we throw. */
13514 push_base_cleanups ();
13518 /* At the end of every destructor we generate code to delete the object if
13519 necessary. Do that now. */
13522 finish_destructor_body (void)
13526 /* Any return from a destructor will end up here; that way all base
13527 and member cleanups will be run when the function returns. */
13528 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13530 /* In a virtual destructor, we must call delete. */
13531 if (DECL_VIRTUAL_P (current_function_decl
))
13534 tree virtual_size
= cxx_sizeof (current_class_type
);
13538 At the point of definition of a virtual destructor (including
13539 an implicit definition), non-placement operator delete shall
13540 be looked up in the scope of the destructor's class and if
13541 found shall be accessible and unambiguous. */
13542 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13544 /*global_p=*/false,
13545 /*placement=*/NULL_TREE
,
13546 /*alloc_fn=*/NULL_TREE
,
13547 tf_warning_or_error
);
13549 if_stmt
= begin_if_stmt ();
13550 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13551 current_in_charge_parm
,
13554 finish_expr_stmt (exprstmt
);
13555 finish_then_clause (if_stmt
);
13556 finish_if_stmt (if_stmt
);
13559 if (targetm
.cxx
.cdtor_returns_this ())
13563 val
= DECL_ARGUMENTS (current_function_decl
);
13564 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13565 DECL_RESULT (current_function_decl
), val
);
13566 /* Return the address of the object. */
13567 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13568 add_stmt (exprstmt
);
13572 /* Do the necessary processing for the beginning of a function body, which
13573 in this case includes member-initializers, but not the catch clauses of
13574 a function-try-block. Currently, this means opening a binding level
13575 for the member-initializers (in a ctor), member cleanups (in a dtor),
13576 and capture proxies (in a lambda operator()). */
13579 begin_function_body (void)
13583 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13586 if (processing_template_decl
)
13587 /* Do nothing now. */;
13589 /* Always keep the BLOCK node associated with the outermost pair of
13590 curly braces of a function. These are needed for correct
13591 operation of dwarfout.c. */
13592 keep_next_level (true);
13594 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13596 if (processing_template_decl
)
13597 /* Do nothing now. */;
13598 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13599 begin_destructor_body ();
13604 /* Do the processing for the end of a function body. Currently, this means
13605 closing out the cleanups for fully-constructed bases and members, and in
13606 the case of the destructor, deleting the object if desired. Again, this
13607 is only meaningful for [cd]tors, since they are the only functions where
13608 there is a significant distinction between the main body and any
13609 function catch clauses. Handling, say, main() return semantics here
13610 would be wrong, as flowing off the end of a function catch clause for
13611 main() would also need to return 0. */
13614 finish_function_body (tree compstmt
)
13616 if (compstmt
== NULL_TREE
)
13619 /* Close the block. */
13620 finish_compound_stmt (compstmt
);
13622 if (processing_template_decl
)
13623 /* Do nothing now. */;
13624 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
13625 finish_constructor_body ();
13626 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13627 finish_destructor_body ();
13630 /* Given a function, returns the BLOCK corresponding to the outermost level
13631 of curly braces, skipping the artificial block created for constructor
13635 outer_curly_brace_block (tree fndecl
)
13637 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
13638 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13639 /* Skip the artificial function body block. */
13640 block
= BLOCK_SUBBLOCKS (block
);
13644 /* If FNDECL is a class's key method, add the class to the list of
13645 keyed classes that should be emitted. */
13648 record_key_method_defined (tree fndecl
)
13650 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
13651 && DECL_VIRTUAL_P (fndecl
)
13652 && !processing_template_decl
)
13654 tree fnclass
= DECL_CONTEXT (fndecl
);
13655 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
13656 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
13660 /* Subroutine of finish_function.
13661 Save the body of constexpr functions for possible
13662 future compile time evaluation. */
13665 maybe_save_function_definition (tree fun
)
13667 if (!processing_template_decl
13668 && DECL_DECLARED_CONSTEXPR_P (fun
)
13669 && !DECL_CLONED_FUNCTION_P (fun
))
13670 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
13673 /* Finish up a function declaration and compile that function
13674 all the way to assembler language output. The free the storage
13675 for the function definition.
13677 FLAGS is a bitwise or of the following values:
13679 We just finished processing the body of an in-class inline
13680 function definition. (This processing will have taken place
13681 after the class definition is complete.) */
13684 finish_function (int flags
)
13686 tree fndecl
= current_function_decl
;
13687 tree fntype
, ctype
= NULL_TREE
;
13688 int inclass_inline
= (flags
& 2) != 0;
13690 /* When we get some parse errors, we can end up without a
13691 current_function_decl, so cope. */
13692 if (fndecl
== NULL_TREE
)
13693 return error_mark_node
;
13695 if (c_dialect_objc ())
13696 objc_finish_function ();
13698 gcc_assert (!defer_mark_used_calls
);
13699 defer_mark_used_calls
= true;
13701 record_key_method_defined (fndecl
);
13703 fntype
= TREE_TYPE (fndecl
);
13705 /* TREE_READONLY (fndecl) = 1;
13706 This caused &foo to be of type ptr-to-const-function
13707 which then got a warning when stored in a ptr-to-function variable. */
13709 gcc_assert (building_stmt_list_p ());
13710 /* The current function is being defined, so its DECL_INITIAL should
13711 be set, and unless there's a multiple definition, it should be
13712 error_mark_node. */
13713 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
13715 /* For a cloned function, we've already got all the code we need;
13716 there's no need to add any extra bits. */
13717 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13719 /* Make it so that `main' always returns 0 by default. */
13720 if (DECL_MAIN_P (current_function_decl
))
13721 finish_return_stmt (integer_zero_node
);
13723 if (use_eh_spec_block (current_function_decl
))
13724 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13725 (TREE_TYPE (current_function_decl
)),
13726 current_eh_spec_block
);
13729 /* If we're saving up tree structure, tie off the function now. */
13730 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
13732 finish_fname_decls ();
13734 /* If this function can't throw any exceptions, remember that. */
13735 if (!processing_template_decl
13736 && !cp_function_chain
->can_throw
13737 && !flag_non_call_exceptions
13738 && !decl_replaceable_p (fndecl
))
13739 TREE_NOTHROW (fndecl
) = 1;
13741 /* This must come after expand_function_end because cleanups might
13742 have declarations (from inline functions) that need to go into
13743 this function's blocks. */
13745 /* If the current binding level isn't the outermost binding level
13746 for this function, either there is a bug, or we have experienced
13747 syntax errors and the statement tree is malformed. */
13748 if (current_binding_level
->kind
!= sk_function_parms
)
13750 /* Make sure we have already experienced errors. */
13751 gcc_assert (errorcount
);
13753 /* Throw away the broken statement tree and extra binding
13755 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
13757 while (current_binding_level
->kind
!= sk_function_parms
)
13759 if (current_binding_level
->kind
== sk_class
)
13760 pop_nested_class ();
13762 poplevel (0, 0, 0);
13765 poplevel (1, 0, 1);
13767 /* Statements should always be full-expressions at the outermost set
13768 of curly braces for a function. */
13769 gcc_assert (stmts_are_full_exprs_p ());
13771 /* If there are no return statements in a function with auto return type,
13772 the return type is void. But if the declared type is something like
13773 auto*, this is an error. */
13774 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
13775 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
13777 if (!is_auto (current_function_auto_return_pattern
)
13778 && !current_function_returns_value
&& !current_function_returns_null
)
13780 error ("no return statements in function returning %qT",
13781 current_function_auto_return_pattern
);
13782 inform (input_location
, "only plain %<auto%> return type can be "
13783 "deduced to %<void%>");
13785 apply_deduced_return_type (fndecl
, void_type_node
);
13786 fntype
= TREE_TYPE (fndecl
);
13789 /* Save constexpr function body before it gets munged by
13790 the NRV transformation. */
13791 maybe_save_function_definition (fndecl
);
13793 /* Set up the named return value optimization, if we can. Candidate
13794 variables are selected in check_return_expr. */
13795 if (current_function_return_value
)
13797 tree r
= current_function_return_value
;
13800 if (r
!= error_mark_node
13801 /* This is only worth doing for fns that return in memory--and
13802 simpler, since we don't have to worry about promoted modes. */
13803 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
13804 /* Only allow this for variables declared in the outer scope of
13805 the function so we know that their lifetime always ends with a
13806 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13807 we were to do this optimization in tree-ssa. */
13808 && (outer
= outer_curly_brace_block (fndecl
))
13809 && chain_member (r
, BLOCK_VARS (outer
)))
13810 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
13812 current_function_return_value
= NULL_TREE
;
13815 /* Remember that we were in class scope. */
13816 if (current_class_name
)
13817 ctype
= current_class_type
;
13819 /* Must mark the RESULT_DECL as being in this function. */
13820 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13822 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13823 to the FUNCTION_DECL node itself. */
13824 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13826 /* Save away current state, if appropriate. */
13827 if (!processing_template_decl
)
13828 save_function_data (fndecl
);
13830 /* Complain if there's just no return statement. */
13831 if (warn_return_type
13832 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
13833 && !dependent_type_p (TREE_TYPE (fntype
))
13834 && !current_function_returns_value
&& !current_function_returns_null
13835 /* Don't complain if we abort or throw. */
13836 && !current_function_returns_abnormally
13837 /* Don't complain if we are declared noreturn. */
13838 && !TREE_THIS_VOLATILE (fndecl
)
13839 && !DECL_NAME (DECL_RESULT (fndecl
))
13840 && !TREE_NO_WARNING (fndecl
)
13841 /* Structor return values (if any) are set by the compiler. */
13842 && !DECL_CONSTRUCTOR_P (fndecl
)
13843 && !DECL_DESTRUCTOR_P (fndecl
)
13844 && targetm
.warn_func_return (fndecl
))
13846 warning (OPT_Wreturn_type
,
13847 "no return statement in function returning non-void");
13848 TREE_NO_WARNING (fndecl
) = 1;
13851 /* Store the end of the function, so that we get good line number
13852 info for the epilogue. */
13853 cfun
->function_end_locus
= input_location
;
13855 /* Complain about parameters that are only set, but never otherwise used. */
13856 if (warn_unused_but_set_parameter
13857 && !processing_template_decl
13858 && errorcount
== unused_but_set_errorcount
13859 && !DECL_CLONED_FUNCTION_P (fndecl
))
13863 for (decl
= DECL_ARGUMENTS (fndecl
);
13865 decl
= DECL_CHAIN (decl
))
13866 if (TREE_USED (decl
)
13867 && TREE_CODE (decl
) == PARM_DECL
13868 && !DECL_READ_P (decl
)
13869 && DECL_NAME (decl
)
13870 && !DECL_ARTIFICIAL (decl
)
13871 && !TREE_NO_WARNING (decl
)
13872 && !DECL_IN_SYSTEM_HEADER (decl
)
13873 && TREE_TYPE (decl
) != error_mark_node
13874 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13875 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
13876 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
13877 warning (OPT_Wunused_but_set_parameter
,
13878 "parameter %q+D set but not used", decl
);
13879 unused_but_set_errorcount
= errorcount
;
13882 /* Complain about locally defined typedefs that are not used in this
13884 maybe_warn_unused_local_typedefs ();
13886 /* Genericize before inlining. */
13887 if (!processing_template_decl
)
13889 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
13890 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
13891 cp_genericize (fndecl
);
13892 /* Clear out the bits we don't need. */
13893 f
->x_current_class_ptr
= NULL
;
13894 f
->x_current_class_ref
= NULL
;
13895 f
->x_eh_spec_block
= NULL
;
13896 f
->x_in_charge_parm
= NULL
;
13897 f
->x_vtt_parm
= NULL
;
13898 f
->x_return_value
= NULL
;
13899 f
->bindings
= NULL
;
13900 f
->extern_decl_map
= NULL
;
13902 /* Clear out the bits we don't need. */
13903 local_names
= NULL
;
13905 /* We're leaving the context of this function, so zap cfun. It's still in
13906 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
13908 current_function_decl
= NULL
;
13910 /* If this is an in-class inline definition, we may have to pop the
13911 bindings for the template parameters that we added in
13912 maybe_begin_member_template_processing when start_function was
13914 if (inclass_inline
)
13915 maybe_end_member_template_processing ();
13917 /* Leave the scope of the class. */
13919 pop_nested_class ();
13924 current_function_decl
= NULL_TREE
;
13926 defer_mark_used_calls
= false;
13927 if (deferred_mark_used_calls
)
13932 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
13934 vec_free (deferred_mark_used_calls
);
13940 /* Create the FUNCTION_DECL for a function definition.
13941 DECLSPECS and DECLARATOR are the parts of the declaration;
13942 they describe the return type and the name of the function,
13943 but twisted together in a fashion that parallels the syntax of C.
13945 This function creates a binding context for the function body
13946 as well as setting up the FUNCTION_DECL in current_function_decl.
13948 Returns a FUNCTION_DECL on success.
13950 If the DECLARATOR is not suitable for a function (it defines a datum
13951 instead), we return 0, which tells yyparse to report a parse error.
13953 May return void_type_node indicating that this method is actually
13954 a friend. See grokfield for more details.
13956 Came here with a `.pushlevel' .
13958 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
13959 CHANGES TO CODE IN `grokfield'. */
13962 grokmethod (cp_decl_specifier_seq
*declspecs
,
13963 const cp_declarator
*declarator
, tree attrlist
)
13965 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
13968 if (fndecl
== error_mark_node
)
13969 return error_mark_node
;
13971 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
13973 error ("invalid member function declaration");
13974 return error_mark_node
;
13978 cplus_decl_attributes (&fndecl
, attrlist
, 0);
13980 /* Pass friends other than inline friend functions back. */
13981 if (fndecl
== void_type_node
)
13984 if (DECL_IN_AGGR_P (fndecl
))
13986 if (DECL_CLASS_SCOPE_P (fndecl
))
13987 error ("%qD is already defined in class %qT", fndecl
,
13988 DECL_CONTEXT (fndecl
));
13989 return error_mark_node
;
13992 check_template_shadow (fndecl
);
13994 DECL_DECLARED_INLINE_P (fndecl
) = 1;
13995 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
13997 /* We process method specializations in finish_struct_1. */
13998 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14000 fndecl
= push_template_decl (fndecl
);
14001 if (fndecl
== error_mark_node
)
14005 if (! DECL_FRIEND_P (fndecl
))
14007 if (DECL_CHAIN (fndecl
))
14009 fndecl
= copy_node (fndecl
);
14010 TREE_CHAIN (fndecl
) = NULL_TREE
;
14014 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14016 DECL_IN_AGGR_P (fndecl
) = 1;
14021 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14022 we can lay it out later, when and if its type becomes complete. */
14025 maybe_register_incomplete_var (tree var
)
14027 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
14029 /* Keep track of variables with incomplete types. */
14030 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14031 && DECL_EXTERNAL (var
))
14033 tree inner_type
= TREE_TYPE (var
);
14035 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14036 inner_type
= TREE_TYPE (inner_type
);
14037 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14039 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14040 /* RTTI TD entries are created while defining the type_info. */
14041 || (TYPE_LANG_SPECIFIC (inner_type
)
14042 && TYPE_BEING_DEFINED (inner_type
)))
14044 incomplete_var iv
= {var
, inner_type
};
14045 vec_safe_push (incomplete_vars
, iv
);
14050 /* Called when a class type (given by TYPE) is defined. If there are
14051 any existing VAR_DECLs whose type has been completed by this
14052 declaration, update them now. */
14055 complete_vars (tree type
)
14058 incomplete_var
*iv
;
14060 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14062 if (same_type_p (type
, iv
->incomplete_type
))
14064 tree var
= iv
->decl
;
14065 tree type
= TREE_TYPE (var
);
14066 /* Complete the type of the variable. The VAR_DECL itself
14067 will be laid out in expand_expr. */
14068 complete_type (type
);
14069 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14070 /* Remove this entry from the list. */
14071 incomplete_vars
->unordered_remove (ix
);
14077 /* Check for pending declarations which may have abstract type. */
14078 complete_type_check_abstract (type
);
14081 /* If DECL is of a type which needs a cleanup, build and return an
14082 expression to perform that cleanup here. Return NULL_TREE if no
14083 cleanup need be done. */
14086 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14092 /* Assume no cleanup is required. */
14093 cleanup
= NULL_TREE
;
14095 if (error_operand_p (decl
))
14098 /* Handle "__attribute__((cleanup))". We run the cleanup function
14099 before the destructor since the destructor is what actually
14100 terminates the lifetime of the object. */
14101 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14108 /* Get the name specified by the user for the cleanup function. */
14109 id
= TREE_VALUE (TREE_VALUE (attr
));
14110 /* Look up the name to find the cleanup function to call. It is
14111 important to use lookup_name here because that is what is
14112 used in c-common.c:handle_cleanup_attribute when performing
14113 initial checks on the attribute. Note that those checks
14114 include ensuring that the function found is not an overloaded
14115 function, or an object with an overloaded call operator,
14116 etc.; we can rely on the fact that the function found is an
14117 ordinary FUNCTION_DECL. */
14118 fn
= lookup_name (id
);
14119 arg
= build_address (decl
);
14121 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14122 if (cleanup
== error_mark_node
)
14123 return error_mark_node
;
14125 /* Handle ordinary C++ destructors. */
14126 type
= TREE_TYPE (decl
);
14127 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
14129 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14130 bool has_vbases
= (TREE_CODE (type
) == RECORD_TYPE
14131 && CLASSTYPE_VBASECLASSES (type
));
14135 if (TREE_CODE (type
) == ARRAY_TYPE
)
14138 addr
= build_address (decl
);
14140 /* Optimize for space over speed here. */
14141 if (!has_vbases
|| flag_expensive_optimizations
)
14142 flags
|= LOOKUP_NONVIRTUAL
;
14144 call
= build_delete (TREE_TYPE (addr
), addr
,
14145 sfk_complete_destructor
, flags
, 0, complain
);
14146 if (call
== error_mark_node
)
14147 cleanup
= error_mark_node
;
14149 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14154 /* build_delete sets the location of the destructor call to the
14155 current location, even though the destructor is going to be
14156 called later, at the end of the current scope. This can lead to
14157 a "jumpy" behaviour for users of debuggers when they step around
14158 the end of the block. So let's unset the location of the
14159 destructor call instead. */
14160 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14161 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14166 /* When a stmt has been parsed, this function is called. */
14173 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14174 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14175 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14178 static_fn_type (tree memfntype
)
14183 if (TYPE_PTRMEMFUNC_P (memfntype
))
14184 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14185 if (POINTER_TYPE_P (memfntype
)
14186 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14187 memfntype
= TREE_TYPE (memfntype
);
14188 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14190 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14191 args
= TYPE_ARG_TYPES (memfntype
);
14192 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14193 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
));
14194 fntype
= (cp_build_type_attribute_variant
14195 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14196 fntype
= (build_exception_variant
14197 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14201 /* DECL was originally constructed as a non-static member function,
14202 but turned out to be static. Update it accordingly. */
14205 revert_static_member_fn (tree decl
)
14207 tree stype
= static_fn_type (decl
);
14208 cp_cv_quals quals
= type_memfn_quals (stype
);
14210 if (quals
!= TYPE_UNQUALIFIED
)
14211 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
);
14213 TREE_TYPE (decl
) = stype
;
14215 if (DECL_ARGUMENTS (decl
))
14216 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14217 DECL_STATIC_FUNCTION_P (decl
) = 1;
14220 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14221 one of the language-independent trees. */
14223 enum cp_tree_node_structure_enum
14224 cp_tree_node_structure (union lang_tree_node
* t
)
14226 switch (TREE_CODE (&t
->generic
))
14228 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14229 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14230 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14231 case OVERLOAD
: return TS_CP_OVERLOAD
;
14232 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14233 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14234 case BASELINK
: return TS_CP_BASELINK
;
14235 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14236 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14237 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14238 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14239 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14240 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14241 default: return TS_CP_GENERIC
;
14245 /* Build the void_list_node (void_type_node having been created). */
14247 build_void_list_node (void)
14249 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14254 cp_missing_noreturn_ok_p (tree decl
)
14256 /* A missing noreturn is ok for the `main' function. */
14257 return DECL_MAIN_P (decl
);
14260 /* Return the COMDAT group into which DECL should be placed. */
14263 cxx_comdat_group (tree decl
)
14267 /* Virtual tables, construction virtual tables, and virtual table
14268 tables all go in a single COMDAT group, named after the primary
14270 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VTABLE_OR_VTT_P (decl
))
14271 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
14272 /* For all other DECLs, the COMDAT group is the mangled name of the
14273 declaration itself. */
14276 while (DECL_THUNK_P (decl
))
14278 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14279 into the same section as the target function. In that case
14280 we must return target's name. */
14281 tree target
= THUNK_TARGET (decl
);
14282 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14283 && DECL_SECTION_NAME (target
) != NULL
14284 && DECL_ONE_ONLY (target
))
14289 name
= DECL_ASSEMBLER_NAME (decl
);
14295 #include "gt-cp-decl.h"