1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2013 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
36 #include "tree-iterator.h"
37 #include "tree-inline.h"
44 #include "c-family/c-common.h"
45 #include "c-family/c-objc.h"
46 #include "c-family/c-pragma.h"
47 #include "c-family/c-target.h"
48 #include "c-family/c-ubsan.h"
49 #include "diagnostic.h"
53 #include "pointer-set.h"
54 #include "splay-tree.h"
59 /* Possible cases of bad specifiers type used by bad_specifiers. */
61 BSP_VAR
, /* variable */
62 BSP_PARM
, /* parameter */
67 static tree
grokparms (tree parmlist
, tree
*);
68 static const char *redeclaration_error_message (tree
, tree
);
70 static int decl_jump_unsafe (tree
);
71 static void require_complete_types_for_parms (tree
);
72 static int ambi_op_p (enum tree_code
);
73 static int unary_op_p (enum tree_code
);
74 static void push_local_name (tree
);
75 static tree
grok_reference_init (tree
, tree
, tree
, int);
76 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
78 static int check_static_variable_definition (tree
, tree
);
79 static void record_unknown_type (tree
, const char *);
80 static tree
builtin_function_1 (tree
, tree
, bool);
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
, int);
113 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
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 // See through references for improved -Wunused-variable (PR 38958).
628 tree type
= non_reference (TREE_TYPE (decl
));
630 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
631 && ! DECL_IN_SYSTEM_HEADER (decl
)
632 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
633 && type
!= error_mark_node
634 && (!CLASS_TYPE_P (type
)
635 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
636 || lookup_attribute ("warn_unused",
637 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
639 if (! TREE_USED (decl
))
640 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
641 else if (DECL_CONTEXT (decl
) == current_function_decl
642 // For -Wunused-but-set-variable leave references alone.
643 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
644 && errorcount
== unused_but_set_errorcount
)
646 warning (OPT_Wunused_but_set_variable
,
647 "variable %q+D set but not used", decl
);
648 unused_but_set_errorcount
= errorcount
;
653 /* Remove declarations for all the DECLs in this level. */
654 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
656 if (leaving_for_scope
&& VAR_P (link
)
657 /* It's hard to make this ARM compatibility hack play nicely with
658 lambdas, and it really isn't necessary in C++11 mode. */
659 && cxx_dialect
< cxx11
662 tree name
= DECL_NAME (link
);
666 ob
= outer_binding (name
,
667 IDENTIFIER_BINDING (name
),
670 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
672 ns_binding
= NULL_TREE
;
674 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
675 /* We have something like:
680 and we are leaving the `for' scope. There's no reason to
681 keep the binding of the inner `i' in this case. */
682 pop_binding (name
, link
);
683 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
684 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
685 /* Here, we have something like:
693 We must pop the for-scope binding so we know what's a
694 type and what isn't. */
695 pop_binding (name
, link
);
698 /* Mark this VAR_DECL as dead so that we can tell we left it
699 there only for backward compatibility. */
700 DECL_DEAD_FOR_LOCAL (link
) = 1;
702 /* Keep track of what should have happened when we
703 popped the binding. */
706 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
707 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
710 /* Add it to the list of dead variables in the next
711 outermost binding to that we can remove these when we
712 leave that binding. */
714 current_binding_level
->level_chain
->dead_vars_from_for
,
717 /* Although we don't pop the cxx_binding, we do clear
718 its SCOPE since the scope is going away now. */
719 IDENTIFIER_BINDING (name
)->scope
720 = current_binding_level
->level_chain
;
727 /* Remove the binding. */
730 if (TREE_CODE (decl
) == TREE_LIST
)
731 decl
= TREE_VALUE (decl
);
734 if (TREE_CODE (name
) == OVERLOAD
)
735 name
= OVL_FUNCTION (name
);
737 gcc_assert (DECL_P (name
));
738 pop_binding (DECL_NAME (name
), decl
);
742 /* Remove declarations for any `for' variables from inner scopes
743 that we kept around. */
744 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
746 pop_binding (DECL_NAME (decl
), decl
);
748 /* Restore the IDENTIFIER_TYPE_VALUEs. */
749 for (link
= current_binding_level
->type_shadowed
;
750 link
; link
= TREE_CHAIN (link
))
751 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
753 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
754 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
756 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
758 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
759 list if a `using' declaration put them there. The debugging
760 back ends won't understand OVERLOAD, so we remove them here.
761 Because the BLOCK_VARS are (temporarily) shared with
762 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
763 popped all the bindings. */
768 for (d
= &BLOCK_VARS (block
); *d
; )
770 if (TREE_CODE (*d
) == TREE_LIST
)
771 *d
= TREE_CHAIN (*d
);
773 d
= &DECL_CHAIN (*d
);
777 /* If the level being exited is the top level of a function,
778 check over all the labels. */
781 /* Since this is the top level block of a function, the vars are
782 the function's parameters. Don't leave them in the BLOCK
783 because they are found in the FUNCTION_DECL instead. */
784 BLOCK_VARS (block
) = 0;
788 kind
= current_binding_level
->kind
;
789 if (kind
== sk_cleanup
)
793 /* If this is a temporary binding created for a cleanup, then we'll
794 have pushed a statement list level. Pop that, create a new
795 BIND_EXPR for the block, and insert it into the stream. */
796 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
797 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
804 /* The current function is being defined, so its DECL_INITIAL
805 should be error_mark_node. */
806 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
807 DECL_INITIAL (current_function_decl
) = block
;
810 current_binding_level
->blocks
811 = block_chainon (current_binding_level
->blocks
, block
);
813 /* If we did not make a block for the level just exited,
814 any blocks made for inner levels
815 (since they cannot be recorded as subblocks in that level)
816 must be carried forward so they will later become subblocks
817 of something else. */
819 current_binding_level
->blocks
820 = block_chainon (current_binding_level
->blocks
, subblocks
);
822 /* Each and every BLOCK node created here in `poplevel' is important
823 (e.g. for proper debugging information) so if we created one
824 earlier, mark it as "used". */
826 TREE_USED (block
) = 1;
828 /* All temporary bindings created for cleanups are popped silently. */
829 if (kind
== sk_cleanup
)
832 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
836 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
837 itself, calling F for each. The DATA is passed to F as well. */
840 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
843 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
845 result
|= (*f
) (name_space
, data
);
847 for (; current
; current
= DECL_CHAIN (current
))
848 result
|= walk_namespaces_r (current
, f
, data
);
853 /* Walk all the namespaces, calling F for each. The DATA is passed to
857 walk_namespaces (walk_namespaces_fn f
, void* data
)
859 return walk_namespaces_r (global_namespace
, f
, data
);
862 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
863 DATA is non-NULL, this is the last time we will call
864 wrapup_global_declarations for this NAMESPACE. */
867 wrapup_globals_for_namespace (tree name_space
, void* data
)
869 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
870 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
871 tree
*vec
= statics
->address ();
872 int len
= statics
->length ();
873 int last_time
= (data
!= 0);
877 check_global_declarations (vec
, len
);
878 emit_debug_global_declarations (vec
, len
);
882 /* Write out any globals that need to be output. */
883 return wrapup_global_declarations (vec
, len
);
887 /* In C++, you don't have to write `struct S' to refer to `S'; you
888 can just use `S'. We accomplish this by creating a TYPE_DECL as
889 if the user had written `typedef struct S S'. Create and return
890 the TYPE_DECL for TYPE. */
893 create_implicit_typedef (tree name
, tree type
)
897 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
898 DECL_ARTIFICIAL (decl
) = 1;
899 /* There are other implicit type declarations, like the one *within*
900 a class that allows you to write `S::S'. We must distinguish
902 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
903 TYPE_NAME (type
) = decl
;
904 TYPE_STUB_DECL (type
) = decl
;
909 /* Remember a local name for name-mangling purposes. */
912 push_local_name (tree decl
)
917 timevar_start (TV_NAME_LOOKUP
);
919 name
= DECL_NAME (decl
);
921 nelts
= vec_safe_length (local_names
);
922 for (i
= 0; i
< nelts
; i
++)
924 t
= (*local_names
)[i
];
925 if (DECL_NAME (t
) == name
)
927 if (!DECL_LANG_SPECIFIC (decl
))
928 retrofit_lang_decl (decl
);
929 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
930 if (DECL_DISCRIMINATOR_SET_P (t
))
931 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
933 DECL_DISCRIMINATOR (decl
) = 1;
935 (*local_names
)[i
] = decl
;
936 timevar_stop (TV_NAME_LOOKUP
);
941 vec_safe_push (local_names
, decl
);
942 timevar_stop (TV_NAME_LOOKUP
);
945 /* Subroutine of duplicate_decls: return truthvalue of whether
946 or not types of these decls match.
948 For C++, we must compare the parameter list so that `int' can match
949 `int&' in a parameter position, but `int&' is not confused with
953 decls_match (tree newdecl
, tree olddecl
)
957 if (newdecl
== olddecl
)
960 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
961 /* If the two DECLs are not even the same kind of thing, we're not
962 interested in their types. */
965 gcc_assert (DECL_P (newdecl
));
967 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
969 tree f1
= TREE_TYPE (newdecl
);
970 tree f2
= TREE_TYPE (olddecl
);
971 tree p1
= TYPE_ARG_TYPES (f1
);
972 tree p2
= TYPE_ARG_TYPES (f2
);
975 /* Specializations of different templates are different functions
976 even if they have the same type. */
977 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
978 ? DECL_TI_TEMPLATE (newdecl
)
980 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
981 ? DECL_TI_TEMPLATE (olddecl
)
986 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
987 && ! (DECL_EXTERN_C_P (newdecl
)
988 && DECL_EXTERN_C_P (olddecl
)))
991 /* A new declaration doesn't match a built-in one unless it
992 is also extern "C". */
993 if (DECL_IS_BUILTIN (olddecl
)
994 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
997 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1000 /* A declaration with deduced return type should use its pre-deduction
1001 type for declaration matching. */
1002 r2
= fndecl_declared_return_type (olddecl
);
1004 if (same_type_p (TREE_TYPE (f1
), r2
))
1006 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1007 && (DECL_BUILT_IN (olddecl
)
1008 #ifndef NO_IMPLICIT_EXTERN_C
1009 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1010 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1014 types_match
= self_promoting_args_p (p1
);
1015 if (p1
== void_list_node
)
1016 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1018 #ifndef NO_IMPLICIT_EXTERN_C
1019 else if (!prototype_p (f1
)
1020 && (DECL_EXTERN_C_P (olddecl
)
1021 && DECL_IN_SYSTEM_HEADER (olddecl
)
1022 && !DECL_CLASS_SCOPE_P (olddecl
))
1023 && (DECL_EXTERN_C_P (newdecl
)
1024 && DECL_IN_SYSTEM_HEADER (newdecl
)
1025 && !DECL_CLASS_SCOPE_P (newdecl
)))
1027 types_match
= self_promoting_args_p (p2
);
1028 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1034 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1035 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1036 || comp_type_attributes (TREE_TYPE (newdecl
),
1037 TREE_TYPE (olddecl
)) != 0);
1042 /* The decls dont match if they correspond to two different versions
1043 of the same function. Disallow extern "C" functions to be
1044 versions for now. */
1046 && !DECL_EXTERN_C_P (newdecl
)
1047 && !DECL_EXTERN_C_P (olddecl
)
1048 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1050 /* Mark functions as versions if necessary. Modify the mangled decl
1051 name if necessary. */
1052 if (DECL_FUNCTION_VERSIONED (newdecl
)
1053 && DECL_FUNCTION_VERSIONED (olddecl
))
1055 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1057 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1058 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1059 mangle_decl (newdecl
);
1061 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1063 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1064 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1065 mangle_decl (olddecl
);
1067 record_function_versions (olddecl
, newdecl
);
1071 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1073 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1074 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1077 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1078 DECL_TEMPLATE_PARMS (olddecl
)))
1081 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1082 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1083 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1085 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1086 DECL_TEMPLATE_RESULT (newdecl
));
1090 /* Need to check scope for variable declaration (VAR_DECL).
1091 For typedef (TYPE_DECL), scope is ignored. */
1093 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1095 Two declarations for an object with C language linkage
1096 with the same name (ignoring the namespace that qualify
1097 it) that appear in different namespace scopes refer to
1099 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1102 if (TREE_TYPE (newdecl
) == error_mark_node
)
1103 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1104 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1105 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1106 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1109 types_match
= comptypes (TREE_TYPE (newdecl
),
1110 TREE_TYPE (olddecl
),
1111 COMPARE_REDECLARATION
);
1117 /* If NEWDECL is `static' and an `extern' was seen previously,
1118 warn about it. OLDDECL is the previous declaration.
1120 Note that this does not apply to the C++ case of declaring
1121 a variable `extern const' and then later `const'.
1123 Don't complain about built-in functions, since they are beyond
1124 the user's control. */
1127 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1129 if (TREE_CODE (newdecl
) == TYPE_DECL
1130 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1131 || TREE_CODE (newdecl
) == CONST_DECL
1132 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1135 /* Don't get confused by static member functions; that's a different
1137 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1138 && DECL_STATIC_FUNCTION_P (newdecl
))
1141 /* If the old declaration was `static', or the new one isn't, then
1142 everything is OK. */
1143 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1146 /* It's OK to declare a builtin function as `static'. */
1147 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1148 && DECL_ARTIFICIAL (olddecl
))
1151 if (permerror (input_location
,
1152 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1153 inform (input_location
, "previous declaration of %q+D", olddecl
);
1156 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1157 function templates. If their exception specifications do not
1158 match, issue a diagnostic. */
1161 check_redeclaration_exception_specification (tree new_decl
,
1166 tree new_exceptions
;
1167 tree old_exceptions
;
1169 new_type
= TREE_TYPE (new_decl
);
1170 new_exceptions
= TYPE_RAISES_EXCEPTIONS (new_type
);
1171 old_type
= TREE_TYPE (old_decl
);
1172 old_exceptions
= TYPE_RAISES_EXCEPTIONS (old_type
);
1176 If any declaration of a function has an exception-specification,
1177 all declarations, including the definition and an explicit
1178 specialization, of that function shall have an
1179 exception-specification with the same set of type-ids. */
1180 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1181 && ! DECL_IS_BUILTIN (old_decl
)
1183 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1185 error ("declaration of %qF has a different exception specifier",
1187 error ("from previous declaration %q+F", old_decl
);
1191 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1192 Otherwise issue diagnostics. */
1195 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1197 old_decl
= STRIP_TEMPLATE (old_decl
);
1198 new_decl
= STRIP_TEMPLATE (new_decl
);
1199 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1200 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1202 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1203 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1205 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1207 if (DECL_BUILT_IN (old_decl
))
1209 /* Hide a built-in declaration. */
1210 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1211 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1214 /* 7.1.5 [dcl.constexpr]
1215 Note: An explicit specialization can differ from the template
1216 declaration with respect to the constexpr specifier. */
1217 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1218 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1221 error ("redeclaration %qD differs in %<constexpr%>", new_decl
);
1222 error ("from previous declaration %q+D", old_decl
);
1228 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1229 && lookup_attribute ("gnu_inline", \
1230 DECL_ATTRIBUTES (fn)))
1232 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1233 If the redeclaration is invalid, a diagnostic is issued, and the
1234 error_mark_node is returned. Otherwise, OLDDECL is returned.
1236 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1239 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1242 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1244 unsigned olddecl_uid
= DECL_UID (olddecl
);
1245 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1246 int new_defines_function
= 0;
1247 tree new_template_info
;
1249 if (newdecl
== olddecl
)
1252 types_match
= decls_match (newdecl
, olddecl
);
1254 /* If either the type of the new decl or the type of the old decl is an
1255 error_mark_node, then that implies that we have already issued an
1256 error (earlier) for some bogus type specification, and in that case,
1257 it is rather pointless to harass the user with yet more error message
1258 about the same declaration, so just pretend the types match here. */
1259 if (TREE_TYPE (newdecl
) == error_mark_node
1260 || TREE_TYPE (olddecl
) == error_mark_node
)
1261 return error_mark_node
;
1263 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1264 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1266 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1267 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1268 && check_raw_literal_operator (olddecl
))
1269 error ("literal operator template %q+D conflicts with"
1270 " raw literal operator %qD", newdecl
, olddecl
);
1271 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1272 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1273 && check_raw_literal_operator (newdecl
))
1274 error ("raw literal operator %q+D conflicts with"
1275 " literal operator template %qD", newdecl
, olddecl
);
1278 if (DECL_P (olddecl
)
1279 && TREE_CODE (newdecl
) == FUNCTION_DECL
1280 && TREE_CODE (olddecl
) == FUNCTION_DECL
1281 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1283 if (DECL_DECLARED_INLINE_P (newdecl
)
1284 && DECL_UNINLINABLE (newdecl
)
1285 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1286 /* Already warned elsewhere. */;
1287 else if (DECL_DECLARED_INLINE_P (olddecl
)
1288 && DECL_UNINLINABLE (olddecl
)
1289 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1290 /* Already warned. */;
1291 else if (DECL_DECLARED_INLINE_P (newdecl
)
1292 && DECL_UNINLINABLE (olddecl
)
1293 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1295 if (warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1297 inform (input_location
, "previous declaration of %q+D "
1298 "with attribute noinline", olddecl
);
1300 else if (DECL_DECLARED_INLINE_P (olddecl
)
1301 && DECL_UNINLINABLE (newdecl
)
1302 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1304 if (warning (OPT_Wattributes
, "function %q+D redeclared with "
1305 "attribute noinline", newdecl
))
1306 inform (input_location
, "previous declaration of %q+D was inline",
1311 /* Check for redeclaration and other discrepancies. */
1312 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1313 && DECL_ARTIFICIAL (olddecl
))
1315 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1316 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1318 /* Avoid warnings redeclaring built-ins which have not been
1319 explicitly declared. */
1320 if (DECL_ANTICIPATED (olddecl
))
1323 /* If you declare a built-in or predefined function name as static,
1324 the old definition is overridden, but optionally warn this was a
1325 bad choice of name. */
1326 if (! TREE_PUBLIC (newdecl
))
1328 warning (OPT_Wshadow
,
1329 DECL_BUILT_IN (olddecl
)
1330 ? G_("shadowing built-in function %q#D")
1331 : G_("shadowing library function %q#D"), olddecl
);
1332 /* Discard the old built-in function. */
1335 /* If the built-in is not ansi, then programs can override
1336 it even globally without an error. */
1337 else if (! DECL_BUILT_IN (olddecl
))
1338 warning (0, "library function %q#D redeclared as non-function %q#D",
1342 error ("declaration of %q#D", newdecl
);
1343 error ("conflicts with built-in declaration %q#D",
1348 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1350 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1351 error_at (DECL_SOURCE_LOCATION (newdecl
),
1352 "redeclaration of %<pragma omp declare reduction%>");
1353 error_at (DECL_SOURCE_LOCATION (olddecl
),
1354 "previous %<pragma omp declare reduction%> declaration");
1355 return error_mark_node
;
1357 else if (!types_match
)
1359 /* Avoid warnings redeclaring built-ins which have not been
1360 explicitly declared. */
1361 if (DECL_ANTICIPATED (olddecl
))
1363 /* Deal with fileptr_type_node. FILE type is not known
1364 at the time we create the builtins. */
1367 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1368 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1370 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1373 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1375 tree t
= TREE_VALUE (t1
);
1378 && TYPE_NAME (TREE_TYPE (t
))
1379 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1380 == get_identifier ("FILE")
1381 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1383 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1385 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1386 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1387 types_match
= decls_match (newdecl
, olddecl
);
1389 return duplicate_decls (newdecl
, olddecl
,
1391 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1394 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1397 else if ((DECL_EXTERN_C_P (newdecl
)
1398 && DECL_EXTERN_C_P (olddecl
))
1399 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1400 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1402 /* A near match; override the builtin. */
1404 if (TREE_PUBLIC (newdecl
))
1406 warning (0, "new declaration %q#D", newdecl
);
1407 warning (0, "ambiguates built-in declaration %q#D",
1411 warning (OPT_Wshadow
,
1412 DECL_BUILT_IN (olddecl
)
1413 ? G_("shadowing built-in function %q#D")
1414 : G_("shadowing library function %q#D"), olddecl
);
1417 /* Discard the old built-in function. */
1420 /* Replace the old RTL to avoid problems with inlining. */
1421 COPY_DECL_RTL (newdecl
, olddecl
);
1423 /* Even if the types match, prefer the new declarations type for
1424 built-ins which have not been explicitly declared, for
1425 exception lists, etc... */
1426 else if (DECL_IS_BUILTIN (olddecl
))
1428 tree type
= TREE_TYPE (newdecl
);
1429 tree attribs
= (*targetm
.merge_type_attributes
)
1430 (TREE_TYPE (olddecl
), type
);
1432 type
= cp_build_type_attribute_variant (type
, attribs
);
1433 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1436 /* If a function is explicitly declared "throw ()", propagate that to
1437 the corresponding builtin. */
1438 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1439 && DECL_ANTICIPATED (olddecl
)
1440 && TREE_NOTHROW (newdecl
)
1441 && !TREE_NOTHROW (olddecl
))
1443 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1444 tree tmpdecl
= builtin_decl_explicit (fncode
);
1445 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1446 TREE_NOTHROW (tmpdecl
) = 1;
1449 /* Whether or not the builtin can throw exceptions has no
1450 bearing on this declarator. */
1451 TREE_NOTHROW (olddecl
) = 0;
1453 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1455 /* If a builtin function is redeclared as `static', merge
1456 the declarations, but make the original one static. */
1457 DECL_THIS_STATIC (olddecl
) = 1;
1458 TREE_PUBLIC (olddecl
) = 0;
1460 /* Make the old declaration consistent with the new one so
1461 that all remnants of the builtin-ness of this function
1462 will be banished. */
1463 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1464 COPY_DECL_RTL (newdecl
, olddecl
);
1467 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1469 /* C++ Standard, 3.3, clause 4:
1470 "[Note: a namespace name or a class template name must be unique
1471 in its declarative region (7.3.2, clause 14). ]" */
1472 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1473 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1474 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1475 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1476 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1477 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1479 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1480 && TREE_CODE (newdecl
) != TYPE_DECL
)
1481 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1482 && TREE_CODE (olddecl
) != TYPE_DECL
))
1484 /* We do nothing special here, because C++ does such nasty
1485 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1486 get shadowed, and know that if we need to find a TYPE_DECL
1487 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1488 slot of the identifier. */
1492 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1493 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1494 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1495 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1499 error ("%q#D redeclared as different kind of symbol", newdecl
);
1500 if (TREE_CODE (olddecl
) == TREE_LIST
)
1501 olddecl
= TREE_VALUE (olddecl
);
1502 inform (input_location
, "previous declaration of %q+#D", olddecl
);
1504 return error_mark_node
;
1506 else if (!types_match
)
1508 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1509 /* These are certainly not duplicate declarations; they're
1510 from different scopes. */
1513 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1515 /* The name of a class template may not be declared to refer to
1516 any other template, class, function, object, namespace, value,
1517 or type in the same scope. */
1518 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1519 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1521 error ("declaration of template %q#D", newdecl
);
1522 error ("conflicts with previous declaration %q+#D", olddecl
);
1523 return error_mark_node
;
1525 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1526 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1527 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1528 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1529 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1530 DECL_TEMPLATE_PARMS (olddecl
))
1531 /* Template functions can be disambiguated by
1533 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1534 TREE_TYPE (TREE_TYPE (olddecl
))))
1536 error ("new declaration %q#D", newdecl
);
1537 error ("ambiguates old declaration %q+#D", olddecl
);
1541 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1543 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1545 error ("declaration of C function %q#D conflicts with",
1547 error ("previous declaration %q+#D here", olddecl
);
1550 /* For function versions, params and types match, but they
1551 are not ambiguous. */
1552 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1553 && !DECL_FUNCTION_VERSIONED (olddecl
))
1554 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1555 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1557 error ("new declaration %q#D", newdecl
);
1558 error ("ambiguates old declaration %q+#D", olddecl
);
1559 return error_mark_node
;
1566 error ("conflicting declaration %q#D", newdecl
);
1567 inform (input_location
,
1568 "%q+D has a previous declaration as %q#D", olddecl
, olddecl
);
1569 return error_mark_node
;
1572 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1573 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1574 && (!DECL_TEMPLATE_INFO (newdecl
)
1575 || (DECL_TI_TEMPLATE (newdecl
)
1576 != DECL_TI_TEMPLATE (olddecl
))))
1577 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1578 && (!DECL_TEMPLATE_INFO (olddecl
)
1579 || (DECL_TI_TEMPLATE (olddecl
)
1580 != DECL_TI_TEMPLATE (newdecl
))))))
1581 /* It's OK to have a template specialization and a non-template
1582 with the same type, or to have specializations of two
1583 different templates with the same type. Note that if one is a
1584 specialization, and the other is an instantiation of the same
1585 template, that we do not exit at this point. That situation
1586 can occur if we instantiate a template class, and then
1587 specialize one of its methods. This situation is valid, but
1588 the declarations must be merged in the usual way. */
1590 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1591 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1592 && !DECL_USE_TEMPLATE (newdecl
))
1593 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1594 && !DECL_USE_TEMPLATE (olddecl
))))
1595 /* One of the declarations is a template instantiation, and the
1596 other is not a template at all. That's OK. */
1598 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1600 /* In [namespace.alias] we have:
1602 In a declarative region, a namespace-alias-definition can be
1603 used to redefine a namespace-alias declared in that declarative
1604 region to refer only to the namespace to which it already
1607 Therefore, if we encounter a second alias directive for the same
1608 alias, we can just ignore the second directive. */
1609 if (DECL_NAMESPACE_ALIAS (newdecl
)
1610 && (DECL_NAMESPACE_ALIAS (newdecl
)
1611 == DECL_NAMESPACE_ALIAS (olddecl
)))
1613 /* [namespace.alias]
1615 A namespace-name or namespace-alias shall not be declared as
1616 the name of any other entity in the same declarative region.
1617 A namespace-name defined at global scope shall not be
1618 declared as the name of any other entity in any global scope
1620 error ("declaration of namespace %qD conflicts with", newdecl
);
1621 error ("previous declaration of namespace %q+D here", olddecl
);
1622 return error_mark_node
;
1626 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1629 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1630 if (DECL_NAME (olddecl
) != NULL_TREE
)
1631 inform (input_location
,
1632 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1633 ? G_("%q+#D previously defined here")
1634 : G_("%q+#D previously declared here"), olddecl
);
1635 return error_mark_node
;
1637 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1638 && DECL_INITIAL (olddecl
) != NULL_TREE
1639 && !prototype_p (TREE_TYPE (olddecl
))
1640 && prototype_p (TREE_TYPE (newdecl
)))
1642 /* Prototype decl follows defn w/o prototype. */
1643 warning_at (input_location
, 0, "prototype for %q+#D", newdecl
);
1644 warning_at (DECL_SOURCE_LOCATION (olddecl
), 0,
1645 "follows non-prototype definition here");
1647 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1648 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1651 If two declarations of the same function or object
1652 specify different linkage-specifications ..., the program
1653 is ill-formed.... Except for functions with C++ linkage,
1654 a function declaration without a linkage specification
1655 shall not precede the first linkage specification for
1656 that function. A function can be declared without a
1657 linkage specification after an explicit linkage
1658 specification has been seen; the linkage explicitly
1659 specified in the earlier declaration is not affected by
1660 such a function declaration.
1662 DR 563 raises the question why the restrictions on
1663 functions should not also apply to objects. Older
1664 versions of G++ silently ignore the linkage-specification
1672 which is clearly wrong. Therefore, we now treat objects
1674 if (current_lang_depth () == 0)
1676 /* There is no explicit linkage-specification, so we use
1677 the linkage from the previous declaration. */
1678 if (!DECL_LANG_SPECIFIC (newdecl
))
1679 retrofit_lang_decl (newdecl
);
1680 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1684 error ("previous declaration of %q+#D with %qL linkage",
1685 olddecl
, DECL_LANGUAGE (olddecl
));
1686 error ("conflicts with new declaration with %qL linkage",
1687 DECL_LANGUAGE (newdecl
));
1691 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1693 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1695 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1696 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1699 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1700 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1702 for (; t1
&& t1
!= void_list_node
;
1703 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1704 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1706 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1709 permerror (input_location
, "default argument given for parameter %d of %q#D",
1711 permerror (input_location
, "after previous specification in %q+#D", olddecl
);
1715 error ("default argument given for parameter %d of %q#D",
1717 error ("after previous specification in %q+#D",
1724 /* Do not merge an implicit typedef with an explicit one. In:
1728 typedef class A A __attribute__ ((foo));
1730 the attribute should apply only to the typedef. */
1731 if (TREE_CODE (olddecl
) == TYPE_DECL
1732 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1733 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1736 /* If new decl is `static' and an `extern' was seen previously,
1738 warn_extern_redeclared_static (newdecl
, olddecl
);
1740 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1741 return error_mark_node
;
1743 /* We have committed to returning 1 at this point. */
1744 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1746 /* Now that functions must hold information normally held
1747 by field decls, there is extra work to do so that
1748 declaration information does not get destroyed during
1750 if (DECL_VINDEX (olddecl
))
1751 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1752 if (DECL_CONTEXT (olddecl
))
1753 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1754 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1755 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1756 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1757 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1758 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1759 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1760 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1761 SET_OVERLOADED_OPERATOR_CODE
1762 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1763 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1765 /* Optionally warn about more than one declaration for the same
1766 name, but don't warn about a function declaration followed by a
1768 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1769 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1770 /* Don't warn about extern decl followed by definition. */
1771 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1772 /* Don't warn about friends, let add_friend take care of it. */
1773 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1774 /* Don't warn about declaration followed by specialization. */
1775 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1776 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1778 if (warning (OPT_Wredundant_decls
,
1779 "redundant redeclaration of %qD in same scope",
1781 inform (input_location
, "previous declaration of %q+D", olddecl
);
1784 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1785 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1787 if (DECL_DELETED_FN (newdecl
))
1789 error ("deleted definition of %qD", newdecl
);
1790 error ("after previous declaration %q+D", olddecl
);
1792 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1796 /* Deal with C++: must preserve virtual function table size. */
1797 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1799 tree newtype
= TREE_TYPE (newdecl
);
1800 tree oldtype
= TREE_TYPE (olddecl
);
1802 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1803 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1804 CLASSTYPE_FRIEND_CLASSES (newtype
)
1805 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1807 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1810 /* Copy all the DECL_... slots specified in the new decl
1811 except for any that we copy here from the old type. */
1812 DECL_ATTRIBUTES (newdecl
)
1813 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1815 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1819 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1820 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1821 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1822 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1823 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1824 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1826 DECL_ATTRIBUTES (old_result
)
1827 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1829 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1831 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1832 && DECL_INITIAL (new_result
))
1834 if (DECL_INITIAL (old_result
))
1835 DECL_UNINLINABLE (old_result
) = 1;
1837 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1838 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1839 DECL_NOT_REALLY_EXTERN (old_result
)
1840 = DECL_NOT_REALLY_EXTERN (new_result
);
1841 DECL_INTERFACE_KNOWN (old_result
)
1842 = DECL_INTERFACE_KNOWN (new_result
);
1843 DECL_DECLARED_INLINE_P (old_result
)
1844 = DECL_DECLARED_INLINE_P (new_result
);
1845 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1846 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1851 DECL_DECLARED_INLINE_P (old_result
)
1852 |= DECL_DECLARED_INLINE_P (new_result
);
1853 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1854 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1855 check_redeclaration_exception_specification (newdecl
, olddecl
);
1859 /* If the new declaration is a definition, update the file and
1860 line information on the declaration, and also make
1861 the old declaration the same definition. */
1862 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1864 DECL_SOURCE_LOCATION (olddecl
)
1865 = DECL_SOURCE_LOCATION (old_result
)
1866 = DECL_SOURCE_LOCATION (newdecl
);
1867 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1868 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1871 DECL_ARGUMENTS (old_result
)
1872 = DECL_ARGUMENTS (new_result
);
1873 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1874 parm
= DECL_CHAIN (parm
))
1875 DECL_CONTEXT (parm
) = old_result
;
1884 /* Automatically handles default parameters. */
1885 tree oldtype
= TREE_TYPE (olddecl
);
1888 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1889 maybe_instantiate_noexcept (olddecl
);
1891 /* Merge the data types specified in the two decls. */
1892 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1894 /* If merge_types produces a non-typedef type, just use the old type. */
1895 if (TREE_CODE (newdecl
) == TYPE_DECL
1896 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1899 if (VAR_P (newdecl
))
1901 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1902 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1903 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1904 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1905 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1906 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1908 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1909 if (DECL_LANG_SPECIFIC (olddecl
)
1910 && CP_DECL_THREADPRIVATE_P (olddecl
))
1912 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1913 if (!DECL_LANG_SPECIFIC (newdecl
))
1914 retrofit_lang_decl (newdecl
);
1916 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1917 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1921 /* Do this after calling `merge_types' so that default
1922 parameters don't confuse us. */
1923 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1924 check_redeclaration_exception_specification (newdecl
, olddecl
);
1925 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1927 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1928 check_default_args (newdecl
);
1930 /* Lay the type out, unless already done. */
1931 if (! same_type_p (newtype
, oldtype
)
1932 && TREE_TYPE (newdecl
) != error_mark_node
1933 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1934 layout_type (TREE_TYPE (newdecl
));
1936 if ((VAR_P (newdecl
)
1937 || TREE_CODE (newdecl
) == PARM_DECL
1938 || TREE_CODE (newdecl
) == RESULT_DECL
1939 || TREE_CODE (newdecl
) == FIELD_DECL
1940 || TREE_CODE (newdecl
) == TYPE_DECL
)
1941 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1942 layout_decl (newdecl
, 0);
1944 /* Merge the type qualifiers. */
1945 if (TREE_READONLY (newdecl
))
1946 TREE_READONLY (olddecl
) = 1;
1947 if (TREE_THIS_VOLATILE (newdecl
))
1948 TREE_THIS_VOLATILE (olddecl
) = 1;
1949 if (TREE_NOTHROW (newdecl
))
1950 TREE_NOTHROW (olddecl
) = 1;
1952 /* Merge deprecatedness. */
1953 if (TREE_DEPRECATED (newdecl
))
1954 TREE_DEPRECATED (olddecl
) = 1;
1956 /* Preserve function specific target and optimization options */
1957 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1959 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
1960 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
1961 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
1962 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
1964 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
1965 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
1966 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
1967 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
1970 /* Merge the initialization information. */
1971 if (DECL_INITIAL (newdecl
) == NULL_TREE
1972 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1974 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1975 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1976 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1978 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1979 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1983 /* Merge the section attribute.
1984 We want to issue an error if the sections conflict but that must be
1985 done later in decl_attributes since we are called before attributes
1987 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1988 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1990 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1992 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1993 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1994 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1995 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1996 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1997 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1998 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
1999 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2000 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2001 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2002 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2003 /* Keep the old RTL. */
2004 COPY_DECL_RTL (olddecl
, newdecl
);
2006 else if (VAR_P (newdecl
)
2007 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2009 /* Keep the old RTL. We cannot keep the old RTL if the old
2010 declaration was for an incomplete object and the new
2011 declaration is not since many attributes of the RTL will
2013 COPY_DECL_RTL (olddecl
, newdecl
);
2016 /* If cannot merge, then use the new type and qualifiers,
2017 and don't preserve the old rtl. */
2020 /* Clean out any memory we had of the old declaration. */
2021 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2023 TREE_VALUE (oldstatic
) = error_mark_node
;
2025 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2026 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2027 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2028 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2031 /* Merge the storage class information. */
2032 merge_weak (newdecl
, olddecl
);
2034 if (DECL_ONE_ONLY (olddecl
))
2035 DECL_COMDAT_GROUP (newdecl
) = DECL_COMDAT_GROUP (olddecl
);
2037 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2038 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2039 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2040 if (! DECL_EXTERNAL (olddecl
))
2041 DECL_EXTERNAL (newdecl
) = 0;
2043 new_template_info
= NULL_TREE
;
2044 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2046 bool new_redefines_gnu_inline
= false;
2048 if (new_defines_function
2049 && ((DECL_INTERFACE_KNOWN (olddecl
)
2050 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2051 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2052 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2053 == FUNCTION_DECL
))))
2057 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2058 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2060 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2063 if (!new_redefines_gnu_inline
)
2065 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2066 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2067 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2069 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2070 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2071 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2073 /* If the OLDDECL is an instantiation and/or specialization,
2074 then the NEWDECL must be too. But, it may not yet be marked
2075 as such if the caller has created NEWDECL, but has not yet
2076 figured out that it is a redeclaration. */
2077 if (!DECL_USE_TEMPLATE (newdecl
))
2078 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2080 /* Don't really know how much of the language-specific
2081 values we should copy from old to new. */
2082 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2083 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2084 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2085 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2087 if (LANG_DECL_HAS_MIN (newdecl
))
2089 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2090 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2091 if (DECL_TEMPLATE_INFO (newdecl
))
2092 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2093 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2095 /* Only functions have these fields. */
2096 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2098 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2099 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2100 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2101 && DECL_HIDDEN_FRIEND_P (olddecl
)
2102 && newdecl_is_friend
);
2103 DECL_BEFRIENDING_CLASSES (newdecl
)
2104 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2105 DECL_BEFRIENDING_CLASSES (olddecl
));
2106 /* DECL_THUNKS is only valid for virtual functions,
2107 otherwise it is a DECL_FRIEND_CONTEXT. */
2108 if (DECL_VIRTUAL_P (newdecl
))
2109 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2111 /* Only variables have this field. */
2112 else if (VAR_P (newdecl
)
2113 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2114 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2117 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2121 /* Merge parameter attributes. */
2122 tree oldarg
, newarg
;
2123 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2124 newarg
= DECL_ARGUMENTS(newdecl
);
2126 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2127 DECL_ATTRIBUTES (newarg
)
2128 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2129 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2132 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2133 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2135 /* If newdecl is not a specialization, then it is not a
2136 template-related function at all. And that means that we
2137 should have exited above, returning 0. */
2138 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2140 if (DECL_ODR_USED (olddecl
))
2141 /* From [temp.expl.spec]:
2143 If a template, a member template or the member of a class
2144 template is explicitly specialized then that
2145 specialization shall be declared before the first use of
2146 that specialization that would cause an implicit
2147 instantiation to take place, in every translation unit in
2148 which such a use occurs. */
2149 error ("explicit specialization of %qD after first use",
2152 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2154 /* Don't propagate visibility from the template to the
2155 specialization here. We'll do that in determine_visibility if
2157 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2159 /* [temp.expl.spec/14] We don't inline explicit specialization
2160 just because the primary template says so. */
2162 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2163 the always_inline attribute. */
2164 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2165 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2167 if (DECL_DECLARED_INLINE_P (newdecl
))
2168 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2170 DECL_ATTRIBUTES (newdecl
)
2171 = remove_attribute ("always_inline",
2172 DECL_ATTRIBUTES (newdecl
));
2175 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2177 /* Never inline re-defined extern inline functions.
2178 FIXME: this could be better handled by keeping both
2179 function as separate declarations. */
2180 DECL_UNINLINABLE (newdecl
) = 1;
2184 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2185 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2187 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2189 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2190 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2192 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2193 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2194 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2195 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2198 /* Preserve abstractness on cloned [cd]tors. */
2199 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
2201 /* Update newdecl's parms to point at olddecl. */
2202 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2203 parm
= DECL_CHAIN (parm
))
2204 DECL_CONTEXT (parm
) = olddecl
;
2208 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2209 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2210 COPY_DECL_RTL (newdecl
, olddecl
);
2212 if (! types_match
|| new_defines_function
)
2214 /* These need to be copied so that the names are available.
2215 Note that if the types do match, we'll preserve inline
2216 info and other bits, but if not, we won't. */
2217 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2218 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2220 /* If redeclaring a builtin function, it stays built in
2221 if newdecl is a gnu_inline definition, or if newdecl is just
2223 if (DECL_BUILT_IN (olddecl
)
2224 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2226 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2227 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2228 /* If we're keeping the built-in definition, keep the rtl,
2229 regardless of declaration matches. */
2230 COPY_DECL_RTL (olddecl
, newdecl
);
2231 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2233 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2236 /* If a compatible prototype of these builtin functions
2237 is seen, assume the runtime implements it with the
2238 expected semantics. */
2239 case BUILT_IN_STPCPY
:
2240 if (builtin_decl_explicit_p (fncode
))
2241 set_builtin_decl_implicit_p (fncode
, true);
2248 if (new_defines_function
)
2249 /* If defining a function declared with other language
2250 linkage, use the previously declared language linkage. */
2251 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2252 else if (types_match
)
2254 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2255 /* Don't clear out the arguments if we're just redeclaring a
2257 if (DECL_ARGUMENTS (olddecl
))
2258 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2261 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2262 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2264 /* Now preserve various other info from the definition. */
2265 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2266 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2267 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2268 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2270 /* Warn about conflicting visibility specifications. */
2271 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2272 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2273 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2275 warning_at (input_location
, OPT_Wattributes
,
2276 "%q+D: visibility attribute ignored because it", newdecl
);
2277 warning_at (DECL_SOURCE_LOCATION (olddecl
), OPT_Wattributes
,
2278 "conflicts with previous declaration here");
2280 /* Choose the declaration which specified visibility. */
2281 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2283 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2284 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2286 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2287 so keep this behavior. */
2288 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2290 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2291 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2293 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2294 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2296 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2297 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2299 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2300 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2301 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2303 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2304 with that from NEWDECL below. */
2305 if (DECL_LANG_SPECIFIC (olddecl
))
2307 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2308 != DECL_LANG_SPECIFIC (newdecl
));
2309 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2312 /* Merge the USED information. */
2313 if (TREE_USED (olddecl
))
2314 TREE_USED (newdecl
) = 1;
2315 else if (TREE_USED (newdecl
))
2316 TREE_USED (olddecl
) = 1;
2317 if (VAR_P (newdecl
))
2319 if (DECL_READ_P (olddecl
))
2320 DECL_READ_P (newdecl
) = 1;
2321 else if (DECL_READ_P (newdecl
))
2322 DECL_READ_P (olddecl
) = 1;
2324 if (DECL_PRESERVE_P (olddecl
))
2325 DECL_PRESERVE_P (newdecl
) = 1;
2326 else if (DECL_PRESERVE_P (newdecl
))
2327 DECL_PRESERVE_P (olddecl
) = 1;
2329 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2330 to olddecl and deleted. */
2331 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2332 && DECL_FUNCTION_VERSIONED (olddecl
))
2334 /* Set the flag for newdecl so that it gets copied to olddecl. */
2335 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2336 /* newdecl will be purged after copying to olddecl and is no longer
2338 delete_function_version (newdecl
);
2341 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2345 function_size
= sizeof (struct tree_decl_common
);
2347 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2348 (char *) newdecl
+ sizeof (struct tree_common
),
2349 function_size
- sizeof (struct tree_common
));
2351 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2352 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2353 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2354 if (new_template_info
)
2355 /* If newdecl is a template instantiation, it is possible that
2356 the following sequence of events has occurred:
2358 o A friend function was declared in a class template. The
2359 class template was instantiated.
2361 o The instantiation of the friend declaration was
2362 recorded on the instantiation list, and is newdecl.
2364 o Later, however, instantiate_class_template called pushdecl
2365 on the newdecl to perform name injection. But, pushdecl in
2366 turn called duplicate_decls when it discovered that another
2367 declaration of a global function with the same name already
2370 o Here, in duplicate_decls, we decided to clobber newdecl.
2372 If we're going to do that, we'd better make sure that
2373 olddecl, and not newdecl, is on the list of
2374 instantiations so that if we try to do the instantiation
2375 again we won't get the clobbered declaration. */
2376 reregister_specialization (newdecl
,
2382 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2383 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2384 (char *) newdecl
+ sizeof (struct tree_common
),
2385 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2386 switch (TREE_CODE (olddecl
))
2396 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2397 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2398 size
- sizeof (struct tree_decl_common
)
2399 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2403 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2404 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2405 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2406 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2410 DECL_UID (olddecl
) = olddecl_uid
;
2412 DECL_FRIEND_P (olddecl
) = 1;
2415 DECL_ANTICIPATED (olddecl
) = 1;
2416 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2419 /* NEWDECL contains the merged attribute lists.
2420 Update OLDDECL to be the same. */
2421 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2423 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2424 so that encode_section_info has a chance to look at the new decl
2425 flags and attributes. */
2426 if (DECL_RTL_SET_P (olddecl
)
2427 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2429 && TREE_STATIC (olddecl
))))
2430 make_decl_rtl (olddecl
);
2432 /* The NEWDECL will no longer be needed. Because every out-of-class
2433 declaration of a member results in a call to duplicate_decls,
2434 freeing these nodes represents in a significant savings. */
2440 /* Return zero if the declaration NEWDECL is valid
2441 when the declaration OLDDECL (assumed to be for the same name)
2442 has already been seen.
2443 Otherwise return an error message format string with a %s
2444 where the identifier should go. */
2447 redeclaration_error_message (tree newdecl
, tree olddecl
)
2449 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2451 /* Because C++ can put things into name space for free,
2452 constructs like "typedef struct foo { ... } foo"
2453 would look like an erroneous redeclaration. */
2454 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2457 return G_("redefinition of %q#D");
2459 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2461 /* If this is a pure function, its olddecl will actually be
2462 the original initialization to `0' (which we force to call
2463 abort()). Don't complain about redefinition in this case. */
2464 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2465 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2468 /* If both functions come from different namespaces, this is not
2469 a redeclaration - this is a conflict with a used function. */
2470 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2471 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2472 && ! decls_match (olddecl
, newdecl
))
2473 return G_("%qD conflicts with used function");
2475 /* We'll complain about linkage mismatches in
2476 warn_extern_redeclared_static. */
2478 /* Defining the same name twice is no good. */
2479 if (DECL_INITIAL (olddecl
) != NULL_TREE
2480 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2482 if (DECL_NAME (olddecl
) == NULL_TREE
)
2483 return G_("%q#D not declared in class");
2484 else if (!GNU_INLINE_P (olddecl
)
2485 || GNU_INLINE_P (newdecl
))
2486 return G_("redefinition of %q#D");
2489 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2491 bool olda
= GNU_INLINE_P (olddecl
);
2492 bool newa
= GNU_INLINE_P (newdecl
);
2497 return G_("%q+D redeclared inline with "
2498 "%<gnu_inline%> attribute");
2500 return G_("%q+D redeclared inline without "
2501 "%<gnu_inline%> attribute");
2505 check_abi_tag_redeclaration
2506 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2507 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2511 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2515 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2517 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2518 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2519 return G_("redefinition of %q#D");
2523 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2524 || (DECL_TEMPLATE_RESULT (newdecl
)
2525 == DECL_TEMPLATE_RESULT (olddecl
)))
2528 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2529 if (DECL_TEMPLATE_INFO (nt
))
2530 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2531 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2532 if (DECL_TEMPLATE_INFO (ot
))
2533 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2534 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2535 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2536 return G_("redefinition of %q#D");
2538 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2540 bool olda
= GNU_INLINE_P (ot
);
2541 bool newa
= GNU_INLINE_P (nt
);
2546 return G_("%q+D redeclared inline with "
2547 "%<gnu_inline%> attribute");
2549 return G_("%q+D redeclared inline without "
2550 "%<gnu_inline%> attribute");
2554 /* Core issue #226 (C++0x):
2556 If a friend function template declaration specifies a
2557 default template-argument, that declaration shall be a
2558 definition and shall be the only declaration of the
2559 function template in the translation unit. */
2560 if ((cxx_dialect
!= cxx98
)
2561 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2562 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2563 /*is_primary=*/true,
2564 /*is_partial=*/false,
2565 /*is_friend_decl=*/2))
2566 return G_("redeclaration of friend %q#D "
2567 "may not have default template arguments");
2571 else if (VAR_P (newdecl
)
2572 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2573 && (! DECL_LANG_SPECIFIC (olddecl
)
2574 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2575 || DECL_THREAD_LOCAL_P (newdecl
)))
2577 /* Only variables can be thread-local, and all declarations must
2578 agree on this property. */
2579 if (DECL_THREAD_LOCAL_P (newdecl
))
2580 return G_("thread-local declaration of %q#D follows "
2581 "non-thread-local declaration");
2583 return G_("non-thread-local declaration of %q#D follows "
2584 "thread-local declaration");
2586 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2588 /* The objects have been declared at namespace scope. If either
2589 is a member of an anonymous union, then this is an invalid
2590 redeclaration. For example:
2596 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2597 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2598 return G_("redeclaration of %q#D");
2599 /* If at least one declaration is a reference, there is no
2600 conflict. For example:
2606 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2608 /* Reject two definitions. */
2609 return G_("redefinition of %q#D");
2613 /* Objects declared with block scope: */
2614 /* Reject two definitions, and reject a definition
2615 together with an external reference. */
2616 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2617 return G_("redeclaration of %q#D");
2622 /* Hash and equality functions for the named_label table. */
2625 named_label_entry_hash (const void *data
)
2627 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2628 return DECL_UID (ent
->label_decl
);
2632 named_label_entry_eq (const void *a
, const void *b
)
2634 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2635 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2636 return ent_a
->label_decl
== ent_b
->label_decl
;
2639 /* Create a new label, named ID. */
2642 make_label_decl (tree id
, int local_p
)
2644 struct named_label_entry
*ent
;
2648 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2650 DECL_CONTEXT (decl
) = current_function_decl
;
2651 DECL_MODE (decl
) = VOIDmode
;
2652 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2654 /* Say where one reference is to the label, for the sake of the
2655 error if it is not defined. */
2656 DECL_SOURCE_LOCATION (decl
) = input_location
;
2658 /* Record the fact that this identifier is bound to this label. */
2659 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2661 /* Create the label htab for the function on demand. */
2663 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2664 named_label_entry_eq
, NULL
);
2666 /* Record this label on the list of labels used in this function.
2667 We do this before calling make_label_decl so that we get the
2668 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2669 ent
= ggc_alloc_cleared_named_label_entry ();
2670 ent
->label_decl
= decl
;
2672 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2673 gcc_assert (*slot
== NULL
);
2679 /* Look for a label named ID in the current function. If one cannot
2680 be found, create one. (We keep track of used, but undefined,
2681 labels, and complain about them at the end of a function.) */
2684 lookup_label_1 (tree id
)
2688 /* You can't use labels at global scope. */
2689 if (current_function_decl
== NULL_TREE
)
2691 error ("label %qE referenced outside of any function", id
);
2695 /* See if we've already got this label. */
2696 decl
= IDENTIFIER_LABEL_VALUE (id
);
2697 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2700 decl
= make_label_decl (id
, /*local_p=*/0);
2704 /* Wrapper for lookup_label_1. */
2707 lookup_label (tree id
)
2710 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2711 ret
= lookup_label_1 (id
);
2712 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2716 /* Declare a local label named ID. */
2719 declare_local_label (tree id
)
2722 cp_label_binding bind
;
2724 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2725 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2726 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2728 decl
= make_label_decl (id
, /*local_p=*/1);
2730 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2735 /* Returns nonzero if it is ill-formed to jump past the declaration of
2736 DECL. Returns 2 if it's also a real problem. */
2739 decl_jump_unsafe (tree decl
)
2741 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2742 with automatic storage duration is not in scope to a point where it is
2743 in scope is ill-formed unless the variable has scalar type, class type
2744 with a trivial default constructor and a trivial destructor, a
2745 cv-qualified version of one of these types, or an array of one of the
2746 preceding types and is declared without an initializer (8.5). */
2747 tree type
= TREE_TYPE (decl
);
2749 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2750 || type
== error_mark_node
)
2753 type
= strip_array_types (type
);
2755 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2758 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
2764 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2767 identify_goto (tree decl
, const location_t
*locus
)
2770 permerror (input_location
, "jump to label %qD", decl
);
2772 permerror (input_location
, "jump to case label");
2774 permerror (*locus
, " from here");
2777 /* Check that a single previously seen jump to a newly defined label
2778 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2779 the jump context; NAMES are the names in scope in LEVEL at the jump
2780 context; LOCUS is the source position of the jump or 0. Returns
2781 true if all is well. */
2784 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2785 bool exited_omp
, const location_t
*locus
)
2787 cp_binding_level
*b
;
2788 bool identified
= false, saw_eh
= false, saw_omp
= false;
2792 identify_goto (decl
, locus
);
2793 error (" exits OpenMP structured block");
2794 identified
= saw_omp
= true;
2797 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2799 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2801 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2802 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2803 : TREE_CHAIN (new_decls
)))
2805 int problem
= decl_jump_unsafe (new_decls
);
2811 identify_goto (decl
, locus
);
2815 error (" crosses initialization of %q+#D", new_decls
);
2817 permerror (input_location
, " enters scope of %q+#D which has "
2818 "non-trivial destructor", new_decls
);
2823 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2827 identify_goto (decl
, locus
);
2830 if (b
->kind
== sk_try
)
2831 error (" enters try block");
2833 error (" enters catch block");
2836 if (b
->kind
== sk_omp
&& !saw_omp
)
2840 identify_goto (decl
, locus
);
2843 error (" enters OpenMP structured block");
2852 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2854 check_previous_goto_1 (decl
, use
->binding_level
,
2855 use
->names_in_scope
, use
->in_omp_scope
,
2856 &use
->o_goto_locus
);
2860 check_switch_goto (cp_binding_level
* level
)
2862 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2865 /* Check that a new jump to a label DECL is OK. Called by
2866 finish_goto_stmt. */
2869 check_goto (tree decl
)
2871 struct named_label_entry
*ent
, dummy
;
2872 bool saw_catch
= false, identified
= false;
2876 /* We can't know where a computed goto is jumping.
2877 So we assume that it's OK. */
2878 if (TREE_CODE (decl
) != LABEL_DECL
)
2881 /* We didn't record any information about this label when we created it,
2882 and there's not much point since it's trivial to analyze as a return. */
2883 if (decl
== cdtor_label
)
2886 dummy
.label_decl
= decl
;
2887 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2888 gcc_assert (ent
!= NULL
);
2890 /* If the label hasn't been defined yet, defer checking. */
2891 if (! DECL_INITIAL (decl
))
2893 struct named_label_use_entry
*new_use
;
2895 /* Don't bother creating another use if the last goto had the
2896 same data, and will therefore create the same set of errors. */
2898 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2901 new_use
= ggc_alloc_named_label_use_entry ();
2902 new_use
->binding_level
= current_binding_level
;
2903 new_use
->names_in_scope
= current_binding_level
->names
;
2904 new_use
->o_goto_locus
= input_location
;
2905 new_use
->in_omp_scope
= false;
2907 new_use
->next
= ent
->uses
;
2908 ent
->uses
= new_use
;
2912 if (ent
->in_try_scope
|| ent
->in_catch_scope
2913 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
2915 permerror (input_location
, "jump to label %q+D", decl
);
2916 permerror (input_location
, " from here");
2920 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
2922 int u
= decl_jump_unsafe (bad
);
2924 if (u
> 1 && DECL_ARTIFICIAL (bad
))
2926 /* Can't skip init of __exception_info. */
2927 error_at (DECL_SOURCE_LOCATION (bad
), " enters catch block");
2931 error (" skips initialization of %q+#D", bad
);
2933 permerror (input_location
, " enters scope of %q+#D which has "
2934 "non-trivial destructor", bad
);
2937 if (ent
->in_try_scope
)
2938 error (" enters try block");
2939 else if (ent
->in_catch_scope
&& !saw_catch
)
2940 error (" enters catch block");
2942 if (ent
->in_omp_scope
)
2943 error (" enters OpenMP structured block");
2944 else if (flag_openmp
)
2946 cp_binding_level
*b
;
2947 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2949 if (b
== ent
->binding_level
)
2951 if (b
->kind
== sk_omp
)
2955 permerror (input_location
, "jump to label %q+D", decl
);
2956 permerror (input_location
, " from here");
2959 error (" exits OpenMP structured block");
2966 /* Check that a return is ok wrt OpenMP structured blocks.
2967 Called by finish_return_stmt. Returns true if all is well. */
2970 check_omp_return (void)
2972 cp_binding_level
*b
;
2973 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2974 if (b
->kind
== sk_omp
)
2976 error ("invalid exit from OpenMP structured block");
2979 else if (b
->kind
== sk_function_parms
)
2984 /* Define a label, specifying the location in the source file.
2985 Return the LABEL_DECL node for the label. */
2988 define_label_1 (location_t location
, tree name
)
2990 struct named_label_entry
*ent
, dummy
;
2991 cp_binding_level
*p
;
2994 decl
= lookup_label (name
);
2996 dummy
.label_decl
= decl
;
2997 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2998 gcc_assert (ent
!= NULL
);
3000 /* After labels, make any new cleanups in the function go into their
3001 own new (temporary) binding contour. */
3002 for (p
= current_binding_level
;
3003 p
->kind
!= sk_function_parms
;
3005 p
->more_cleanups_ok
= 0;
3007 if (name
== get_identifier ("wchar_t"))
3008 permerror (input_location
, "label named wchar_t");
3010 if (DECL_INITIAL (decl
) != NULL_TREE
)
3012 error ("duplicate label %qD", decl
);
3013 return error_mark_node
;
3017 struct named_label_use_entry
*use
;
3019 /* Mark label as having been defined. */
3020 DECL_INITIAL (decl
) = error_mark_node
;
3021 /* Say where in the source. */
3022 DECL_SOURCE_LOCATION (decl
) = location
;
3024 ent
->binding_level
= current_binding_level
;
3025 ent
->names_in_scope
= current_binding_level
->names
;
3027 for (use
= ent
->uses
; use
; use
= use
->next
)
3028 check_previous_goto (decl
, use
);
3035 /* Wrapper for define_label_1. */
3038 define_label (location_t location
, tree name
)
3041 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3042 ret
= define_label_1 (location
, name
);
3043 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3050 cp_binding_level
*level
;
3051 struct cp_switch
*next
;
3052 /* The SWITCH_STMT being built. */
3054 /* A splay-tree mapping the low element of a case range to the high
3055 element, or NULL_TREE if there is no high element. Used to
3056 determine whether or not a new case label duplicates an old case
3057 label. We need a tree, rather than simply a hash table, because
3058 of the GNU case range extension. */
3062 /* A stack of the currently active switch statements. The innermost
3063 switch statement is on the top of the stack. There is no need to
3064 mark the stack for garbage collection because it is only active
3065 during the processing of the body of a function, and we never
3066 collect at that point. */
3068 static struct cp_switch
*switch_stack
;
3070 /* Called right after a switch-statement condition is parsed.
3071 SWITCH_STMT is the switch statement being parsed. */
3074 push_switch (tree switch_stmt
)
3076 struct cp_switch
*p
= XNEW (struct cp_switch
);
3077 p
->level
= current_binding_level
;
3078 p
->next
= switch_stack
;
3079 p
->switch_stmt
= switch_stmt
;
3080 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3087 struct cp_switch
*cs
= switch_stack
;
3088 location_t switch_location
;
3090 /* Emit warnings as needed. */
3091 switch_location
= EXPR_LOC_OR_HERE (cs
->switch_stmt
);
3092 if (!processing_template_decl
)
3093 c_do_switch_warnings (cs
->cases
, switch_location
,
3094 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3095 SWITCH_STMT_COND (cs
->switch_stmt
));
3097 splay_tree_delete (cs
->cases
);
3098 switch_stack
= switch_stack
->next
;
3102 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3103 condition. Note that if TYPE and VALUE are already integral we don't
3104 really do the conversion because the language-independent
3105 warning/optimization code will work better that way. */
3108 case_conversion (tree type
, tree value
)
3110 if (value
== NULL_TREE
)
3113 if (cxx_dialect
>= cxx11
3114 && (SCOPED_ENUM_P (type
)
3115 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3117 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3118 type
= type_promotes_to (type
);
3119 value
= (perform_implicit_conversion_flags
3120 (type
, value
, tf_warning_or_error
,
3121 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3123 return cxx_constant_value (value
);
3126 /* Note that we've seen a definition of a case label, and complain if this
3127 is a bad place for one. */
3130 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3133 cp_binding_level
*p
;
3136 if (processing_template_decl
)
3140 /* For templates, just add the case label; we'll do semantic
3141 analysis at instantiation-time. */
3142 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3143 return add_stmt (build_case_label (low_value
, high_value
, label
));
3146 /* Find the condition on which this switch statement depends. */
3147 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3148 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3149 cond
= TREE_VALUE (cond
);
3151 if (!check_switch_goto (switch_stack
->level
))
3152 return error_mark_node
;
3154 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3156 low_value
= case_conversion (type
, low_value
);
3157 high_value
= case_conversion (type
, high_value
);
3159 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3160 low_value
, high_value
);
3162 /* After labels, make any new cleanups in the function go into their
3163 own new (temporary) binding contour. */
3164 for (p
= current_binding_level
;
3165 p
->kind
!= sk_function_parms
;
3167 p
->more_cleanups_ok
= 0;
3172 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3175 typename_hash (const void* k
)
3178 const_tree
const t
= (const_tree
) k
;
3180 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3181 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
3186 typedef struct typename_info
{
3194 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3195 really of type `typename_info*' */
3198 typename_compare (const void * k1
, const void * k2
)
3200 const_tree
const t1
= (const_tree
) k1
;
3201 const typename_info
*const t2
= (const typename_info
*) k2
;
3203 return (DECL_NAME (TYPE_NAME (t1
)) == t2
->name
3204 && TYPE_CONTEXT (t1
) == t2
->scope
3205 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3206 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3207 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3210 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3211 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3213 Returns the new TYPENAME_TYPE. */
3215 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
3218 build_typename_type (tree context
, tree name
, tree fullname
,
3219 enum tag_types tag_type
)
3227 if (typename_htab
== NULL
)
3228 typename_htab
= htab_create_ggc (61, &typename_hash
,
3229 &typename_compare
, NULL
);
3231 ti
.scope
= FROB_CONTEXT (context
);
3233 ti
.template_id
= fullname
;
3234 ti
.enum_p
= tag_type
== enum_type
;
3235 ti
.class_p
= (tag_type
== class_type
3236 || tag_type
== record_type
3237 || tag_type
== union_type
);
3238 hash
= (htab_hash_pointer (ti
.scope
)
3239 ^ htab_hash_pointer (ti
.name
));
3241 /* See if we already have this type. */
3242 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
3247 /* Build the TYPENAME_TYPE. */
3248 t
= cxx_make_type (TYPENAME_TYPE
);
3249 TYPE_CONTEXT (t
) = ti
.scope
;
3250 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3251 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3252 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3254 /* Build the corresponding TYPE_DECL. */
3255 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3256 TYPE_NAME (TREE_TYPE (d
)) = d
;
3257 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3258 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3259 DECL_ARTIFICIAL (d
) = 1;
3261 /* Store it in the hash table. */
3264 /* TYPENAME_TYPEs must always be compared structurally, because
3265 they may or may not resolve down to another type depending on
3266 the currently open classes. */
3267 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3273 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3274 provided to name the type. Returns an appropriate type, unless an
3275 error occurs, in which case error_mark_node is returned. If we
3276 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3277 return that, rather than the _TYPE it corresponds to, in other
3278 cases we look through the type decl. If TF_ERROR is set, complain
3279 about errors, otherwise be quiet. */
3282 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3283 tsubst_flags_t complain
)
3289 if (name
== error_mark_node
3290 || context
== NULL_TREE
3291 || context
== error_mark_node
)
3292 return error_mark_node
;
3296 if (!(TYPE_LANG_SPECIFIC (name
)
3297 && (CLASSTYPE_IS_TEMPLATE (name
)
3298 || CLASSTYPE_USE_TEMPLATE (name
))))
3299 name
= TYPE_IDENTIFIER (name
);
3301 /* Create a TEMPLATE_ID_EXPR for the type. */
3302 name
= build_nt (TEMPLATE_ID_EXPR
,
3303 CLASSTYPE_TI_TEMPLATE (name
),
3304 CLASSTYPE_TI_ARGS (name
));
3306 else if (TREE_CODE (name
) == TYPE_DECL
)
3307 name
= DECL_NAME (name
);
3311 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3313 name
= TREE_OPERAND (name
, 0);
3314 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3315 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3316 else if (TREE_CODE (name
) == OVERLOAD
)
3318 if (complain
& tf_error
)
3319 error ("%qD is not a type", name
);
3320 return error_mark_node
;
3323 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3325 if (complain
& tf_error
)
3326 error ("%qD used without template parameters", name
);
3327 return error_mark_node
;
3329 gcc_assert (identifier_p (name
));
3330 gcc_assert (TYPE_P (context
));
3332 if (!MAYBE_CLASS_TYPE_P (context
))
3334 if (complain
& tf_error
)
3335 error ("%q#T is not a class", context
);
3336 return error_mark_node
;
3339 /* When the CONTEXT is a dependent type, NAME could refer to a
3340 dependent base class of CONTEXT. But look inside it anyway
3341 if CONTEXT is a currently open scope, in case it refers to a
3342 member of the current instantiation or a non-dependent base;
3343 lookup will stop when we hit a dependent base. */
3344 if (!dependent_scope_p (context
))
3345 /* We should only set WANT_TYPE when we're a nested typename type.
3346 Then we can give better diagnostics if we find a non-type. */
3347 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3351 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3352 return build_typename_type (context
, name
, fullname
, tag_type
);
3354 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3358 if (complain
& tf_error
)
3359 error (want_template
? G_("no class template named %q#T in %q#T")
3360 : G_("no type named %q#T in %q#T"), name
, context
);
3361 return error_mark_node
;
3364 /* Pull out the template from an injected-class-name (or multiple). */
3366 t
= maybe_get_template_decl_from_type_decl (t
);
3368 if (TREE_CODE (t
) == TREE_LIST
)
3370 if (complain
& tf_error
)
3372 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3373 print_candidates (t
);
3375 return error_mark_node
;
3378 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3380 if (complain
& tf_error
)
3381 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3383 return error_mark_node
;
3385 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3387 if (complain
& tf_error
)
3388 error ("%<typename %T::%D%> names %q#T, which is not a type",
3390 return error_mark_node
;
3393 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3394 return error_mark_node
;
3396 /* If we are currently parsing a template and if T is a typedef accessed
3397 through CONTEXT then we need to remember and check access of T at
3398 template instantiation time. */
3399 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3402 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3404 /*entering_scope=*/0,
3405 tf_warning_or_error
| tf_user
);
3407 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3410 maybe_record_typedef_use (t
);
3415 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3416 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3417 in which case error_mark_node is returned.
3419 If PARM_LIST is non-NULL, also make sure that the template parameter
3420 list of TEMPLATE_DECL matches.
3422 If COMPLAIN zero, don't complain about any errors that occur. */
3425 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3426 tsubst_flags_t complain
)
3432 name
= TYPE_IDENTIFIER (name
);
3433 else if (DECL_P (name
))
3434 name
= DECL_NAME (name
);
3435 gcc_assert (identifier_p (name
));
3437 if (!dependent_type_p (context
)
3438 || currently_open_class (context
))
3440 tree tmpl
= NULL_TREE
;
3442 if (MAYBE_CLASS_TYPE_P (context
))
3443 tmpl
= lookup_field (context
, name
, 0, false);
3445 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3446 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3448 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3450 if (complain
& tf_error
)
3451 error ("no class template named %q#T in %q#T", name
, context
);
3452 return error_mark_node
;
3456 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3458 if (complain
& tf_error
)
3460 error ("template parameters do not match template");
3461 error ("%q+D declared here", tmpl
);
3463 return error_mark_node
;
3466 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3468 return error_mark_node
;
3473 /* Build the UNBOUND_CLASS_TEMPLATE. */
3474 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3475 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3476 TREE_TYPE (t
) = NULL_TREE
;
3477 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3479 /* Build the corresponding TEMPLATE_DECL. */
3480 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3481 TYPE_NAME (TREE_TYPE (d
)) = d
;
3482 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3483 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3484 DECL_ARTIFICIAL (d
) = 1;
3485 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3492 /* Push the declarations of builtin types into the namespace.
3493 RID_INDEX is the index of the builtin type in the array
3494 RID_POINTERS. NAME is the name used when looking up the builtin
3495 type. TYPE is the _TYPE node for the builtin type. */
3498 record_builtin_type (enum rid rid_index
,
3502 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3503 tree tdecl
= NULL_TREE
;
3505 if ((int) rid_index
< (int) RID_MAX
)
3506 rname
= ridpointers
[(int) rid_index
];
3508 tname
= get_identifier (name
);
3510 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3511 eliminated. Built-in types should not be looked up name; their
3512 names are keywords that the parser can recognize. However, there
3513 is code in c-common.c that uses identifier_global_value to look
3514 up built-in types by name. */
3517 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3518 DECL_ARTIFICIAL (tdecl
) = 1;
3519 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3525 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3526 DECL_ARTIFICIAL (tdecl
) = 1;
3528 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3531 if (!TYPE_NAME (type
))
3532 TYPE_NAME (type
) = tdecl
;
3535 debug_hooks
->type_decl (tdecl
, 0);
3538 /* Record one of the standard Java types.
3539 * Declare it as having the given NAME.
3540 * If SIZE > 0, it is the size of one of the integral types;
3541 * otherwise it is the negative of the size of one of the other types. */
3544 record_builtin_java_type (const char* name
, int size
)
3549 type
= build_nonstandard_integer_type (size
, 0);
3550 type
= build_distinct_type_copy (type
);
3552 else if (size
> -32)
3555 /* "__java_char" or ""__java_boolean". */
3556 type
= build_nonstandard_integer_type (-size
, 1);
3557 type
= build_distinct_type_copy (type
);
3558 /* Get the signed type cached and attached to the unsigned type,
3559 so it doesn't get garbage-collected at "random" times,
3560 causing potential codegen differences out of different UIDs
3561 and different alias set numbers. */
3562 stype
= build_nonstandard_integer_type (-size
, 0);
3563 stype
= build_distinct_type_copy (stype
);
3564 TREE_CHAIN (type
) = stype
;
3565 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3568 { /* "__java_float" or ""__java_double". */
3569 type
= make_node (REAL_TYPE
);
3570 TYPE_PRECISION (type
) = - size
;
3573 record_builtin_type (RID_MAX
, name
, type
);
3574 decl
= TYPE_NAME (type
);
3576 /* Suppress generate debug symbol entries for these types,
3577 since for normal C++ they are just clutter.
3578 However, push_lang_context undoes this if extern "Java" is seen. */
3579 DECL_IGNORED_P (decl
) = 1;
3581 TYPE_FOR_JAVA (type
) = 1;
3585 /* Push a type into the namespace so that the back ends ignore it. */
3588 record_unknown_type (tree type
, const char* name
)
3590 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3591 TYPE_DECL
, get_identifier (name
), type
));
3592 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3593 DECL_IGNORED_P (decl
) = 1;
3594 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3595 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3596 TYPE_ALIGN (type
) = 1;
3597 TYPE_USER_ALIGN (type
) = 0;
3598 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3601 /* A string for which we should create an IDENTIFIER_NODE at
3604 typedef struct predefined_identifier
3606 /* The name of the identifier. */
3607 const char *const name
;
3608 /* The place where the IDENTIFIER_NODE should be stored. */
3610 /* Nonzero if this is the name of a constructor or destructor. */
3611 const int ctor_or_dtor_p
;
3612 } predefined_identifier
;
3614 /* Create all the predefined identifiers. */
3617 initialize_predefined_identifiers (void)
3619 const predefined_identifier
*pid
;
3621 /* A table of identifiers to create at startup. */
3622 static const predefined_identifier predefined_identifiers
[] = {
3623 { "C++", &lang_name_cplusplus
, 0 },
3624 { "C", &lang_name_c
, 0 },
3625 { "Java", &lang_name_java
, 0 },
3626 /* Some of these names have a trailing space so that it is
3627 impossible for them to conflict with names written by users. */
3628 { "__ct ", &ctor_identifier
, 1 },
3629 { "__base_ctor ", &base_ctor_identifier
, 1 },
3630 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3631 { "__dt ", &dtor_identifier
, 1 },
3632 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3633 { "__base_dtor ", &base_dtor_identifier
, 1 },
3634 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3635 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3636 { "nelts", &nelts_identifier
, 0 },
3637 { THIS_NAME
, &this_identifier
, 0 },
3638 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3639 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3640 { "_vptr", &vptr_identifier
, 0 },
3641 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3642 { "::", &global_scope_name
, 0 },
3643 { "std", &std_identifier
, 0 },
3647 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3649 *pid
->node
= get_identifier (pid
->name
);
3650 if (pid
->ctor_or_dtor_p
)
3651 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3655 /* Create the predefined scalar types of C,
3656 and some nodes representing standard constants (0, 1, (void *)0).
3657 Initialize the global binding level.
3658 Make definitions for built-in primitive functions. */
3661 cxx_init_decl_processing (void)
3664 tree void_ftype_ptr
;
3666 /* Create all the identifiers we need. */
3667 initialize_predefined_identifiers ();
3669 /* Create the global variables. */
3670 push_to_top_level ();
3672 current_function_decl
= NULL_TREE
;
3673 current_binding_level
= NULL
;
3674 /* Enter the global namespace. */
3675 gcc_assert (global_namespace
== NULL_TREE
);
3676 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3678 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3679 TREE_PUBLIC (global_namespace
) = 1;
3680 begin_scope (sk_namespace
, global_namespace
);
3682 if (flag_visibility_ms_compat
)
3683 default_visibility
= VISIBILITY_HIDDEN
;
3686 current_lang_name
= lang_name_c
;
3688 /* Create the `std' namespace. */
3689 push_namespace (std_identifier
);
3690 std_node
= current_namespace
;
3693 c_common_nodes_and_builtins ();
3695 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3696 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3697 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3698 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3699 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3700 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3701 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3702 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3704 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3706 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3707 truthvalue_type_node
= boolean_type_node
;
3708 truthvalue_false_node
= boolean_false_node
;
3709 truthvalue_true_node
= boolean_true_node
;
3711 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3712 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3713 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3716 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3719 delta_type_node
= ptrdiff_type_node
;
3720 vtable_index_type
= ptrdiff_type_node
;
3722 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3723 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3724 void_ftype_ptr
= build_function_type_list (void_type_node
,
3725 ptr_type_node
, NULL_TREE
);
3727 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3729 /* C++ extensions */
3731 unknown_type_node
= make_node (LANG_TYPE
);
3732 record_unknown_type (unknown_type_node
, "unknown type");
3734 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3735 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3737 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3739 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3740 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3742 init_list_type_node
= make_node (LANG_TYPE
);
3743 record_unknown_type (init_list_type_node
, "init list");
3746 /* Make sure we get a unique function type, so we can give
3747 its pointer type a name. (This wins for gdb.) */
3748 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3749 TREE_TYPE (vfunc_type
) = integer_type_node
;
3750 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3751 layout_type (vfunc_type
);
3753 vtable_entry_type
= build_pointer_type (vfunc_type
);
3755 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3758 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3759 layout_type (vtbl_type_node
);
3760 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3761 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3762 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3763 layout_type (vtbl_ptr_type_node
);
3764 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3766 push_namespace (get_identifier ("__cxxabiv1"));
3767 abi_node
= current_namespace
;
3770 global_type_node
= make_node (LANG_TYPE
);
3771 record_unknown_type (global_type_node
, "global type");
3774 current_lang_name
= lang_name_cplusplus
;
3777 tree newattrs
, extvisattr
;
3778 tree newtype
, deltype
;
3779 tree ptr_ftype_sizetype
;
3783 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3784 if (cxx_dialect
== cxx98
)
3787 tree bad_alloc_type_node
;
3788 tree bad_alloc_decl
;
3790 push_namespace (std_identifier
);
3791 bad_alloc_id
= get_identifier ("bad_alloc");
3792 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3793 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3795 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3796 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3800 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3803 new_eh_spec
= noexcept_false_spec
;
3805 /* Ensure attribs.c is initialized. */
3807 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3809 newattrs
= tree_cons (get_identifier ("alloc_size"),
3810 build_tree_list (NULL_TREE
, integer_one_node
),
3812 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3813 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3814 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3815 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3816 DECL_IS_OPERATOR_NEW (push_cp_library_fn (NEW_EXPR
, newtype
, 0)) = 1;
3817 DECL_IS_OPERATOR_NEW (push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0)) = 1;
3818 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3819 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3821 nullptr_type_node
= make_node (NULLPTR_TYPE
);
3822 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
3823 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
3824 TYPE_UNSIGNED (nullptr_type_node
) = 1;
3825 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
3826 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
3827 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
3828 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
3832 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
3833 ECF_NORETURN
| ECF_NOTHROW
);
3835 /* Perform other language dependent initializations. */
3836 init_class_processing ();
3837 init_rtti_processing ();
3838 init_template_processing ();
3840 if (flag_exceptions
)
3841 init_exception_processing ();
3843 if (! supports_one_only ())
3846 make_fname_decl
= cp_make_fname_decl
;
3847 start_fname_decls ();
3849 /* Show we use EH for cleanups. */
3850 if (flag_exceptions
)
3851 using_eh_for_cleanups ();
3854 /* Generate an initializer for a function naming variable from
3855 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3856 filled in with the type of the init. */
3859 cp_fname_init (const char* name
, tree
*type_p
)
3861 tree domain
= NULL_TREE
;
3863 tree init
= NULL_TREE
;
3868 length
= strlen (name
);
3869 domain
= build_index_type (size_int (length
));
3870 init
= build_string (length
+ 1, name
);
3873 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3874 type
= build_cplus_array_type (type
, domain
);
3879 TREE_TYPE (init
) = type
;
3881 init
= error_mark_node
;
3886 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3887 the decl, LOC is the location to give the decl, NAME is the
3888 initialization string and TYPE_DEP indicates whether NAME depended
3889 on the type of the function. We make use of that to detect
3890 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3891 at the point of first use, so we mustn't push the decl now. */
3894 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3896 const char *const name
= (type_dep
&& processing_template_decl
3897 ? NULL
: fname_as_string (type_dep
));
3899 tree init
= cp_fname_init (name
, &type
);
3900 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3903 free (CONST_CAST (char *, name
));
3905 /* As we're using pushdecl_with_scope, we must set the context. */
3906 DECL_CONTEXT (decl
) = current_function_decl
;
3908 TREE_STATIC (decl
) = 1;
3909 TREE_READONLY (decl
) = 1;
3910 DECL_ARTIFICIAL (decl
) = 1;
3912 TREE_USED (decl
) = 1;
3914 if (current_function_decl
)
3916 cp_binding_level
*b
= current_binding_level
;
3917 if (b
->kind
== sk_function_parms
)
3918 return error_mark_node
;
3919 while (b
->level_chain
->kind
!= sk_function_parms
)
3921 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3922 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3923 LOOKUP_ONLYCONVERTING
);
3927 DECL_THIS_STATIC (decl
) = true;
3928 pushdecl_top_level_and_finish (decl
, init
);
3935 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3937 tree id
= DECL_NAME (decl
);
3938 const char *name
= IDENTIFIER_POINTER (id
);
3940 retrofit_lang_decl (decl
);
3942 DECL_ARTIFICIAL (decl
) = 1;
3943 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3944 SET_DECL_LANGUAGE (decl
, lang_c
);
3945 /* Runtime library routines are, by definition, available in an
3946 external shared object. */
3947 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3948 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3950 DECL_CONTEXT (decl
) = context
;
3953 pushdecl_top_level (decl
);
3957 /* A function in the user's namespace should have an explicit
3958 declaration before it is used. Mark the built-in function as
3959 anticipated but not actually declared. */
3960 if (name
[0] != '_' || name
[1] != '_')
3961 DECL_ANTICIPATED (decl
) = 1;
3962 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
3964 size_t len
= strlen (name
);
3966 /* Treat __*_chk fortification functions as anticipated as well,
3967 unless they are __builtin_*. */
3968 if (len
> strlen ("___chk")
3969 && memcmp (name
+ len
- strlen ("_chk"),
3970 "_chk", strlen ("_chk") + 1) == 0)
3971 DECL_ANTICIPATED (decl
) = 1;
3978 cxx_builtin_function (tree decl
)
3980 tree id
= DECL_NAME (decl
);
3981 const char *name
= IDENTIFIER_POINTER (id
);
3982 /* All builtins that don't begin with an '_' should additionally
3983 go in the 'std' namespace. */
3986 tree decl2
= copy_node(decl
);
3987 push_namespace (std_identifier
);
3988 builtin_function_1 (decl2
, std_node
, false);
3992 return builtin_function_1 (decl
, NULL_TREE
, false);
3995 /* Like cxx_builtin_function, but guarantee the function is added to the global
3996 scope. This is to allow function specific options to add new machine
3997 dependent builtins when the target ISA changes via attribute((target(...)))
3998 which saves space on program startup if the program does not use non-generic
4002 cxx_builtin_function_ext_scope (tree decl
)
4005 tree id
= DECL_NAME (decl
);
4006 const char *name
= IDENTIFIER_POINTER (id
);
4007 /* All builtins that don't begin with an '_' should additionally
4008 go in the 'std' namespace. */
4011 tree decl2
= copy_node(decl
);
4012 push_namespace (std_identifier
);
4013 builtin_function_1 (decl2
, std_node
, true);
4017 return builtin_function_1 (decl
, NULL_TREE
, true);
4020 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4021 function. Not called directly. */
4024 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4027 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4028 DECL_EXTERNAL (fn
) = 1;
4029 TREE_PUBLIC (fn
) = 1;
4030 DECL_ARTIFICIAL (fn
) = 1;
4031 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4032 SET_DECL_LANGUAGE (fn
, lang_c
);
4033 /* Runtime library routines are, by definition, available in an
4034 external shared object. */
4035 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4036 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4037 set_call_expr_flags (fn
, ecf_flags
);
4041 /* Returns the _DECL for a library function with C++ linkage. */
4044 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4047 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4048 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4049 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4053 /* Like build_library_fn, but takes a C string instead of an
4057 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4059 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4062 /* Like build_cp_library_fn, but takes a C string instead of an
4066 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4068 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4072 /* Like build_library_fn, but also pushes the function so that we will
4073 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4074 may throw exceptions listed in RAISES. */
4077 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4082 type
= build_exception_variant (type
, raises
);
4084 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4085 pushdecl_top_level (fn
);
4089 /* Like build_cp_library_fn, but also pushes the function so that it
4090 will be found by normal lookup. */
4093 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4096 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4101 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4105 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4109 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4111 tree type
= build_function_type (void_type_node
, parmtypes
);
4112 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4115 /* Like push_library_fn, but also note that this function throws
4116 and does not return. Used for __throw_foo and the like. */
4119 push_throw_library_fn (tree name
, tree type
)
4121 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4125 /* When we call finish_struct for an anonymous union, we create
4126 default copy constructors and such. But, an anonymous union
4127 shouldn't have such things; this function undoes the damage to the
4128 anonymous union type T.
4130 (The reason that we create the synthesized methods is that we don't
4131 distinguish `union { int i; }' from `typedef union { int i; } U'.
4132 The first is an anonymous union; the second is just an ordinary
4136 fixup_anonymous_aggr (tree t
)
4140 /* Wipe out memory of synthesized methods. */
4141 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4142 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4143 TYPE_HAS_COPY_CTOR (t
) = 0;
4144 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4145 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4146 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4148 /* Splice the implicitly generated functions out of the TYPE_METHODS
4150 q
= &TYPE_METHODS (t
);
4153 if (DECL_ARTIFICIAL (*q
))
4154 *q
= TREE_CHAIN (*q
);
4156 q
= &DECL_CHAIN (*q
);
4159 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4160 if (TYPE_METHODS (t
))
4162 tree decl
= TYPE_MAIN_DECL (t
);
4164 if (TREE_CODE (t
) != UNION_TYPE
)
4165 error_at (DECL_SOURCE_LOCATION (decl
),
4166 "an anonymous struct cannot have function members");
4168 error_at (DECL_SOURCE_LOCATION (decl
),
4169 "an anonymous union cannot have function members");
4172 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4173 assignment operators (because they cannot have these methods themselves).
4174 For anonymous unions this is already checked because they are not allowed
4175 in any union, otherwise we have to check it. */
4176 if (TREE_CODE (t
) != UNION_TYPE
)
4180 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4181 if (TREE_CODE (field
) == FIELD_DECL
)
4183 type
= TREE_TYPE (field
);
4184 if (CLASS_TYPE_P (type
))
4186 if (TYPE_NEEDS_CONSTRUCTING (type
))
4187 error ("member %q+#D with constructor not allowed "
4188 "in anonymous aggregate", field
);
4189 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4190 error ("member %q+#D with destructor not allowed "
4191 "in anonymous aggregate", field
);
4192 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4193 error ("member %q+#D with copy assignment operator "
4194 "not allowed in anonymous aggregate", field
);
4200 /* Warn for an attribute located at LOCATION that appertains to the
4201 class type CLASS_TYPE that has not been properly placed after its
4202 class-key, in it class-specifier. */
4205 warn_misplaced_attr_for_class_type (source_location location
,
4208 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4210 warning_at (location
, OPT_Wattributes
,
4211 "attribute ignored in declaration "
4212 "of %q#T", class_type
);
4214 "attribute for %q#T must follow the %qs keyword",
4215 class_type
, class_key_or_enum_as_string (class_type
));
4218 /* Make sure that a declaration with no declarator is well-formed, i.e.
4219 just declares a tagged type or anonymous union.
4221 Returns the type declared; or NULL_TREE if none. */
4224 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4225 bool explicit_type_instantiation_p
)
4227 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4228 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4229 /* If a class, struct, or enum type is declared by the DECLSPECS
4230 (i.e, if a class-specifier, enum-specifier, or non-typename
4231 elaborated-type-specifier appears in the DECLSPECS),
4232 DECLARED_TYPE is set to the corresponding type. */
4233 tree declared_type
= NULL_TREE
;
4234 bool error_p
= false;
4236 if (declspecs
->multiple_types_p
)
4237 error ("multiple types in one declaration");
4238 else if (declspecs
->redefined_builtin_type
)
4240 if (!in_system_header
)
4241 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4242 "redeclaration of C++ built-in type %qT",
4243 declspecs
->redefined_builtin_type
);
4248 && TYPE_P (declspecs
->type
)
4249 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4250 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4251 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4252 declared_type
= declspecs
->type
;
4253 else if (declspecs
->type
== error_mark_node
)
4255 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4256 permerror (input_location
, "declaration does not declare anything");
4257 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4259 error ("%<auto%> can only be specified for variables "
4260 "or function declarations");
4261 return error_mark_node
;
4263 /* Check for an anonymous union. */
4264 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4265 && TYPE_ANONYMOUS_P (declared_type
))
4267 /* 7/3 In a simple-declaration, the optional init-declarator-list
4268 can be omitted only when declaring a class (clause 9) or
4269 enumeration (7.2), that is, when the decl-specifier-seq contains
4270 either a class-specifier, an elaborated-type-specifier with
4271 a class-key (9.1), or an enum-specifier. In these cases and
4272 whenever a class-specifier or enum-specifier is present in the
4273 decl-specifier-seq, the identifiers in these specifiers are among
4274 the names being declared by the declaration (as class-name,
4275 enum-names, or enumerators, depending on the syntax). In such
4276 cases, and except for the declaration of an unnamed bit-field (9.6),
4277 the decl-specifier-seq shall introduce one or more names into the
4278 program, or shall redeclare a name introduced by a previous
4279 declaration. [Example:
4280 enum { }; // ill-formed
4281 typedef class { }; // ill-formed
4285 error ("missing type-name in typedef-declaration");
4288 /* Anonymous unions are objects, so they can have specifiers. */;
4289 SET_ANON_AGGR_TYPE_P (declared_type
);
4291 if (TREE_CODE (declared_type
) != UNION_TYPE
&& !in_system_header
)
4292 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4297 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4298 || decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4299 error ("%qs can only be specified for functions",
4300 decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4301 ? "inline" : "virtual");
4303 && (!current_class_type
4304 || current_scope () != current_class_type
))
4305 error ("%<friend%> can only be specified inside a class");
4306 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4307 error ("%<explicit%> can only be specified for constructors");
4308 else if (declspecs
->storage_class
)
4309 error ("a storage class can only be specified for objects "
4311 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
)
4312 || decl_spec_seq_has_spec_p (declspecs
, ds_volatile
)
4313 || decl_spec_seq_has_spec_p (declspecs
, ds_restrict
)
4314 || decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4315 error ("qualifiers can only be specified for objects "
4317 else if (saw_typedef
)
4318 warning (0, "%<typedef%> was ignored in this declaration");
4319 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4320 error ("%<constexpr%> cannot be used for type declarations");
4323 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4326 if (!CLASS_TYPE_P (declared_type
)
4327 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4328 /* For a non-template class, use the name location. */
4329 loc
= location_of (declared_type
);
4331 /* For a template class (an explicit instantiation), use the
4332 current location. */
4333 loc
= input_location
;
4335 if (explicit_type_instantiation_p
)
4336 /* [dcl.attr.grammar]/4:
4338 No attribute-specifier-seq shall appertain to an explicit
4341 warning_at (loc
, OPT_Wattributes
,
4342 "attribute ignored in explicit instantiation %q#T",
4345 "no attribute can be applied to "
4346 "an explicit instantiation");
4349 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4352 return declared_type
;
4355 /* Called when a declaration is seen that contains no names to declare.
4356 If its type is a reference to a structure, union or enum inherited
4357 from a containing scope, shadow that tag name for the current scope
4358 with a forward reference.
4359 If its type defines a new named structure or union
4360 or defines an enum, it is valid but we need not do anything here.
4361 Otherwise, it is an error.
4363 C++: may have to grok the declspecs to learn about static,
4364 complain for anonymous unions.
4366 Returns the TYPE declared -- or NULL_TREE if none. */
4369 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4371 tree t
= check_tag_decl (declspecs
,
4372 /*explicit_type_instantiation_p=*/false);
4377 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4380 /* This is where the variables in an anonymous union are
4381 declared. An anonymous union declaration looks like:
4383 because there is no declarator after the union, the parser
4384 sends that declaration here. */
4385 if (ANON_AGGR_TYPE_P (t
))
4387 fixup_anonymous_aggr (t
);
4389 if (TYPE_FIELDS (t
))
4391 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4392 declspecs
, NORMAL
, 0, NULL
);
4393 finish_anon_union (decl
);
4400 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4403 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4404 const cp_declarator
*declarator
,
4405 bool is_template_arg
)
4409 enum decl_context context
4410 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4411 attrs
= type_specifiers
->attributes
;
4412 type_specifiers
->attributes
= NULL_TREE
;
4413 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4414 if (attrs
&& type
!= error_mark_node
)
4416 if (CLASS_TYPE_P (type
))
4417 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4418 "outside of definition", type
);
4419 else if (MAYBE_CLASS_TYPE_P (type
))
4420 /* A template type parameter or other dependent type. */
4421 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4422 "type %qT without an associated declaration", type
);
4424 cplus_decl_attributes (&type
, attrs
, 0);
4429 /* Process a DECLARATOR for a function-scope variable declaration,
4430 namespace-scope variable declaration, or function declaration.
4431 (Function definitions go through start_function; class member
4432 declarations appearing in the body of the class go through
4433 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4434 If an error occurs, the error_mark_node is returned instead.
4436 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4437 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4438 for an explicitly defaulted function, or SD_DELETED for an explicitly
4439 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4440 implicitly initialized via a default constructor. ATTRIBUTES and
4441 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4443 The scope represented by the context of the returned DECL is pushed
4444 (if it is not the global namespace) and is assigned to
4445 *PUSHED_SCOPE_P. The caller is then responsible for calling
4446 pop_scope on *PUSHED_SCOPE_P if it is set. */
4449 start_decl (const cp_declarator
*declarator
,
4450 cp_decl_specifier_seq
*declspecs
,
4453 tree prefix_attributes
,
4454 tree
*pushed_scope_p
)
4462 *pushed_scope_p
= NULL_TREE
;
4464 /* An object declared as __attribute__((deprecated)) suppresses
4465 warnings of uses of other deprecated items. */
4466 if (lookup_attribute ("deprecated", attributes
))
4467 deprecated_state
= DEPRECATED_SUPPRESS
;
4469 attributes
= chainon (attributes
, prefix_attributes
);
4471 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4474 deprecated_state
= DEPRECATED_NORMAL
;
4476 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4477 || decl
== error_mark_node
)
4478 return error_mark_node
;
4480 context
= CP_DECL_CONTEXT (decl
);
4481 if (context
!= global_namespace
)
4482 *pushed_scope_p
= push_scope (context
);
4485 /* Is it valid for this decl to have an initializer at all?
4486 If not, set INITIALIZED to zero, which will indirectly
4487 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4488 switch (TREE_CODE (decl
))
4491 error ("typedef %qD is initialized (use decltype instead)", decl
);
4492 return error_mark_node
;
4495 if (initialized
== SD_DELETED
)
4496 /* We'll handle the rest of the semantics later, but we need to
4497 set this now so it's visible to duplicate_decls. */
4498 DECL_DELETED_FN (decl
) = 1;
4507 if (! toplevel_bindings_p ()
4508 && DECL_EXTERNAL (decl
))
4509 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4511 DECL_EXTERNAL (decl
) = 0;
4512 if (toplevel_bindings_p ())
4513 TREE_STATIC (decl
) = 1;
4515 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4517 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4518 record_key_method_defined (decl
);
4520 /* If this is a typedef that names the class for linkage purposes
4521 (7.1.3p8), apply any attributes directly to the type. */
4522 if (TREE_CODE (decl
) == TYPE_DECL
4523 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4524 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4525 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4529 /* Set attributes here so if duplicate decl, will have proper attributes. */
4530 cplus_decl_attributes (&decl
, attributes
, flags
);
4532 /* Dllimported symbols cannot be defined. Static data members (which
4533 can be initialized in-class and dllimported) go through grokfield,
4534 not here, so we don't need to exclude those decls when checking for
4536 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4538 error ("definition of %q#D is marked %<dllimport%>", decl
);
4539 DECL_DLLIMPORT_P (decl
) = 0;
4542 /* If #pragma weak was used, mark the decl weak now. */
4543 if (!processing_template_decl
)
4544 maybe_apply_pragma_weak (decl
);
4546 if (TREE_CODE (decl
) == FUNCTION_DECL
4547 && DECL_DECLARED_INLINE_P (decl
)
4548 && DECL_UNINLINABLE (decl
)
4549 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4550 warning (0, "inline function %q+D given attribute noinline", decl
);
4552 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4556 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4557 if (field
== NULL_TREE
|| !VAR_P (field
))
4558 error ("%q#D is not a static member of %q#T", decl
, context
);
4561 if (DECL_CONTEXT (field
) != context
)
4563 if (!same_type_p (DECL_CONTEXT (field
), context
))
4564 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4565 "to be defined as %<%T::%D%>",
4566 DECL_CONTEXT (field
), DECL_NAME (decl
),
4567 context
, DECL_NAME (decl
));
4568 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4570 /* Static data member are tricky; an in-class initialization
4571 still doesn't provide a definition, so the in-class
4572 declaration will have DECL_EXTERNAL set, but will have an
4573 initialization. Thus, duplicate_decls won't warn
4574 about this situation, and so we check here. */
4575 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4576 error ("duplicate initialization of %qD", decl
);
4577 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4579 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4580 && !DECL_DECLARED_CONSTEXPR_P (field
))
4581 error ("%qD declared %<constexpr%> outside its class", field
);
4586 tree field
= check_classfn (context
, decl
,
4587 (processing_template_decl
4588 > template_class_depth (context
))
4589 ? current_template_parms
4591 if (field
&& field
!= error_mark_node
4592 && duplicate_decls (decl
, field
,
4593 /*newdecl_is_friend=*/false))
4597 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4598 DECL_IN_AGGR_P (decl
) = 0;
4599 /* Do not mark DECL as an explicit specialization if it was not
4600 already marked as an instantiation; a declaration should
4601 never be marked as a specialization unless we know what
4602 template is being specialized. */
4603 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4605 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4607 /* [temp.expl.spec] An explicit specialization of a static data
4608 member of a template is a definition if the declaration
4609 includes an initializer; otherwise, it is a declaration.
4611 We check for processing_specialization so this only applies
4612 to the new specialization syntax. */
4613 if (!initialized
&& processing_specialization
)
4614 DECL_EXTERNAL (decl
) = 1;
4617 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4618 /* Aliases are definitions. */
4620 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4624 was_public
= TREE_PUBLIC (decl
);
4626 /* Enter this declaration into the symbol table. */
4627 decl
= maybe_push_decl (decl
);
4629 if (processing_template_decl
)
4630 decl
= push_template_decl (decl
);
4631 if (decl
== error_mark_node
)
4632 return error_mark_node
;
4635 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4636 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4638 /* This is a const variable with implicit 'static'. Set
4639 DECL_THIS_STATIC so we can tell it from variables that are
4640 !TREE_PUBLIC because of the anonymous namespace. */
4641 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4642 DECL_THIS_STATIC (decl
) = 1;
4645 if (!processing_template_decl
&& VAR_P (decl
))
4646 start_decl_1 (decl
, initialized
);
4651 /* Process the declaration of a variable DECL. INITIALIZED is true
4652 iff DECL is explicitly initialized. (INITIALIZED is false if the
4653 variable is initialized via an implicitly-called constructor.)
4654 This function must be called for ordinary variables (including, for
4655 example, implicit instantiations of templates), but must not be
4656 called for template declarations. */
4659 start_decl_1 (tree decl
, bool initialized
)
4663 bool aggregate_definition_p
;
4665 gcc_assert (!processing_template_decl
);
4667 if (error_operand_p (decl
))
4670 gcc_assert (VAR_P (decl
));
4672 type
= TREE_TYPE (decl
);
4673 complete_p
= COMPLETE_TYPE_P (type
);
4674 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4676 /* If an explicit initializer is present, or if this is a definition
4677 of an aggregate, then we need a complete type at this point.
4678 (Scalars are always complete types, so there is nothing to
4679 check.) This code just sets COMPLETE_P; errors (if necessary)
4680 are issued below. */
4681 if ((initialized
|| aggregate_definition_p
)
4683 && COMPLETE_TYPE_P (complete_type (type
)))
4686 /* We will not yet have set TREE_READONLY on DECL if the type
4687 was "const", but incomplete, before this point. But, now, we
4688 have a complete type, so we can try again. */
4689 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4693 /* Is it valid for this decl to have an initializer at all? */
4695 /* Don't allow initializations for incomplete types except for
4696 arrays which might be completed by the initialization. */
4698 ; /* A complete type is ok. */
4699 else if (type_uses_auto (type
))
4700 ; /* An auto type is ok. */
4701 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4703 error ("variable %q#D has initializer but incomplete type", decl
);
4704 type
= TREE_TYPE (decl
) = error_mark_node
;
4706 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4708 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4709 error ("elements of array %q#D have incomplete type", decl
);
4710 /* else we already gave an error in start_decl. */
4713 else if (aggregate_definition_p
&& !complete_p
)
4715 if (type_uses_auto (type
))
4716 error ("declaration of %q#D has no initializer", decl
);
4718 error ("aggregate %q#D has incomplete type and cannot be defined",
4720 /* Change the type so that assemble_variable will give
4721 DECL an rtl we can live with: (mem (const_int 0)). */
4722 type
= TREE_TYPE (decl
) = error_mark_node
;
4725 /* Create a new scope to hold this declaration if necessary.
4726 Whether or not a new scope is necessary cannot be determined
4727 until after the type has been completed; if the type is a
4728 specialization of a class template it is not until after
4729 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4730 will be set correctly. */
4731 maybe_push_cleanup_level (type
);
4734 /* Handle initialization of references. DECL, TYPE, and INIT have the
4735 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4736 but will be set to a new CLEANUP_STMT if a temporary is created
4737 that must be destroyed subsequently.
4739 Returns an initializer expression to use to initialize DECL, or
4740 NULL if the initialization can be performed statically.
4742 Quotes on semantics can be found in ARM 8.4.3. */
4745 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4747 if (init
== NULL_TREE
)
4749 if ((DECL_LANG_SPECIFIC (decl
) == 0
4750 || DECL_IN_AGGR_P (decl
) == 0)
4751 && ! DECL_THIS_EXTERN (decl
))
4752 error ("%qD declared as reference but not initialized", decl
);
4756 if (TREE_CODE (init
) == TREE_LIST
)
4757 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4758 tf_warning_or_error
);
4760 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4761 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4762 /* Note: default conversion is only called in very special cases. */
4763 init
= decay_conversion (init
, tf_warning_or_error
);
4765 /* Convert INIT to the reference type TYPE. This may involve the
4766 creation of a temporary, whose lifetime must be the same as that
4767 of the reference. If so, a DECL_EXPR for the temporary will be
4768 added just after the DECL_EXPR for DECL. That's why we don't set
4769 DECL_INITIAL for local references (instead assigning to them
4770 explicitly); we need to allow the temporary to be initialized
4772 return initialize_reference (type
, init
, flags
,
4773 tf_warning_or_error
);
4776 /* Designated initializers in arrays are not supported in GNU C++.
4777 The parser cannot detect this error since it does not know whether
4778 a given brace-enclosed initializer is for a class type or for an
4779 array. This function checks that CE does not use a designated
4780 initializer. If it does, an error is issued. Returns true if CE
4781 is valid, i.e., does not have a designated initializer. */
4784 check_array_designated_initializer (constructor_elt
*ce
,
4785 unsigned HOST_WIDE_INT index
)
4787 /* Designated initializers for array elements are not supported. */
4790 /* The parser only allows identifiers as designated
4792 if (ce
->index
== error_mark_node
)
4794 error ("name used in a GNU-style designated "
4795 "initializer for an array");
4798 else if (identifier_p (ce
->index
))
4800 error ("name %qD used in a GNU-style designated "
4801 "initializer for an array", ce
->index
);
4805 ce
->index
= cxx_constant_value (ce
->index
);
4807 if (TREE_CODE (ce
->index
) == INTEGER_CST
)
4809 /* A C99 designator is OK if it matches the current index. */
4810 if (wi::eq_p (ce
->index
, index
))
4813 sorry ("non-trivial designated initializers not supported");
4824 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4825 array until we finish parsing the initializer. If that's the
4826 situation we're in, update DECL accordingly. */
4829 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4831 tree type
= TREE_TYPE (decl
);
4833 if (TREE_CODE (type
) == ARRAY_TYPE
4834 && TYPE_DOMAIN (type
) == NULL_TREE
4835 && TREE_CODE (decl
) != TYPE_DECL
)
4837 /* do_default is really a C-ism to deal with tentative definitions.
4838 But let's leave it here to ease the eventual merge. */
4839 int do_default
= !DECL_EXTERNAL (decl
);
4840 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4843 /* Check that there are no designated initializers in INIT, as
4844 those are not supported in GNU C++, and as the middle-end
4845 will crash if presented with a non-numeric designated
4847 if (initializer
&& TREE_CODE (initializer
) == CONSTRUCTOR
)
4849 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
4850 constructor_elt
*ce
;
4852 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
4853 if (!check_array_designated_initializer (ce
, i
))
4859 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4863 error ("initializer fails to determine size of %qD", decl
);
4865 else if (failure
== 2)
4869 error ("array size missing in %qD", decl
);
4871 /* If a `static' var's size isn't known, make it extern as
4872 well as static, so it does not get allocated. If it's not
4873 `static', then don't mark it extern; finish_incomplete_decl
4874 will give it a default size and it will get allocated. */
4875 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4876 DECL_EXTERNAL (decl
) = 1;
4878 else if (failure
== 3)
4880 error ("zero-size array %qD", decl
);
4884 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4886 relayout_decl (decl
);
4890 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4891 any appropriate error messages regarding the layout. */
4894 layout_var_decl (tree decl
)
4898 type
= TREE_TYPE (decl
);
4899 if (type
== error_mark_node
)
4902 /* If we haven't already laid out this declaration, do so now.
4903 Note that we must not call complete type for an external object
4904 because it's type might involve templates that we are not
4905 supposed to instantiate yet. (And it's perfectly valid to say
4906 `extern X x' for some incomplete type `X'.) */
4907 if (!DECL_EXTERNAL (decl
))
4908 complete_type (type
);
4909 if (!DECL_SIZE (decl
)
4910 && TREE_TYPE (decl
) != error_mark_node
4911 && (COMPLETE_TYPE_P (type
)
4912 || (TREE_CODE (type
) == ARRAY_TYPE
4913 && !TYPE_DOMAIN (type
)
4914 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4915 layout_decl (decl
, 0);
4917 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4919 /* An automatic variable with an incomplete type: that is an error.
4920 Don't talk about array types here, since we took care of that
4921 message in grokdeclarator. */
4922 error ("storage size of %qD isn%'t known", decl
);
4923 TREE_TYPE (decl
) = error_mark_node
;
4926 /* Keep this code around in case we later want to control debug info
4927 based on whether a type is "used". (jason 1999-11-11) */
4929 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4930 /* Let debugger know it should output info for this type. */
4931 note_debug_info_needed (ttype
);
4933 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4934 note_debug_info_needed (DECL_CONTEXT (decl
));
4937 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4938 && DECL_SIZE (decl
) != NULL_TREE
4939 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4941 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4942 constant_expression_warning (DECL_SIZE (decl
));
4945 error ("storage size of %qD isn%'t constant", decl
);
4946 TREE_TYPE (decl
) = error_mark_node
;
4951 /* If a local static variable is declared in an inline function, or if
4952 we have a weak definition, we must endeavor to create only one
4953 instance of the variable at link-time. */
4956 maybe_commonize_var (tree decl
)
4958 /* Static data in a function with comdat linkage also has comdat
4960 if (TREE_STATIC (decl
)
4961 /* Don't mess with __FUNCTION__. */
4962 && ! DECL_ARTIFICIAL (decl
)
4963 && DECL_FUNCTION_SCOPE_P (decl
)
4964 && vague_linkage_p (DECL_CONTEXT (decl
)))
4968 /* With weak symbols, we simply make the variable COMDAT;
4969 that will cause copies in multiple translations units to
4971 comdat_linkage (decl
);
4975 if (DECL_INITIAL (decl
) == NULL_TREE
4976 || DECL_INITIAL (decl
) == error_mark_node
)
4978 /* Without weak symbols, we can use COMMON to merge
4979 uninitialized variables. */
4980 TREE_PUBLIC (decl
) = 1;
4981 DECL_COMMON (decl
) = 1;
4985 /* While for initialized variables, we must use internal
4986 linkage -- which means that multiple copies will not
4988 TREE_PUBLIC (decl
) = 0;
4989 DECL_COMMON (decl
) = 0;
4990 warning_at (input_location
, 0,
4991 "sorry: semantics of inline function static "
4992 "data %q+#D are wrong (you%'ll wind up "
4993 "with multiple copies)", decl
);
4994 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4995 " you can work around this by removing "
5000 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
5001 /* Set it up again; we might have set DECL_INITIAL since the last
5003 comdat_linkage (decl
);
5006 /* Issue an error message if DECL is an uninitialized const variable. */
5009 check_for_uninitialized_const_var (tree decl
)
5011 tree type
= strip_array_types (TREE_TYPE (decl
));
5013 /* ``Unless explicitly declared extern, a const object does not have
5014 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5017 && TREE_CODE (type
) != REFERENCE_TYPE
5018 && CP_TYPE_CONST_P (type
)
5019 && !DECL_INITIAL (decl
))
5021 tree field
= default_init_uninitialized_part (type
);
5025 permerror (DECL_SOURCE_LOCATION (decl
),
5026 "uninitialized const %qD", decl
);
5028 if (CLASS_TYPE_P (type
))
5030 tree defaulted_ctor
;
5032 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5033 "%q#T has no user-provided default constructor", type
);
5034 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5036 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5037 "constructor is not user-provided because it is "
5038 "explicitly defaulted in the class body");
5039 inform (0, "and the implicitly-defined constructor does not "
5040 "initialize %q+#D", field
);
5045 /* Structure holding the current initializer being processed by reshape_init.
5046 CUR is a pointer to the current element being processed, END is a pointer
5047 after the last element present in the initializer. */
5048 typedef struct reshape_iterator_t
5050 constructor_elt
*cur
;
5051 constructor_elt
*end
;
5054 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5056 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5057 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5058 initialized. If there are no more such fields, the return value
5062 next_initializable_field (tree field
)
5065 && (TREE_CODE (field
) != FIELD_DECL
5066 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5067 || DECL_ARTIFICIAL (field
)))
5068 field
= DECL_CHAIN (field
);
5073 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5074 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5075 INTEGER_CST representing the size of the array minus one (the maximum index),
5076 or NULL_TREE if the array was declared without specifying the size. D is
5077 the iterator within the constructor. */
5080 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5081 tsubst_flags_t complain
)
5084 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5085 unsigned HOST_WIDE_INT max_index_cst
= 0;
5086 unsigned HOST_WIDE_INT index
;
5088 /* The initializer for an array is always a CONSTRUCTOR. */
5089 new_init
= build_constructor (init_list_type_node
, NULL
);
5093 /* Minus 1 is used for zero sized arrays. */
5094 if (integer_all_onesp (max_index
))
5097 if (tree_fits_uhwi_p (max_index
))
5098 max_index_cst
= tree_to_uhwi (max_index
);
5099 /* sizetype is sign extended, not zero extended. */
5101 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5104 /* Loop until there are no more initializers. */
5106 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5110 constructor_elt
*old_cur
= d
->cur
;
5112 check_array_designated_initializer (d
->cur
, index
);
5113 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5115 if (elt_init
== error_mark_node
)
5116 return error_mark_node
;
5117 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5118 size_int (index
), elt_init
);
5119 if (!TREE_CONSTANT (elt_init
))
5120 TREE_CONSTANT (new_init
) = false;
5122 /* This can happen with an invalid initializer (c++/54501). */
5123 if (d
->cur
== old_cur
&& !sized_array_p
)
5130 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5131 Parameters are the same of reshape_init_r. */
5134 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5136 tree max_index
= NULL_TREE
;
5138 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5140 if (TYPE_DOMAIN (type
))
5141 max_index
= array_type_nelts (type
);
5143 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5146 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5147 Parameters are the same of reshape_init_r. */
5150 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5152 tree max_index
= NULL_TREE
;
5154 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
5156 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5158 tree value
= d
->cur
->value
;
5159 if (!same_type_p (TREE_TYPE (value
), type
))
5161 if (complain
& tf_error
)
5162 error ("invalid type %qT as initializer for a vector of type %qT",
5163 TREE_TYPE (d
->cur
->value
), type
);
5164 value
= error_mark_node
;
5170 /* For a vector, we initialize it as an array of the appropriate size. */
5171 if (TREE_CODE (type
) == VECTOR_TYPE
)
5172 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5174 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5177 /* Subroutine of reshape_init_r, processes the initializers for classes
5178 or union. Parameters are the same of reshape_init_r. */
5181 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5182 tsubst_flags_t complain
)
5187 gcc_assert (CLASS_TYPE_P (type
));
5189 /* The initializer for a class is always a CONSTRUCTOR. */
5190 new_init
= build_constructor (init_list_type_node
, NULL
);
5191 field
= next_initializable_field (TYPE_FIELDS (type
));
5197 An initializer for an aggregate member that is an
5198 empty class shall have the form of an empty
5199 initializer-list {}. */
5200 if (!first_initializer_p
)
5202 if (complain
& tf_error
)
5203 error ("initializer for %qT must be brace-enclosed", type
);
5204 return error_mark_node
;
5209 /* Loop through the initializable fields, gathering initializers. */
5210 while (d
->cur
!= d
->end
)
5213 constructor_elt
*old_cur
= d
->cur
;
5215 /* Handle designated initializers, as an extension. */
5218 if (d
->cur
->index
== error_mark_node
)
5219 return error_mark_node
;
5221 if (TREE_CODE (d
->cur
->index
) == INTEGER_CST
)
5223 if (complain
& tf_error
)
5224 error ("%<[%E] =%> used in a GNU-style designated initializer"
5225 " for class %qT", d
->cur
->index
, type
);
5226 return error_mark_node
;
5229 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5230 /* We already reshaped this. */
5231 gcc_assert (d
->cur
->index
== field
);
5233 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5235 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5237 if (complain
& tf_error
)
5238 error ("%qT has no non-static data member named %qD", type
,
5240 return error_mark_node
;
5244 /* If we processed all the member of the class, we are done. */
5248 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5249 /*first_initializer_p=*/false, complain
);
5250 if (field_init
== error_mark_node
)
5251 return error_mark_node
;
5253 if (d
->cur
== old_cur
&& d
->cur
->index
)
5255 /* This can happen with an invalid initializer for a flexible
5256 array member (c++/54441). */
5257 if (complain
& tf_error
)
5258 error ("invalid initializer for %q#D", field
);
5259 return error_mark_node
;
5262 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5266 When a union is initialized with a brace-enclosed
5267 initializer, the braces shall only contain an
5268 initializer for the first member of the union. */
5269 if (TREE_CODE (type
) == UNION_TYPE
)
5272 field
= next_initializable_field (DECL_CHAIN (field
));
5278 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5279 designators are not valid; either complain or return true to indicate
5280 that reshape_init_r should return error_mark_node. */
5283 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5287 if (complain
& tf_error
)
5288 error ("C99 designator %qE outside aggregate initializer",
5296 /* Subroutine of reshape_init, which processes a single initializer (part of
5297 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5298 iterator within the CONSTRUCTOR which points to the initializer to process.
5299 FIRST_INITIALIZER_P is true if this is the first initializer of the
5300 outermost CONSTRUCTOR node. */
5303 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5304 tsubst_flags_t complain
)
5306 tree init
= d
->cur
->value
;
5308 if (error_operand_p (init
))
5309 return error_mark_node
;
5311 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5312 && has_designator_problem (d
, complain
))
5313 return error_mark_node
;
5315 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5317 /* A complex type can be initialized from one or two initializers,
5318 but braces are not elided. */
5320 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5322 if (CONSTRUCTOR_NELTS (init
) > 2)
5324 if (complain
& tf_error
)
5325 error ("too many initializers for %qT", type
);
5327 return error_mark_node
;
5330 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5332 vec
<constructor_elt
, va_gc
> *v
= 0;
5333 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5334 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5335 if (has_designator_problem (d
, complain
))
5336 return error_mark_node
;
5338 init
= build_constructor (init_list_type_node
, v
);
5343 /* A non-aggregate type is always initialized with a single
5345 if (!CP_AGGREGATE_TYPE_P (type
))
5347 /* It is invalid to initialize a non-aggregate type with a
5348 brace-enclosed initializer before C++0x.
5349 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5350 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5351 a CONSTRUCTOR (with a record type). */
5352 if (TREE_CODE (init
) == CONSTRUCTOR
5353 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5355 if (SCALAR_TYPE_P (type
))
5357 if (complain
& tf_error
)
5358 error ("braces around scalar initializer for type %qT", type
);
5359 init
= error_mark_node
;
5362 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5371 All implicit type conversions (clause _conv_) are considered when
5372 initializing the aggregate member with an initializer from an
5373 initializer-list. If the initializer can initialize a member,
5374 the member is initialized. Otherwise, if the member is itself a
5375 non-empty subaggregate, brace elision is assumed and the
5376 initializer is considered for the initialization of the first
5377 member of the subaggregate. */
5378 if (TREE_CODE (init
) != CONSTRUCTOR
5379 /* But don't try this for the first initializer, since that would be
5380 looking through the outermost braces; A a2 = { a1 }; is not a
5381 valid aggregate initialization. */
5382 && !first_initializer_p
5383 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5384 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5391 /* [dcl.init.string]
5393 A char array (whether plain char, signed char, or unsigned char)
5394 can be initialized by a string-literal (optionally enclosed in
5395 braces); a wchar_t array can be initialized by a wide
5396 string-literal (optionally enclosed in braces). */
5397 if (TREE_CODE (type
) == ARRAY_TYPE
5398 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5400 tree str_init
= init
;
5402 /* Strip one level of braces if and only if they enclose a single
5403 element (as allowed by [dcl.init.string]). */
5404 if (!first_initializer_p
5405 && TREE_CODE (str_init
) == CONSTRUCTOR
5406 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5408 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5411 /* If it's a string literal, then it's the initializer for the array
5412 as a whole. Otherwise, continue with normal initialization for
5413 array types (one value per array element). */
5414 if (TREE_CODE (str_init
) == STRING_CST
)
5416 if (has_designator_problem (d
, complain
))
5417 return error_mark_node
;
5423 /* The following cases are about aggregates. If we are not within a full
5424 initializer already, and there is not a CONSTRUCTOR, it means that there
5425 is a missing set of braces (that is, we are processing the case for
5426 which reshape_init exists). */
5427 if (!first_initializer_p
)
5429 if (TREE_CODE (init
) == CONSTRUCTOR
)
5431 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5432 /* There is no need to reshape pointer-to-member function
5433 initializers, as they are always constructed correctly
5434 by the front end. */
5436 else if (COMPOUND_LITERAL_P (init
))
5437 /* For a nested compound literal, there is no need to reshape since
5438 brace elision is not allowed. Even if we decided to allow it,
5439 we should add a call to reshape_init in finish_compound_literal,
5440 before calling digest_init, so changing this code would still
5441 not be necessary. */
5442 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5446 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5447 return reshape_init (type
, init
, complain
);
5451 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5455 /* Dispatch to specialized routines. */
5456 if (CLASS_TYPE_P (type
))
5457 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5458 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5459 return reshape_init_array (type
, d
, complain
);
5460 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5461 return reshape_init_vector (type
, d
, complain
);
5466 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5467 brace-enclosed aggregate initializer.
5469 INIT is the CONSTRUCTOR containing the list of initializers describing
5470 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5471 It may not presently match the shape of the TYPE; for example:
5473 struct S { int a; int b; };
5474 struct S a[] = { 1, 2, 3, 4 };
5476 Here INIT will hold a vector of four elements, rather than a
5477 vector of two elements, each itself a vector of two elements. This
5478 routine transforms INIT from the former form into the latter. The
5479 revised CONSTRUCTOR node is returned. */
5482 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5484 vec
<constructor_elt
, va_gc
> *v
;
5488 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5490 v
= CONSTRUCTOR_ELTS (init
);
5492 /* An empty constructor does not need reshaping, and it is always a valid
5494 if (vec_safe_is_empty (v
))
5497 /* Recurse on this CONSTRUCTOR. */
5499 d
.end
= d
.cur
+ v
->length ();
5501 new_init
= reshape_init_r (type
, &d
, true, complain
);
5502 if (new_init
== error_mark_node
)
5503 return error_mark_node
;
5505 /* Make sure all the element of the constructor were used. Otherwise,
5506 issue an error about exceeding initializers. */
5509 if (complain
& tf_error
)
5510 error ("too many initializers for %qT", type
);
5512 return error_mark_node
;
5518 /* Verify array initializer. Returns true if errors have been reported. */
5521 check_array_initializer (tree decl
, tree type
, tree init
)
5523 tree element_type
= TREE_TYPE (type
);
5525 /* The array type itself need not be complete, because the
5526 initializer may tell us how many elements are in the array.
5527 But, the elements of the array must be complete. */
5528 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5531 error ("elements of array %q#D have incomplete type", decl
);
5533 error ("elements of array %q#T have incomplete type", type
);
5536 /* A compound literal can't have variable size. */
5538 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5539 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5541 error ("variable-sized compound literal");
5547 /* Subroutine of check_initializer; args are passed down from that function.
5548 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5551 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5554 gcc_assert (stmts_are_full_exprs_p ());
5555 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5558 /* Verify INIT (the initializer for DECL), and record the
5559 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5560 grok_reference_init.
5562 If the return value is non-NULL, it is an expression that must be
5563 evaluated dynamically to initialize DECL. */
5566 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5568 tree type
= TREE_TYPE (decl
);
5569 tree init_code
= NULL
;
5570 tree extra_init
= NULL_TREE
;
5573 /* Things that are going to be initialized need to have complete
5575 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5577 if (DECL_HAS_VALUE_EXPR_P (decl
))
5579 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5580 it doesn't have storage to be initialized. */
5581 gcc_assert (init
== NULL_TREE
);
5585 if (type
== error_mark_node
)
5586 /* We will have already complained. */
5589 if (TREE_CODE (type
) == ARRAY_TYPE
)
5591 if (check_array_initializer (decl
, type
, init
))
5594 else if (!COMPLETE_TYPE_P (type
))
5596 error ("%q#D has incomplete type", decl
);
5597 TREE_TYPE (decl
) = error_mark_node
;
5601 /* There is no way to make a variable-sized class type in GNU C++. */
5602 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5604 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5606 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5607 if (SCALAR_TYPE_P (type
))
5611 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5612 init
= build_zero_init (type
, NULL_TREE
, false);
5614 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5616 error ("scalar object %qD requires one element in initializer",
5618 TREE_TYPE (decl
) = error_mark_node
;
5624 if (TREE_CODE (decl
) == CONST_DECL
)
5626 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5628 DECL_INITIAL (decl
) = init
;
5630 gcc_assert (init
!= NULL_TREE
);
5633 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5635 else if (init
|| type_build_ctor_call (type
)
5636 || TREE_CODE (type
) == REFERENCE_TYPE
)
5638 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5640 init
= grok_reference_init (decl
, type
, init
, flags
);
5641 flags
|= LOOKUP_ALREADY_DIGESTED
;
5644 check_for_uninitialized_const_var (decl
);
5645 /* Do not reshape constructors of vectors (they don't need to be
5647 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5649 if (is_std_init_list (type
))
5651 init
= perform_implicit_conversion (type
, init
,
5652 tf_warning_or_error
);
5653 flags
|= LOOKUP_ALREADY_DIGESTED
;
5655 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5657 /* Don't reshape if the class has constructors. */
5658 if (cxx_dialect
== cxx98
)
5659 error ("in C++98 %qD must be initialized by constructor, "
5663 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5665 error ("opaque vector types cannot be initialized");
5666 init
= error_mark_node
;
5670 init
= reshape_init (type
, init
, tf_warning_or_error
);
5671 if (SCALAR_TYPE_P (type
))
5672 check_narrowing (type
, init
);
5676 /* If DECL has an array type without a specific bound, deduce the
5677 array size from the initializer. */
5678 maybe_deduce_size_from_array_init (decl
, init
);
5679 type
= TREE_TYPE (decl
);
5680 if (type
== error_mark_node
)
5683 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5684 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5685 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5686 && CP_AGGREGATE_TYPE_P (type
)
5687 && (CLASS_TYPE_P (type
)
5688 || !TYPE_NEEDS_CONSTRUCTING (type
)
5689 || type_has_extended_temps (type
))))
5691 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5693 /* A constructor call is a non-trivial initializer even if
5694 it isn't explicitly written. */
5695 if (TREE_SIDE_EFFECTS (init_code
))
5696 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5698 /* If this is a constexpr initializer, expand_default_init will
5699 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5700 case, pull the initializer back out and pass it down into
5701 store_init_value. */
5702 while (TREE_CODE (init_code
) == EXPR_STMT
5703 || TREE_CODE (init_code
) == CONVERT_EXPR
)
5704 init_code
= TREE_OPERAND (init_code
, 0);
5705 if (TREE_CODE (init_code
) == INIT_EXPR
)
5707 init
= TREE_OPERAND (init_code
, 1);
5708 init_code
= NULL_TREE
;
5709 /* Don't call digest_init; it's unnecessary and will complain
5710 about aggregate initialization of non-aggregate classes. */
5711 flags
|= LOOKUP_ALREADY_DIGESTED
;
5713 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
5715 /* Declared constexpr, but no suitable initializer; massage
5716 init appropriately so we can pass it into store_init_value
5718 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5719 init
= finish_compound_literal (type
, init
,
5720 tf_warning_or_error
);
5721 else if (CLASS_TYPE_P (type
)
5722 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
5724 init
= build_functional_cast (type
, init
, tf_none
);
5725 if (TREE_CODE (init
) == TARGET_EXPR
)
5726 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
5728 init_code
= NULL_TREE
;
5734 if (init
&& TREE_CODE (init
) != TREE_VEC
)
5736 /* In aggregate initialization of a variable, each element
5737 initialization is a full-expression because there is no
5738 enclosing expression. */
5739 gcc_assert (stmts_are_full_exprs_p ());
5741 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
5743 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5744 && DECL_INITIAL (decl
)
5745 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5746 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5747 warning (0, "array %qD initialized by parenthesized string literal %qE",
5748 decl
, DECL_INITIAL (decl
));
5754 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
5755 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
5756 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
5757 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
5760 check_for_uninitialized_const_var (decl
);
5763 if (init
&& init
!= error_mark_node
)
5764 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5767 init_code
= add_stmt_to_compound (extra_init
, init_code
);
5769 if (init_code
&& DECL_IN_AGGR_P (decl
))
5771 static int explained
= 0;
5773 if (cxx_dialect
< cxx11
)
5774 error ("initializer invalid for static member with constructor");
5776 error ("non-constant in-class initialization invalid for static "
5777 "member %qD", decl
);
5780 error ("(an out of class initialization is required)");
5788 /* If DECL is not a local variable, give it RTL. */
5791 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5793 int toplev
= toplevel_bindings_p ();
5795 const char *filename
;
5797 /* Set the DECL_ASSEMBLER_NAME for the object. */
5800 /* The `register' keyword, when used together with an
5801 asm-specification, indicates that the variable should be
5802 placed in a particular register. */
5803 if (VAR_P (decl
) && DECL_REGISTER (decl
))
5805 set_user_assembler_name (decl
, asmspec
);
5806 DECL_HARD_REGISTER (decl
) = 1;
5810 if (TREE_CODE (decl
) == FUNCTION_DECL
5811 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5812 set_builtin_user_assembler_name (decl
, asmspec
);
5813 set_user_assembler_name (decl
, asmspec
);
5817 /* Handle non-variables up front. */
5820 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5824 /* If we see a class member here, it should be a static data
5826 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5828 gcc_assert (TREE_STATIC (decl
));
5829 /* An in-class declaration of a static data member should be
5830 external; it is only a declaration, and not a definition. */
5831 if (init
== NULL_TREE
)
5832 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5835 /* We don't create any RTL for local variables. */
5836 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5839 /* We defer emission of local statics until the corresponding
5840 DECL_EXPR is expanded. */
5841 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5843 /* We try to defer namespace-scope static constants so that they are
5844 not emitted into the object file unnecessarily. */
5845 filename
= input_filename
;
5846 if (!DECL_VIRTUAL_P (decl
)
5847 && TREE_READONLY (decl
)
5848 && DECL_INITIAL (decl
) != NULL_TREE
5849 && DECL_INITIAL (decl
) != error_mark_node
5851 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5853 && !TREE_PUBLIC (decl
))
5855 /* Fool with the linkage of static consts according to #pragma
5857 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5858 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5860 TREE_PUBLIC (decl
) = 1;
5861 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5866 /* Likewise for template instantiations. */
5867 else if (DECL_LANG_SPECIFIC (decl
)
5868 && DECL_IMPLICIT_INSTANTIATION (decl
))
5871 /* If we're not deferring, go ahead and assemble the variable. */
5873 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5876 /* walk_tree helper for wrap_temporary_cleanups, below. */
5879 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5881 /* Stop at types or full-expression boundaries. */
5882 if (TYPE_P (*stmt_p
)
5883 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
5889 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5891 tree guard
= (tree
)data
;
5892 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5894 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5895 /* Tell honor_protect_cleanup_actions to handle this as a separate
5897 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5899 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5905 /* We're initializing a local variable which has a cleanup GUARD. If there
5906 are any temporaries used in the initializer INIT of this variable, we
5907 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5908 variable will be cleaned up properly if one of them throws.
5910 Unfortunately, there's no way to express this properly in terms of
5911 nesting, as the regions for the temporaries overlap the region for the
5912 variable itself; if there are two temporaries, the variable needs to be
5913 the first thing destroyed if either of them throws. However, we only
5914 want to run the variable's cleanup if it actually got constructed. So
5915 we need to guard the temporary cleanups with the variable's cleanup if
5916 they are run on the normal path, but not if they are run on the
5917 exceptional path. We implement this by telling
5918 honor_protect_cleanup_actions to strip the variable cleanup from the
5919 exceptional path. */
5922 wrap_temporary_cleanups (tree init
, tree guard
)
5924 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5927 /* Generate code to initialize DECL (a local variable). */
5930 initialize_local_var (tree decl
, tree init
)
5932 tree type
= TREE_TYPE (decl
);
5936 gcc_assert (VAR_P (decl
)
5937 || TREE_CODE (decl
) == RESULT_DECL
);
5938 gcc_assert (!TREE_STATIC (decl
));
5940 if (DECL_SIZE (decl
) == NULL_TREE
)
5942 /* If we used it already as memory, it must stay in memory. */
5943 DECL_INITIAL (decl
) = NULL_TREE
;
5944 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5948 if (type
== error_mark_node
)
5951 /* Compute and store the initial value. */
5952 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5953 if (TREE_USED (type
))
5954 DECL_READ_P (decl
) = 1;
5956 /* Generate a cleanup, if necessary. */
5957 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
5959 /* Perform the initialization. */
5962 if (TREE_CODE (init
) == INIT_EXPR
5963 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init
, 1)))
5965 /* Stick simple initializers in DECL_INITIAL so that
5966 -Wno-init-self works (c++/34772). */
5967 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
5968 DECL_INITIAL (decl
) = TREE_OPERAND (init
, 1);
5972 int saved_stmts_are_full_exprs_p
;
5974 /* If we're only initializing a single object, guard the
5975 destructors of any temporaries used in its initializer with
5976 its destructor. This isn't right for arrays because each
5977 element initialization is a full-expression. */
5978 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
5979 wrap_temporary_cleanups (init
, cleanup
);
5981 gcc_assert (building_stmt_list_p ());
5982 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5983 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5984 finish_expr_stmt (init
);
5985 current_stmt_tree ()->stmts_are_full_exprs_p
=
5986 saved_stmts_are_full_exprs_p
;
5990 /* Set this to 0 so we can tell whether an aggregate which was
5991 initialized was ever used. Don't do this if it has a
5992 destructor, so we don't complain about the 'resource
5993 allocation is initialization' idiom. Now set
5994 attribute((unused)) on types so decls of that type will be
5995 marked used. (see TREE_USED, above.) */
5996 if (TYPE_NEEDS_CONSTRUCTING (type
)
5998 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
5999 && DECL_NAME (decl
))
6000 TREE_USED (decl
) = 0;
6001 else if (already_used
)
6002 TREE_USED (decl
) = 1;
6005 finish_decl_cleanup (decl
, cleanup
);
6008 /* DECL is a VAR_DECL for a compiler-generated variable with static
6009 storage duration (like a virtual table) whose initializer is a
6010 compile-time constant. Initialize the variable and provide it to the
6014 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6017 gcc_assert (DECL_ARTIFICIAL (decl
));
6018 init
= build_constructor (TREE_TYPE (decl
), v
);
6019 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6020 DECL_INITIAL (decl
) = init
;
6021 DECL_INITIALIZED_P (decl
) = 1;
6022 determine_visibility (decl
);
6023 layout_var_decl (decl
);
6024 maybe_commonize_var (decl
);
6025 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6028 /* INIT is the initializer for a variable, as represented by the
6029 parser. Returns true iff INIT is type-dependent. */
6032 type_dependent_init_p (tree init
)
6034 if (TREE_CODE (init
) == TREE_LIST
)
6035 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6036 return any_type_dependent_elements_p (init
);
6037 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6038 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6040 vec
<constructor_elt
, va_gc
> *elts
;
6044 elts
= CONSTRUCTOR_ELTS (init
);
6045 nelts
= vec_safe_length (elts
);
6046 for (i
= 0; i
< nelts
; ++i
)
6047 if (type_dependent_init_p ((*elts
)[i
].value
))
6051 /* It must be a simple expression, e.g., int i = 3; */
6052 return type_dependent_expression_p (init
);
6057 /* INIT is the initializer for a variable, as represented by the
6058 parser. Returns true iff INIT is value-dependent. */
6061 value_dependent_init_p (tree init
)
6063 if (TREE_CODE (init
) == TREE_LIST
)
6064 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6065 return any_value_dependent_elements_p (init
);
6066 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6067 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6069 vec
<constructor_elt
, va_gc
> *elts
;
6073 elts
= CONSTRUCTOR_ELTS (init
);
6074 nelts
= vec_safe_length (elts
);
6075 for (i
= 0; i
< nelts
; ++i
)
6076 if (value_dependent_init_p ((*elts
)[i
].value
))
6080 /* It must be a simple expression, e.g., int i = 3; */
6081 return value_dependent_expression_p (init
);
6086 /* Finish processing of a declaration;
6087 install its line number and initial value.
6088 If the length of an array type is not known before,
6089 it must be determined now, from the initial value, or it is an error.
6091 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6092 true, then INIT is an integral constant expression.
6094 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6095 if the (init) syntax was used. */
6098 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6099 tree asmspec_tree
, int flags
)
6102 vec
<tree
, va_gc
> *cleanups
= NULL
;
6103 const char *asmspec
= NULL
;
6104 int was_readonly
= 0;
6105 bool var_definition_p
= false;
6108 if (decl
== error_mark_node
)
6113 error ("assignment (not initialization) in declaration");
6117 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6118 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6119 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6121 type
= TREE_TYPE (decl
);
6122 if (type
== error_mark_node
)
6125 /* If a name was specified, get the string. */
6126 if (at_namespace_scope_p ())
6127 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6128 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6129 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6131 if (current_class_type
6132 && CP_DECL_CONTEXT (decl
) == current_class_type
6133 && TYPE_BEING_DEFINED (current_class_type
)
6134 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6135 && (DECL_INITIAL (decl
) || init
))
6136 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6138 if (TREE_CODE (decl
) != FUNCTION_DECL
6139 && (auto_node
= type_uses_auto (type
)))
6142 if (init
== NULL_TREE
)
6144 if (DECL_LANG_SPECIFIC (decl
)
6145 && DECL_TEMPLATE_INSTANTIATION (decl
)
6146 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6148 /* init is null because we're deferring instantiating the
6149 initializer until we need it. Well, we need it now. */
6150 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6154 error ("declaration of %q#D has no initializer", decl
);
6155 TREE_TYPE (decl
) = error_mark_node
;
6159 if (TREE_CODE (d_init
) == TREE_LIST
)
6160 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6161 tf_warning_or_error
);
6162 d_init
= resolve_nondeduced_context (d_init
);
6163 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6165 if (type
== error_mark_node
)
6167 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6170 if (!ensure_literal_type_for_constexpr_object (decl
))
6171 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6174 && DECL_CLASS_SCOPE_P (decl
)
6175 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6176 check_static_variable_definition (decl
, type
);
6178 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6181 if (init
== ridpointers
[(int)RID_DELETE
])
6183 /* FIXME check this is 1st decl. */
6184 DECL_DELETED_FN (decl
) = 1;
6185 DECL_DECLARED_INLINE_P (decl
) = 1;
6186 DECL_INITIAL (decl
) = error_mark_node
;
6187 FOR_EACH_CLONE (clone
, decl
)
6189 DECL_DELETED_FN (clone
) = 1;
6190 DECL_DECLARED_INLINE_P (clone
) = 1;
6191 DECL_INITIAL (clone
) = error_mark_node
;
6195 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6197 if (defaultable_fn_check (decl
))
6198 DECL_DEFAULTED_FN (decl
) = 1;
6200 DECL_INITIAL (decl
) = NULL_TREE
;
6204 if (init
&& VAR_P (decl
))
6206 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6207 /* If DECL is a reference, then we want to know whether init is a
6208 reference constant; init_const_expr_p as passed tells us whether
6209 it's an rvalue constant. */
6210 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6211 init_const_expr_p
= potential_constant_expression (init
);
6212 if (init_const_expr_p
)
6214 /* Set these flags now for templates. We'll update the flags in
6215 store_init_value for instantiations. */
6216 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6217 if (decl_maybe_constant_var_p (decl
))
6218 TREE_CONSTANT (decl
) = 1;
6222 if (processing_template_decl
)
6224 bool type_dependent_p
;
6226 /* Add this declaration to the statement-tree. */
6227 if (at_function_scope_p ())
6228 add_decl_expr (decl
);
6230 type_dependent_p
= dependent_type_p (type
);
6232 if (check_for_bare_parameter_packs (init
))
6235 DECL_INITIAL (decl
) = NULL_TREE
;
6238 /* Generally, initializers in templates are expanded when the
6239 template is instantiated. But, if DECL is a variable constant
6240 then it can be used in future constant expressions, so its value
6241 must be available. */
6243 if (!VAR_P (decl
) || dependent_type_p (type
))
6244 /* We can't do anything if the decl has dependent type. */;
6246 && init_const_expr_p
6247 && !type_dependent_p
6248 && decl_maybe_constant_var_p (decl
)
6249 && !type_dependent_init_p (init
)
6250 && !value_dependent_init_p (init
))
6252 /* This variable seems to be a non-dependent constant, so process
6253 its initializer. If check_initializer returns non-null the
6254 initialization wasn't constant after all. */
6256 cleanups
= make_tree_vector ();
6257 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6258 if (init_code
== NULL_TREE
)
6260 release_tree_vector (cleanups
);
6262 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6264 /* Deduce array size even if the initializer is dependent. */
6265 maybe_deduce_size_from_array_init (decl
, init
);
6266 /* And complain about multiple initializers. */
6267 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6268 && !MAYBE_CLASS_TYPE_P (type
))
6269 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6270 tf_warning_or_error
);
6274 DECL_INITIAL (decl
) = init
;
6278 /* Just store non-static data member initializers for later. */
6279 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6280 DECL_INITIAL (decl
) = init
;
6282 /* Take care of TYPE_DECLs up front. */
6283 if (TREE_CODE (decl
) == TYPE_DECL
)
6285 if (type
!= error_mark_node
6286 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6288 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6289 warning (0, "shadowing previous type declaration of %q#D", decl
);
6290 set_identifier_type_value (DECL_NAME (decl
), decl
);
6293 /* If we have installed this as the canonical typedef for this
6294 type, and that type has not been defined yet, delay emitting
6295 the debug information for it, as we will emit it later. */
6296 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6297 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6298 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6300 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6305 /* A reference will be modified here, as it is initialized. */
6306 if (! DECL_EXTERNAL (decl
)
6307 && TREE_READONLY (decl
)
6308 && TREE_CODE (type
) == REFERENCE_TYPE
)
6311 TREE_READONLY (decl
) = 0;
6316 /* If this is a local variable that will need a mangled name,
6317 register it now. We must do this before processing the
6318 initializer for the variable, since the initialization might
6319 require a guard variable, and since the mangled name of the
6320 guard variable will depend on the mangled name of this
6322 if (DECL_FUNCTION_SCOPE_P (decl
)
6323 && TREE_STATIC (decl
)
6324 && !DECL_ARTIFICIAL (decl
))
6326 push_local_name (decl
);
6327 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6328 || DECL_DESTRUCTOR_P (current_function_decl
))
6329 /* Normally local_decls is populated during GIMPLE lowering,
6330 but [cd]tors are never actually compiled directly. We need
6331 to put statics on the list so we can deal with the label
6332 address extension. FIXME. */
6333 add_local_decl (cfun
, decl
);
6336 /* Convert the initializer to the type of DECL, if we have not
6337 already initialized DECL. */
6338 if (!DECL_INITIALIZED_P (decl
)
6339 /* If !DECL_EXTERNAL then DECL is being defined. In the
6340 case of a static data member initialized inside the
6341 class-specifier, there can be an initializer even if DECL
6342 is *not* defined. */
6343 && (!DECL_EXTERNAL (decl
) || init
))
6345 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6348 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6349 /* Allow libjava/prims.cc define primitive classes. */
6350 if (init
!= NULL_TREE
6351 || jclass
== NULL_TREE
6352 || TREE_CODE (jclass
) != TYPE_DECL
6353 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6354 || !same_type_ignoring_top_level_qualifiers_p
6355 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6356 error ("Java object %qD not allocated with %<new%>", decl
);
6359 cleanups
= make_tree_vector ();
6360 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6366 The memory occupied by any object of static storage
6367 duration is zero-initialized at program startup before
6368 any other initialization takes place.
6370 We cannot create an appropriate initializer until after
6371 the type of DECL is finalized. If DECL_INITIAL is set,
6372 then the DECL is statically initialized, and any
6373 necessary zero-initialization has already been performed. */
6374 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6375 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6376 /*nelts=*/NULL_TREE
,
6377 /*static_storage_p=*/true);
6378 /* Remember that the initialization for this variable has
6380 DECL_INITIALIZED_P (decl
) = 1;
6381 /* This declaration is the definition of this variable,
6382 unless we are initializing a static data member within
6383 the class specifier. */
6384 if (!DECL_EXTERNAL (decl
))
6385 var_definition_p
= true;
6387 /* If the variable has an array type, lay out the type, even if
6388 there is no initializer. It is valid to index through the
6389 array, and we must get TYPE_ALIGN set correctly on the array
6391 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6394 if (TREE_STATIC (decl
)
6395 && !at_function_scope_p ()
6396 && current_function_decl
== NULL
)
6397 /* So decl is a global variable or a static member of a
6398 non local class. Record the types it uses
6399 so that we can decide later to emit debug info for them. */
6400 record_types_used_by_current_var_decl (decl
);
6402 else if (TREE_CODE (decl
) == FIELD_DECL
6403 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6404 error ("non-static data member %qD has Java class type", decl
);
6406 /* Add this declaration to the statement-tree. This needs to happen
6407 after the call to check_initializer so that the DECL_EXPR for a
6408 reference temp is added before the DECL_EXPR for the reference itself. */
6409 if (DECL_FUNCTION_SCOPE_P (decl
))
6410 add_decl_expr (decl
);
6412 /* Let the middle end know about variables and functions -- but not
6413 static data members in uninstantiated class templates. */
6414 if (VAR_OR_FUNCTION_DECL_P (decl
))
6418 layout_var_decl (decl
);
6419 maybe_commonize_var (decl
);
6422 /* This needs to happen after the linkage is set. */
6423 determine_visibility (decl
);
6425 if (var_definition_p
&& TREE_STATIC (decl
))
6427 /* If a TREE_READONLY variable needs initialization
6428 at runtime, it is no longer readonly and we need to
6429 avoid MEM_READONLY_P being set on RTL created for it. */
6432 if (TREE_READONLY (decl
))
6433 TREE_READONLY (decl
) = 0;
6436 else if (was_readonly
)
6437 TREE_READONLY (decl
) = 1;
6439 /* Likewise if it needs destruction. */
6440 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6441 TREE_READONLY (decl
) = 0;
6444 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6446 /* Check for abstractness of the type. Notice that there is no
6447 need to strip array types here since the check for those types
6448 is already done within create_array_type_for_decl. */
6449 abstract_virtuals_error (decl
, type
);
6451 if (TREE_TYPE (decl
) == error_mark_node
)
6452 /* No initialization required. */
6454 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6458 if (init
== ridpointers
[(int)RID_DEFAULT
])
6460 /* An out-of-class default definition is defined at
6461 the point where it is explicitly defaulted. */
6462 if (DECL_DELETED_FN (decl
))
6463 maybe_explain_implicit_delete (decl
);
6464 else if (DECL_INITIAL (decl
) == error_mark_node
)
6465 synthesize_method (decl
);
6468 error ("function %q#D is initialized like a variable", decl
);
6470 /* else no initialization required. */
6472 else if (DECL_EXTERNAL (decl
)
6473 && ! (DECL_LANG_SPECIFIC (decl
)
6474 && DECL_NOT_REALLY_EXTERN (decl
)))
6477 DECL_INITIAL (decl
) = init
;
6479 /* A variable definition. */
6480 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6481 /* Initialize the local variable. */
6482 initialize_local_var (decl
, init
);
6484 /* If a variable is defined, and then a subsequent
6485 definition with external linkage is encountered, we will
6486 get here twice for the same variable. We want to avoid
6487 calling expand_static_init more than once. For variables
6488 that are not static data members, we can call
6489 expand_static_init only when we actually process the
6490 initializer. It is not legal to redeclare a static data
6491 member, so this issue does not arise in that case. */
6492 else if (var_definition_p
&& TREE_STATIC (decl
))
6493 expand_static_init (decl
, init
);
6496 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6497 reference, insert it in the statement-tree now. */
6501 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6502 push_cleanup (decl
, t
, false);
6503 release_tree_vector (cleanups
);
6507 TREE_READONLY (decl
) = 1;
6509 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6512 /* Returns a declaration for a VAR_DECL as if:
6514 extern "C" TYPE NAME;
6516 had been seen. Used to create compiler-generated global
6520 declare_global_var (tree name
, tree type
)
6524 push_to_top_level ();
6525 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6526 TREE_PUBLIC (decl
) = 1;
6527 DECL_EXTERNAL (decl
) = 1;
6528 DECL_ARTIFICIAL (decl
) = 1;
6529 /* If the user has explicitly declared this variable (perhaps
6530 because the code we are compiling is part of a low-level runtime
6531 library), then it is possible that our declaration will be merged
6532 with theirs by pushdecl. */
6533 decl
= pushdecl (decl
);
6534 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6535 pop_from_top_level ();
6540 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6541 if "__cxa_atexit" is not being used) corresponding to the function
6542 to be called when the program exits. */
6545 get_atexit_fn_ptr_type (void)
6549 if (!atexit_fn_ptr_type_node
)
6552 if (flag_use_cxa_atexit
6553 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6554 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6555 arg_type
= ptr_type_node
;
6557 /* The parameter to "atexit" is "void (*)(void)". */
6558 arg_type
= NULL_TREE
;
6560 fn_type
= build_function_type_list (void_type_node
,
6561 arg_type
, NULL_TREE
);
6562 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6565 return atexit_fn_ptr_type_node
;
6568 /* Returns a pointer to the `atexit' function. Note that if
6569 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6570 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6573 get_atexit_node (void)
6579 bool use_aeabi_atexit
;
6584 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6586 /* The declaration for `__cxa_atexit' is:
6588 int __cxa_atexit (void (*)(void *), void *, void *)
6590 We build up the argument types and then the function type
6592 tree argtype0
, argtype1
, argtype2
;
6594 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6595 /* First, build the pointer-to-function type for the first
6597 fn_ptr_type
= get_atexit_fn_ptr_type ();
6598 /* Then, build the rest of the argument types. */
6599 argtype2
= ptr_type_node
;
6600 if (use_aeabi_atexit
)
6602 argtype1
= fn_ptr_type
;
6603 argtype0
= ptr_type_node
;
6607 argtype1
= ptr_type_node
;
6608 argtype0
= fn_ptr_type
;
6610 /* And the final __cxa_atexit type. */
6611 fn_type
= build_function_type_list (integer_type_node
,
6612 argtype0
, argtype1
, argtype2
,
6614 if (use_aeabi_atexit
)
6615 name
= "__aeabi_atexit";
6617 name
= "__cxa_atexit";
6621 /* The declaration for `atexit' is:
6623 int atexit (void (*)());
6625 We build up the argument types and then the function type
6627 fn_ptr_type
= get_atexit_fn_ptr_type ();
6628 /* Build the final atexit type. */
6629 fn_type
= build_function_type_list (integer_type_node
,
6630 fn_ptr_type
, NULL_TREE
);
6634 /* Now, build the function declaration. */
6635 push_lang_context (lang_name_c
);
6636 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
6637 mark_used (atexit_fndecl
);
6638 pop_lang_context ();
6639 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6644 /* Like get_atexit_node, but for thread-local cleanups. */
6647 get_thread_atexit_node (void)
6649 /* The declaration for `__cxa_thread_atexit' is:
6651 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6652 tree fn_type
= build_function_type_list (integer_type_node
,
6653 get_atexit_fn_ptr_type (),
6654 ptr_type_node
, ptr_type_node
,
6657 /* Now, build the function declaration. */
6658 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
6659 ECF_LEAF
| ECF_NOTHROW
);
6660 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6663 /* Returns the __dso_handle VAR_DECL. */
6666 get_dso_handle_node (void)
6668 if (dso_handle_node
)
6669 return dso_handle_node
;
6671 /* Declare the variable. */
6672 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6675 #ifdef HAVE_GAS_HIDDEN
6676 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6677 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6680 return dso_handle_node
;
6683 /* Begin a new function with internal linkage whose job will be simply
6684 to destroy some particular variable. */
6686 static GTY(()) int start_cleanup_cnt
;
6689 start_cleanup_fn (void)
6694 bool use_cxa_atexit
= flag_use_cxa_atexit
6695 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6697 push_to_top_level ();
6699 /* No need to mangle this. */
6700 push_lang_context (lang_name_c
);
6702 /* Build the name of the function. */
6703 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6704 /* Build the function declaration. */
6705 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6706 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6707 /* It's a function with internal linkage, generated by the
6709 TREE_PUBLIC (fndecl
) = 0;
6710 DECL_ARTIFICIAL (fndecl
) = 1;
6711 /* Make the function `inline' so that it is only emitted if it is
6712 actually needed. It is unlikely that it will be inlined, since
6713 it is only called via a function pointer, but we avoid unnecessary
6714 emissions this way. */
6715 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6716 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6717 /* Build the parameter. */
6722 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6723 DECL_CONTEXT (parmdecl
) = fndecl
;
6724 TREE_USED (parmdecl
) = 1;
6725 DECL_READ_P (parmdecl
) = 1;
6726 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6730 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6732 pop_lang_context ();
6734 return current_function_decl
;
6737 /* Finish the cleanup function begun by start_cleanup_fn. */
6740 end_cleanup_fn (void)
6742 expand_or_defer_fn (finish_function (0));
6744 pop_from_top_level ();
6747 /* Generate code to handle the destruction of DECL, an object with
6748 static storage duration. */
6751 register_dtor_fn (tree decl
)
6758 bool ob_parm
, dso_parm
, use_dtor
;
6759 tree arg0
, arg1
, arg2
;
6762 type
= TREE_TYPE (decl
);
6763 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6764 return void_zero_node
;
6766 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
6767 "__aeabi_atexit"), and DECL is a class object, we can just pass the
6768 destructor to "__cxa_atexit"; we don't have to build a temporary
6769 function to do the cleanup. */
6770 dso_parm
= (flag_use_cxa_atexit
6771 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
6772 ob_parm
= (DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
6773 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
6778 /* Find the destructor. */
6779 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6780 gcc_assert (idx
>= 0);
6781 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
6782 /* Make sure it is accessible. */
6783 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
6784 tf_warning_or_error
);
6788 /* Call build_cleanup before we enter the anonymous function so
6789 that any access checks will be done relative to the current
6790 scope, rather than the scope of the anonymous function. */
6791 build_cleanup (decl
);
6793 /* Now start the function. */
6794 cleanup
= start_cleanup_fn ();
6796 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6797 to the original function, rather than the anonymous one. That
6798 will make the back end think that nested functions are in use,
6799 which causes confusion. */
6800 push_deferring_access_checks (dk_no_check
);
6801 fcall
= build_cleanup (decl
);
6802 pop_deferring_access_checks ();
6804 /* Create the body of the anonymous function. */
6805 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6806 finish_expr_stmt (fcall
);
6807 finish_compound_stmt (compound_stmt
);
6811 /* Call atexit with the cleanup function. */
6812 mark_used (cleanup
);
6813 cleanup
= build_address (cleanup
);
6815 if (DECL_THREAD_LOCAL_P (decl
))
6816 atex_node
= get_thread_atexit_node ();
6818 atex_node
= get_atexit_node ();
6822 /* We must convert CLEANUP to the type that "__cxa_atexit"
6824 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6825 /* "__cxa_atexit" will pass the address of DECL to the
6826 cleanup function. */
6828 addr
= build_address (decl
);
6829 /* The declared type of the parameter to "__cxa_atexit" is
6830 "void *". For plain "T*", we could just let the
6831 machinery in cp_build_function_call convert it -- but if the
6832 type is "cv-qualified T *", then we need to convert it
6833 before passing it in, to avoid spurious errors. */
6834 addr
= build_nop (ptr_type_node
, addr
);
6837 /* Since the cleanup functions we build ignore the address
6838 they're given, there's no reason to pass the actual address
6839 in, and, in general, it's cheaper to pass NULL than any
6841 addr
= null_pointer_node
;
6844 arg2
= cp_build_addr_expr (get_dso_handle_node (),
6845 tf_warning_or_error
);
6847 /* Just pass NULL to the dso handle parm if we don't actually
6848 have a DSO handle on this target. */
6849 arg2
= null_pointer_node
;
6855 if (!DECL_THREAD_LOCAL_P (decl
)
6856 && targetm
.cxx
.use_aeabi_atexit ())
6872 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
6873 arg0
, arg1
, arg2
, NULL_TREE
);
6876 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6877 is its initializer. Generate code to handle the construction
6878 and destruction of DECL. */
6881 expand_static_init (tree decl
, tree init
)
6883 gcc_assert (VAR_P (decl
));
6884 gcc_assert (TREE_STATIC (decl
));
6886 /* Some variables require no dynamic initialization. */
6888 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6890 /* Make sure the destructor is callable. */
6891 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6895 if (DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
6896 && !DECL_FUNCTION_SCOPE_P (decl
))
6899 error ("non-local variable %qD declared %<__thread%> "
6900 "needs dynamic initialization", decl
);
6902 error ("non-local variable %qD declared %<__thread%> "
6903 "has a non-trivial destructor", decl
);
6904 static bool informed
;
6907 inform (DECL_SOURCE_LOCATION (decl
),
6908 "C++11 %<thread_local%> allows dynamic initialization "
6915 if (DECL_FUNCTION_SCOPE_P (decl
))
6917 /* Emit code to perform this initialization but once. */
6918 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6919 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6920 tree guard
, guard_addr
;
6922 /* We don't need thread-safety code for thread-local vars. */
6923 bool thread_guard
= (flag_threadsafe_statics
6924 && !DECL_THREAD_LOCAL_P (decl
));
6926 /* Emit code to perform this initialization but once. This code
6929 static <type> guard;
6930 if (!guard.first_byte) {
6931 if (__cxa_guard_acquire (&guard)) {
6934 // Do initialization.
6935 flag = true; __cxa_guard_release (&guard);
6936 // Register variable for destruction at end of program.
6938 if (!flag) __cxa_guard_abort (&guard);
6942 Note that the `flag' variable is only set to 1 *after* the
6943 initialization is complete. This ensures that an exception,
6944 thrown during the construction, will cause the variable to
6945 reinitialized when we pass through this code again, as per:
6949 If the initialization exits by throwing an exception, the
6950 initialization is not complete, so it will be tried again
6951 the next time control enters the declaration.
6953 This process should be thread-safe, too; multiple threads
6954 should not be able to initialize the variable more than
6957 /* Create the guard variable. */
6958 guard
= get_guard (decl
);
6960 /* This optimization isn't safe on targets with relaxed memory
6961 consistency. On such targets we force synchronization in
6962 __cxa_guard_acquire. */
6963 if (!targetm
.relaxed_ordering
|| !thread_guard
)
6965 /* Begin the conditional initialization. */
6966 if_stmt
= begin_if_stmt ();
6967 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
6968 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6973 tree vfntype
= NULL_TREE
;
6974 tree acquire_name
, release_name
, abort_name
;
6975 tree acquire_fn
, release_fn
, abort_fn
;
6976 guard_addr
= build_address (guard
);
6978 acquire_name
= get_identifier ("__cxa_guard_acquire");
6979 release_name
= get_identifier ("__cxa_guard_release");
6980 abort_name
= get_identifier ("__cxa_guard_abort");
6981 acquire_fn
= identifier_global_value (acquire_name
);
6982 release_fn
= identifier_global_value (release_name
);
6983 abort_fn
= identifier_global_value (abort_name
);
6985 acquire_fn
= push_library_fn
6986 (acquire_name
, build_function_type_list (integer_type_node
,
6987 TREE_TYPE (guard_addr
),
6989 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
6990 if (!release_fn
|| !abort_fn
)
6991 vfntype
= build_function_type_list (void_type_node
,
6992 TREE_TYPE (guard_addr
),
6995 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
6996 ECF_NOTHROW
| ECF_LEAF
);
6998 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
6999 ECF_NOTHROW
| ECF_LEAF
);
7001 inner_if_stmt
= begin_if_stmt ();
7002 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7005 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7006 begin
= get_target_expr (boolean_false_node
);
7007 flag
= TARGET_EXPR_SLOT (begin
);
7009 TARGET_EXPR_CLEANUP (begin
)
7010 = build3 (COND_EXPR
, void_type_node
, flag
,
7012 build_call_n (abort_fn
, 1, guard_addr
));
7013 CLEANUP_EH_ONLY (begin
) = 1;
7015 /* Do the initialization itself. */
7016 init
= add_stmt_to_compound (begin
, init
);
7017 init
= add_stmt_to_compound
7018 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7019 init
= add_stmt_to_compound
7020 (init
, build_call_n (release_fn
, 1, guard_addr
));
7023 init
= add_stmt_to_compound (init
, set_guard (guard
));
7025 /* Use atexit to register a function for destroying this static
7027 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7029 finish_expr_stmt (init
);
7033 finish_compound_stmt (inner_then_clause
);
7034 finish_then_clause (inner_if_stmt
);
7035 finish_if_stmt (inner_if_stmt
);
7038 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7040 finish_compound_stmt (then_clause
);
7041 finish_then_clause (if_stmt
);
7042 finish_if_stmt (if_stmt
);
7045 else if (DECL_THREAD_LOCAL_P (decl
))
7046 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7048 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7052 /* Make TYPE a complete type based on INITIAL_VALUE.
7053 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7054 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7055 3 if the initializer list is empty (in pedantic mode). */
7058 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7061 tree type
, elt_type
;
7065 unsigned HOST_WIDE_INT i
;
7068 /* An array of character type can be initialized from a
7069 brace-enclosed string constant.
7071 FIXME: this code is duplicated from reshape_init. Probably
7072 we should just call reshape_init here? */
7073 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7074 && TREE_CODE (initial_value
) == CONSTRUCTOR
7075 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7077 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7078 tree value
= (*v
)[0].value
;
7080 if (TREE_CODE (value
) == STRING_CST
7081 && v
->length () == 1)
7082 initial_value
= value
;
7085 /* If any of the elements are parameter packs, we can't actually
7086 complete this type now because the array size is dependent. */
7087 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7089 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7092 if (PACK_EXPANSION_P (value
))
7098 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7100 /* We can create the array before the element type is complete, which
7101 means that we didn't have these two bits set in the original type
7102 either. In completing the type, we are expected to propagate these
7103 bits. See also complete_type which does the same thing for arrays
7106 if (TYPE_DOMAIN (type
))
7108 elt_type
= TREE_TYPE (type
);
7109 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7110 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7111 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7117 /* As above, but either give an error or reject zero-size arrays, depending
7121 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7122 bool do_default
, tsubst_flags_t complain
)
7125 bool sfinae
= !(complain
& tf_error
);
7126 /* In SFINAE context we can't be lenient about zero-size arrays. */
7129 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7135 /* Not an error. */;
7136 else if (failure
== 1)
7137 error ("initializer fails to determine size of %qT", *ptype
);
7138 else if (failure
== 2)
7141 error ("array size missing in %qT", *ptype
);
7143 else if (failure
== 3)
7144 error ("zero-size array %qT", *ptype
);
7145 *ptype
= error_mark_node
;
7150 /* Return zero if something is declared to be a member of type
7151 CTYPE when in the context of CUR_TYPE. STRING is the error
7152 message to print in that case. Otherwise, quietly return 1. */
7155 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7157 if (ctype
&& ctype
!= cur_type
)
7159 if (flags
== DTOR_FLAG
)
7160 error ("destructor for alien class %qT cannot be a member", ctype
);
7162 error ("constructor for alien class %qT cannot be a member", ctype
);
7168 /* Subroutine of `grokdeclarator'. */
7170 /* Generate errors possibly applicable for a given set of specifiers.
7171 This is for ARM $7.1.2. */
7174 bad_specifiers (tree object
,
7175 enum bad_spec_place type
,
7186 error ("%qD declared as a %<virtual%> variable", object
);
7188 error ("%qD declared as an %<inline%> variable", object
);
7190 error ("%<const%> and %<volatile%> function specifiers on "
7191 "%qD invalid in variable declaration", object
);
7195 error ("%qD declared as a %<virtual%> parameter", object
);
7197 error ("%qD declared as an %<inline%> parameter", object
);
7199 error ("%<const%> and %<volatile%> function specifiers on "
7200 "%qD invalid in parameter declaration", object
);
7204 error ("%qD declared as a %<virtual%> type", object
);
7206 error ("%qD declared as an %<inline%> type", object
);
7208 error ("%<const%> and %<volatile%> function specifiers on "
7209 "%qD invalid in type declaration", object
);
7213 error ("%qD declared as a %<virtual%> field", object
);
7215 error ("%qD declared as an %<inline%> field", object
);
7217 error ("%<const%> and %<volatile%> function specifiers on "
7218 "%qD invalid in field declaration", object
);
7224 error ("%q+D declared as a friend", object
);
7226 && (TREE_CODE (object
) == TYPE_DECL
7227 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7228 && !TYPE_REFFN_P (TREE_TYPE (object
))
7229 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7230 error ("%q+D declared with an exception specification", object
);
7233 /* DECL is a member function or static data member and is presently
7234 being defined. Check that the definition is taking place in a
7238 check_class_member_definition_namespace (tree decl
)
7240 /* These checks only apply to member functions and static data
7242 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7243 /* We check for problems with specializations in pt.c in
7244 check_specialization_namespace, where we can issue better
7246 if (processing_specialization
)
7248 /* There are no restrictions on the placement of
7249 explicit instantiations. */
7250 if (processing_explicit_instantiation
)
7254 A member function definition that appears outside of the
7255 class definition shall appear in a namespace scope enclosing
7256 the class definition.
7260 The definition for a static data member shall appear in a
7261 namespace scope enclosing the member's class definition. */
7262 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7263 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7264 decl
, DECL_CONTEXT (decl
));
7267 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7268 METHOD_TYPE for a non-static member function; QUALS are the
7269 cv-qualifiers that apply to the function. */
7272 build_this_parm (tree type
, cp_cv_quals quals
)
7277 cp_cv_quals this_quals
;
7279 if (CLASS_TYPE_P (type
))
7282 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7283 this_type
= build_pointer_type (this_type
);
7286 this_type
= type_of_this_parm (type
);
7287 /* The `this' parameter is implicitly `const'; it cannot be
7289 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7290 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7291 parm
= build_artificial_parm (this_identifier
, qual_type
);
7292 cp_apply_type_quals_to_decl (this_quals
, parm
);
7296 /* DECL is a static member function. Complain if it was declared
7297 with function-cv-quals. */
7300 check_static_quals (tree decl
, cp_cv_quals quals
)
7302 if (quals
!= TYPE_UNQUALIFIED
)
7303 error ("static member function %q#D declared with type qualifiers",
7307 /* Helper function. Replace the temporary this parameter injected
7308 during cp_finish_omp_declare_simd with the real this parameter. */
7311 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7313 tree this_parm
= (tree
) data
;
7314 if (TREE_CODE (*tp
) == PARM_DECL
7315 && DECL_NAME (*tp
) == this_identifier
7316 && *tp
!= this_parm
)
7318 else if (TYPE_P (*tp
))
7323 /* CTYPE is class type, or null if non-class.
7324 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7326 DECLARATOR is the function's name.
7327 PARMS is a chain of PARM_DECLs for the function.
7328 VIRTUALP is truthvalue of whether the function is virtual or not.
7329 FLAGS are to be passed through to `grokclassfn'.
7330 QUALS are qualifiers indicating whether the function is `const'
7332 RAISES is a list of exceptions that this function can raise.
7333 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7334 not look, and -1 if we should not call `grokclassfn' at all.
7336 SFK is the kind of special function (if any) for the new function.
7338 Returns `NULL_TREE' if something goes wrong, after issuing
7339 applicable error messages. */
7342 grokfndecl (tree ctype
,
7346 tree orig_declarator
,
7348 enum overload_flags flags
,
7350 cp_ref_qualifier rqual
,
7356 special_function_kind sfk
,
7361 location_t location
)
7364 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7368 type
= build_ref_qualified_type (type
, rqual
);
7370 type
= build_exception_variant (type
, raises
);
7372 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7374 /* If we have an explicit location, use it, otherwise use whatever
7375 build_lang_decl used (probably input_location). */
7376 if (location
!= UNKNOWN_LOCATION
)
7377 DECL_SOURCE_LOCATION (decl
) = location
;
7379 if (TREE_CODE (type
) == METHOD_TYPE
)
7382 parm
= build_this_parm (type
, quals
);
7383 DECL_CHAIN (parm
) = parms
;
7386 DECL_ARGUMENTS (decl
) = parms
;
7387 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7388 DECL_CONTEXT (t
) = decl
;
7389 /* Propagate volatile out from type to decl. */
7390 if (TYPE_VOLATILE (type
))
7391 TREE_THIS_VOLATILE (decl
) = 1;
7393 /* Setup decl according to sfk. */
7396 case sfk_constructor
:
7397 case sfk_copy_constructor
:
7398 case sfk_move_constructor
:
7399 DECL_CONSTRUCTOR_P (decl
) = 1;
7401 case sfk_destructor
:
7402 DECL_DESTRUCTOR_P (decl
) = 1;
7408 /* If pointers to member functions use the least significant bit to
7409 indicate whether a function is virtual, ensure a pointer
7410 to this function will have that bit clear. */
7411 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7412 && TREE_CODE (type
) == METHOD_TYPE
7413 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7414 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7417 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7421 ("defining explicit specialization %qD in friend declaration",
7425 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7426 tree args
= TREE_OPERAND (orig_declarator
, 1);
7428 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7430 /* Something like `template <class T> friend void f<T>()'. */
7431 error ("invalid use of template-id %qD in declaration "
7432 "of primary template",
7438 /* A friend declaration of the form friend void f<>(). Record
7439 the information in the TEMPLATE_ID_EXPR. */
7440 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7442 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7443 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7445 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7446 if (TREE_PURPOSE (t
)
7447 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7449 error ("default arguments are not allowed in declaration "
7450 "of friend template specialization %qD",
7456 error ("%<inline%> is not allowed in declaration of friend "
7457 "template specialization %qD",
7460 error ("%<constexpr%> is not allowed in declaration of friend "
7461 "template specialization %qD",
7468 /* If this decl has namespace scope, set that up. */
7470 set_decl_namespace (decl
, in_namespace
, friendp
);
7472 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7474 /* `main' and builtins have implicit 'C' linkage. */
7475 if ((MAIN_NAME_P (declarator
)
7476 || (IDENTIFIER_LENGTH (declarator
) > 10
7477 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7478 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7479 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
7480 || (targetcm
.cxx_implicit_extern_c
7481 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
7482 && current_lang_name
== lang_name_cplusplus
7483 && ctype
== NULL_TREE
7484 && DECL_FILE_SCOPE_P (decl
))
7485 SET_DECL_LANGUAGE (decl
, lang_c
);
7487 /* Should probably propagate const out from type to decl I bet (mrs). */
7490 DECL_STATIC_FUNCTION_P (decl
) = 1;
7491 DECL_CONTEXT (decl
) = ctype
;
7496 DECL_CONTEXT (decl
) = ctype
;
7498 check_class_member_definition_namespace (decl
);
7501 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7503 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7504 error ("cannot declare %<::main%> to be a template");
7506 error ("cannot declare %<::main%> to be inline");
7508 error ("cannot declare %<::main%> to be constexpr");
7510 error ("cannot declare %<::main%> to be static");
7515 /* Members of anonymous types and local classes have no linkage; make
7516 them internal. If a typedef is made later, this will be changed. */
7517 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
7518 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7521 if (publicp
&& cxx_dialect
== cxx98
)
7523 /* [basic.link]: A name with no linkage (notably, the name of a class
7524 or enumeration declared in a local scope) shall not be used to
7525 declare an entity with linkage.
7527 DR 757 relaxes this restriction for C++0x. */
7528 t
= no_linkage_check (TREE_TYPE (decl
),
7529 /*relaxed_p=*/false);
7532 if (TYPE_ANONYMOUS_P (t
))
7534 if (DECL_EXTERN_C_P (decl
))
7535 /* Allow this; it's pretty common in C. */;
7538 permerror (input_location
, "anonymous type with no linkage "
7539 "used to declare function %q#D with linkage",
7541 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7542 permerror (input_location
, "%q+#D does not refer to the unqualified "
7543 "type, so it is not used for linkage",
7548 permerror (input_location
, "type %qT with no linkage used to "
7549 "declare function %q#D with linkage", t
, decl
);
7553 TREE_PUBLIC (decl
) = publicp
;
7556 DECL_INTERFACE_KNOWN (decl
) = 1;
7557 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7560 /* If the declaration was declared inline, mark it as such. */
7562 DECL_DECLARED_INLINE_P (decl
) = 1;
7564 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7566 DECL_EXTERNAL (decl
) = 1;
7567 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7572 ? G_("static member function %qD cannot have cv-qualifier")
7573 : G_("non-member function %qD cannot have cv-qualifier"),
7575 quals
= TYPE_UNQUALIFIED
;
7581 ? G_("static member function %qD cannot have ref-qualifier")
7582 : G_("non-member function %qD cannot have ref-qualifier"),
7584 rqual
= REF_QUAL_NONE
;
7588 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7589 && !grok_op_properties (decl
, /*complain=*/true))
7591 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7593 bool long_long_unsigned_p
;
7595 const char *suffix
= NULL
;
7596 /* [over.literal]/6: Literal operators shall not have C linkage. */
7597 if (DECL_LANGUAGE (decl
) == lang_c
)
7599 error ("literal operator with C linkage");
7603 if (DECL_NAMESPACE_SCOPE_P (decl
))
7605 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7608 error ("%qD has invalid argument list", decl
);
7612 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7613 if (long_long_unsigned_p
)
7615 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7616 warning (0, "integer suffix %<%s%>"
7617 " shadowed by implementation", suffix
);
7619 else if (long_double_p
)
7621 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7622 warning (0, "floating point suffix %<%s%>"
7623 " shadowed by implementation", suffix
);
7628 error ("%qD must be a non-member function", decl
);
7634 /* Make the init_value nonzero so pushdecl knows this is not
7635 tentative. error_mark_node is replaced later with the BLOCK. */
7636 DECL_INITIAL (decl
) = error_mark_node
;
7638 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7639 TREE_NOTHROW (decl
) = 1;
7643 /* Adjust "omp declare simd" attributes. */
7644 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
7648 for (attr
= ods
; attr
;
7649 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
7651 if (TREE_CODE (type
) == METHOD_TYPE
)
7652 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
7653 DECL_ARGUMENTS (decl
), NULL
);
7654 if (TREE_VALUE (attr
) != NULL_TREE
)
7656 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
7657 cl
= c_omp_declare_simd_clauses_to_numbers
7658 (DECL_ARGUMENTS (decl
), cl
);
7660 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
7662 TREE_VALUE (attr
) = NULL_TREE
;
7668 /* Caller will do the rest of this. */
7672 if (ctype
!= NULL_TREE
)
7673 grokclassfn (ctype
, decl
, flags
);
7676 if (cxx_dialect
>= cxx11
7677 && DECL_DESTRUCTOR_P (decl
)
7678 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7679 && !processing_template_decl
)
7680 deduce_noexcept_on_destructor (decl
);
7682 decl
= check_explicit_specialization (orig_declarator
, decl
,
7685 4 * (friendp
!= 0));
7686 if (decl
== error_mark_node
)
7689 if (DECL_STATIC_FUNCTION_P (decl
))
7690 check_static_quals (decl
, quals
);
7694 cplus_decl_attributes (&decl
, *attrlist
, 0);
7695 *attrlist
= NULL_TREE
;
7698 /* Check main's type after attributes have been applied. */
7699 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7701 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7704 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7706 error ("%<::main%> must return %<int%>");
7707 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7708 TREE_TYPE (decl
) = newtype
;
7711 check_main_parameter_types (decl
);
7714 if (ctype
!= NULL_TREE
7715 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
7718 tree old_decl
= check_classfn (ctype
, decl
,
7719 (processing_template_decl
7720 > template_class_depth (ctype
))
7721 ? current_template_parms
7724 if (old_decl
== error_mark_node
)
7732 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
7733 /* Because grokfndecl is always supposed to return a
7734 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7735 here. We depend on our callers to figure out that its
7736 really a template that's being returned. */
7737 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
7739 if (DECL_STATIC_FUNCTION_P (old_decl
)
7740 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7742 /* Remove the `this' parm added by grokclassfn. */
7743 revert_static_member_fn (decl
);
7744 check_static_quals (decl
, quals
);
7746 if (DECL_ARTIFICIAL (old_decl
))
7748 error ("definition of implicitly-declared %qD", old_decl
);
7751 else if (DECL_DEFAULTED_FN (old_decl
))
7753 error ("definition of explicitly-defaulted %q+D", decl
);
7754 error ("%q+#D explicitly defaulted here", old_decl
);
7758 /* Since we've smashed OLD_DECL to its
7759 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7760 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7761 decl
= DECL_TEMPLATE_RESULT (decl
);
7763 /* Attempt to merge the declarations. This can fail, in
7764 the case of some invalid specialization declarations. */
7765 pushed_scope
= push_scope (ctype
);
7766 ok
= duplicate_decls (decl
, old_decl
, friendp
);
7768 pop_scope (pushed_scope
);
7771 error ("no %q#D member function declared in class %qT",
7779 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
7782 if (ctype
== NULL_TREE
|| check
)
7786 DECL_VIRTUAL_P (decl
) = 1;
7791 /* decl is a FUNCTION_DECL.
7792 specifiers are the parsed virt-specifiers.
7794 Set flags to reflect the virt-specifiers.
7799 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
7801 if (decl
== NULL_TREE
)
7803 if (specifiers
& VIRT_SPEC_OVERRIDE
)
7804 DECL_OVERRIDE_P (decl
) = 1;
7805 if (specifiers
& VIRT_SPEC_FINAL
)
7806 DECL_FINAL_P (decl
) = 1;
7810 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7811 the linkage that DECL will receive in the object file. */
7814 set_linkage_for_static_data_member (tree decl
)
7816 /* A static data member always has static storage duration and
7817 external linkage. Note that static data members are forbidden in
7818 local classes -- the only situation in which a class has
7819 non-external linkage. */
7820 TREE_PUBLIC (decl
) = 1;
7821 TREE_STATIC (decl
) = 1;
7822 /* For non-template classes, static data members are always put
7823 out in exactly those files where they are defined, just as
7824 with ordinary namespace-scope variables. */
7825 if (!processing_template_decl
)
7826 DECL_INTERFACE_KNOWN (decl
) = 1;
7829 /* Create a VAR_DECL named NAME with the indicated TYPE.
7831 If SCOPE is non-NULL, it is the class type or namespace containing
7832 the variable. If SCOPE is NULL, the variable should is created in
7833 the innermost enclosings scope. */
7836 grokvardecl (tree type
,
7838 const cp_decl_specifier_seq
*declspecs
,
7844 tree explicit_scope
;
7846 gcc_assert (!name
|| identifier_p (name
));
7848 /* Compute the scope in which to place the variable, but remember
7849 whether or not that scope was explicitly specified by the user. */
7850 explicit_scope
= scope
;
7853 /* An explicit "extern" specifier indicates a namespace-scope
7855 if (declspecs
->storage_class
== sc_extern
)
7856 scope
= current_decl_namespace ();
7857 else if (!at_function_scope_p ())
7858 scope
= current_scope ();
7862 && (/* If the variable is a namespace-scope variable declared in a
7863 template, we need DECL_LANG_SPECIFIC. */
7864 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
7865 /* Similarly for namespace-scope variables with language linkage
7867 || (TREE_CODE (scope
) == NAMESPACE_DECL
7868 && current_lang_name
!= lang_name_cplusplus
)
7869 /* Similarly for static data members. */
7871 decl
= build_lang_decl (VAR_DECL
, name
, type
);
7873 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7875 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
7876 set_decl_namespace (decl
, explicit_scope
, 0);
7878 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
7880 if (declspecs
->storage_class
== sc_extern
)
7882 DECL_THIS_EXTERN (decl
) = 1;
7883 DECL_EXTERNAL (decl
) = !initialized
;
7886 if (DECL_CLASS_SCOPE_P (decl
))
7888 set_linkage_for_static_data_member (decl
);
7889 /* This function is only called with out-of-class definitions. */
7890 DECL_EXTERNAL (decl
) = 0;
7891 check_class_member_definition_namespace (decl
);
7893 /* At top level, either `static' or no s.c. makes a definition
7894 (perhaps tentative), and absence of `static' makes it public. */
7895 else if (toplevel_bindings_p ())
7897 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
7898 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7899 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7901 /* Not at top level, only `static' makes a static definition. */
7904 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
7905 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7908 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
7910 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
7911 if (declspecs
->gnu_thread_keyword_p
)
7912 DECL_GNU_TLS_P (decl
) = true;
7915 /* If the type of the decl has no linkage, make sure that we'll
7916 notice that in mark_used. */
7917 if (cxx_dialect
> cxx98
7918 && decl_linkage (decl
) != lk_none
7919 && DECL_LANG_SPECIFIC (decl
) == NULL
7920 && !DECL_EXTERN_C_P (decl
)
7921 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
7922 retrofit_lang_decl (decl
);
7924 if (TREE_PUBLIC (decl
))
7926 /* [basic.link]: A name with no linkage (notably, the name of a class
7927 or enumeration declared in a local scope) shall not be used to
7928 declare an entity with linkage.
7930 DR 757 relaxes this restriction for C++0x. */
7931 tree t
= (cxx_dialect
> cxx98
? NULL_TREE
7932 : no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false));
7935 if (TYPE_ANONYMOUS_P (t
))
7937 if (DECL_EXTERN_C_P (decl
))
7938 /* Allow this; it's pretty common in C. */
7942 /* DRs 132, 319 and 389 seem to indicate types with
7943 no linkage can only be used to declare extern "C"
7944 entities. Since it's not always an error in the
7945 ISO C++ 90 Standard, we only issue a warning. */
7946 warning (0, "anonymous type with no linkage used to declare "
7947 "variable %q#D with linkage", decl
);
7948 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7949 warning (0, "%q+#D does not refer to the unqualified "
7950 "type, so it is not used for linkage",
7955 warning (0, "type %qT with no linkage used to declare variable "
7956 "%q#D with linkage", t
, decl
);
7960 DECL_INTERFACE_KNOWN (decl
) = 1;
7965 /* Create and return a canonical pointer to member function type, for
7966 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7969 build_ptrmemfunc_type (tree type
)
7973 tree unqualified_variant
= NULL_TREE
;
7975 if (type
== error_mark_node
)
7978 /* If a canonical type already exists for this type, use it. We use
7979 this method instead of type_hash_canon, because it only does a
7980 simple equality check on the list of field members. */
7982 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
7985 /* Make sure that we always have the unqualified pointer-to-member
7987 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7989 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
7991 t
= make_class_type (RECORD_TYPE
);
7992 xref_basetypes (t
, NULL_TREE
);
7994 /* Let the front end know this is a pointer to member function... */
7995 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
7996 /* ... and not really a class type. */
7997 SET_CLASS_TYPE_P (t
, 0);
7999 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8002 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8004 DECL_CHAIN (field
) = fields
;
8007 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8009 /* Zap out the name so that the back end will give us the debugging
8010 information for this anonymous RECORD_TYPE. */
8011 TYPE_NAME (t
) = NULL_TREE
;
8013 /* If this is not the unqualified form of this pointer-to-member
8014 type, set the TYPE_MAIN_VARIANT for this type to be the
8015 unqualified type. Since they are actually RECORD_TYPEs that are
8016 not variants of each other, we must do this manually.
8017 As we just built a new type there is no need to do yet another copy. */
8018 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
8020 int type_quals
= cp_type_quals (type
);
8021 TYPE_READONLY (t
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
8022 TYPE_VOLATILE (t
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
8023 TYPE_RESTRICT (t
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
8024 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
8025 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
8026 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
8027 TREE_TYPE (TYPE_BINFO (t
)) = t
;
8030 /* Cache this pointer-to-member type so that we can find it again
8032 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8034 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8035 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8036 else if (TYPE_CANONICAL (type
) != type
)
8037 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8042 /* Create and return a pointer to data member type. */
8045 build_ptrmem_type (tree class_type
, tree member_type
)
8047 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8049 cp_cv_quals quals
= type_memfn_quals (member_type
);
8050 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8051 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8052 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8056 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8057 return build_offset_type (class_type
, member_type
);
8061 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8062 Check to see that the definition is valid. Issue appropriate error
8063 messages. Return 1 if the definition is particularly bad, or 0
8067 check_static_variable_definition (tree decl
, tree type
)
8069 /* Can't check yet if we don't know the type. */
8070 if (dependent_type_p (type
))
8072 /* If DECL is declared constexpr, we'll do the appropriate checks
8073 in check_initializer. */
8074 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8076 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8078 if (!COMPLETE_TYPE_P (type
))
8079 error ("in-class initialization of static data member %q#D of "
8080 "incomplete type", decl
);
8081 else if (literal_type_p (type
))
8082 permerror (input_location
,
8083 "%<constexpr%> needed for in-class initialization of "
8084 "static data member %q#D of non-integral type", decl
);
8086 error ("in-class initialization of static data member %q#D of "
8087 "non-literal type", decl
);
8091 /* Motion 10 at San Diego: If a static const integral data member is
8092 initialized with an integral constant expression, the initializer
8093 may appear either in the declaration (within the class), or in
8094 the definition, but not both. If it appears in the class, the
8095 member is a member constant. The file-scope definition is always
8097 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8099 error ("invalid in-class initialization of static data member "
8100 "of non-integral type %qT",
8104 else if (!CP_TYPE_CONST_P (type
))
8105 error ("ISO C++ forbids in-class initialization of non-const "
8106 "static member %qD",
8108 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8109 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8110 "%qD of non-integral type %qT", decl
, type
);
8115 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8116 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8117 expressions out into temporary variables so that walk_tree doesn't
8118 step into them (c++/15764). */
8121 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8123 struct pointer_set_t
*pset
= (struct pointer_set_t
*)data
;
8124 tree expr
= *expr_p
;
8125 if (TREE_CODE (expr
) == SAVE_EXPR
)
8127 tree op
= TREE_OPERAND (expr
, 0);
8128 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8129 if (TREE_SIDE_EFFECTS (op
))
8130 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8133 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8138 /* Entry point for the above. */
8141 stabilize_vla_size (tree size
)
8143 struct pointer_set_t
*pset
= pointer_set_create ();
8144 /* Break out any function calls into temporary variables. */
8145 cp_walk_tree (&size
, stabilize_save_expr_r
, pset
, pset
);
8146 pointer_set_destroy (pset
);
8149 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8150 not inside of SAVE_EXPR and fold them. */
8153 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8155 tree expr
= *expr_p
;
8156 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8158 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8160 *(bool *)data
= true;
8161 if (SIZEOF_EXPR_TYPE_P (expr
))
8162 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8163 SIZEOF_EXPR
, false);
8164 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8165 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8168 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8170 if (expr
== error_mark_node
)
8171 expr
= size_one_node
;
8178 /* Given the SIZE (i.e., number of elements) in an array, compute an
8179 appropriate index type for the array. If non-NULL, NAME is the
8180 name of the thing being declared. */
8183 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8187 tree abi_1_itype
= NULL_TREE
;
8189 if (error_operand_p (size
))
8190 return error_mark_node
;
8192 if (!type_dependent_expression_p (size
))
8194 tree type
= TREE_TYPE (size
);
8196 mark_rvalue_use (size
);
8198 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8199 && TREE_SIDE_EFFECTS (size
))
8200 /* In C++98, we mark a non-constant array bound with a magic
8201 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8204 size
= fold_non_dependent_expr_sfinae (size
, complain
);
8206 if (CLASS_TYPE_P (type
)
8207 && CLASSTYPE_LITERAL_P (type
))
8209 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8212 if (!(complain
& tf_error
))
8213 return error_mark_node
;
8215 error ("size of array %qD has non-integral type %qT",
8218 error ("size of array has non-integral type %qT", type
);
8219 size
= integer_one_node
;
8221 if (size
== error_mark_node
)
8222 return error_mark_node
;
8223 type
= TREE_TYPE (size
);
8224 /* We didn't support this case in GCC 3.2, so don't bother
8225 trying to model it now in ABI v1. */
8226 abi_1_itype
= error_mark_node
;
8229 size
= maybe_constant_value (size
);
8230 if (!TREE_CONSTANT (size
))
8234 if (error_operand_p (size
))
8235 return error_mark_node
;
8237 /* The array bound must be an integer type. */
8238 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8240 if (!(complain
& tf_error
))
8241 return error_mark_node
;
8243 error ("size of array %qD has non-integral type %qT", name
, type
);
8245 error ("size of array has non-integral type %qT", type
);
8246 size
= integer_one_node
;
8247 type
= TREE_TYPE (size
);
8251 /* A type is dependent if it is...an array type constructed from any
8252 dependent type or whose size is specified by a constant expression
8253 that is value-dependent. */
8254 /* We can only call value_dependent_expression_p on integral constant
8255 expressions; treat non-constant expressions as dependent, too. */
8256 if (processing_template_decl
8257 && (type_dependent_expression_p (size
)
8258 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8260 /* We cannot do any checking for a SIZE that isn't known to be
8261 constant. Just build the index type and mark that it requires
8262 structural equality checks. */
8263 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8264 size
, size_one_node
));
8265 TYPE_DEPENDENT_P (itype
) = 1;
8266 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8267 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8271 if (!abi_version_at_least (2) && processing_template_decl
8272 && abi_1_itype
== NULL_TREE
)
8273 /* For abi-1, we handled all instances in templates the same way,
8274 even when they were non-dependent. This affects the manglings
8275 produced. So, we do the normal checking for non-dependent
8276 sizes, but at the end we'll return the same type that abi-1
8277 would have, but with TYPE_CANONICAL set to the "right"
8278 value that the current ABI would provide. */
8279 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8280 osize
, integer_one_node
));
8282 /* Normally, the array-bound will be a constant. */
8283 if (TREE_CODE (size
) == INTEGER_CST
)
8285 /* Check to see if the array bound overflowed. Make that an
8286 error, no matter how generous we're being. */
8287 constant_expression_error (size
);
8289 /* An array must have a positive number of elements. */
8290 if (INT_CST_LT (size
, integer_zero_node
))
8292 if (!(complain
& tf_error
))
8293 return error_mark_node
;
8295 error ("size of array %qD is negative", name
);
8297 error ("size of array is negative");
8298 size
= integer_one_node
;
8300 /* As an extension we allow zero-sized arrays. */
8301 else if (integer_zerop (size
))
8303 if (!(complain
& tf_error
))
8304 /* We must fail if performing argument deduction (as
8305 indicated by the state of complain), so that
8306 another substitution can be found. */
8307 return error_mark_node
;
8308 else if (in_system_header
)
8309 /* Allow them in system headers because glibc uses them. */;
8311 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8313 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8316 else if (TREE_CONSTANT (size
)
8317 /* We don't allow VLAs at non-function scopes, or during
8318 tentative template substitution. */
8319 || !at_function_scope_p ()
8320 || (cxx_dialect
< cxx1y
&& !(complain
& tf_error
)))
8322 if (!(complain
& tf_error
))
8323 return error_mark_node
;
8324 /* `(int) &fn' is not a valid array bound. */
8326 error ("size of array %qD is not an integral constant-expression",
8329 error ("size of array is not an integral constant-expression");
8330 size
= integer_one_node
;
8332 else if (cxx_dialect
< cxx1y
&& pedantic
&& warn_vla
!= 0)
8335 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8337 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8339 else if (warn_vla
> 0)
8343 "variable length array %qD is used", name
);
8346 "variable length array is used");
8349 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8350 /* A variable sized array. */
8351 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8354 HOST_WIDE_INT saved_processing_template_decl
;
8356 /* Compute the index of the largest element in the array. It is
8357 one less than the number of elements in the array. We save
8358 and restore PROCESSING_TEMPLATE_DECL so that computations in
8359 cp_build_binary_op will be appropriately folded. */
8360 saved_processing_template_decl
= processing_template_decl
;
8361 processing_template_decl
= 0;
8362 itype
= cp_build_binary_op (input_location
,
8364 cp_convert (ssizetype
, size
, complain
),
8365 cp_convert (ssizetype
, integer_one_node
,
8368 itype
= fold (itype
);
8369 processing_template_decl
= saved_processing_template_decl
;
8371 if (!TREE_CONSTANT (itype
))
8373 /* A variable sized array. */
8374 itype
= variable_size (itype
);
8376 if (TREE_CODE (itype
) != SAVE_EXPR
)
8378 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8379 they might survive till gimplification. */
8380 tree newitype
= itype
;
8382 cp_walk_tree_without_duplicates (&newitype
,
8383 fold_sizeof_expr_r
, &found
);
8385 itype
= variable_size (fold (newitype
));
8388 stabilize_vla_size (itype
);
8390 if (cxx_dialect
>= cxx1y
)
8392 /* If the VLA bound is larger than half the address space,
8393 or less than zero, throw std::bad_array_length. */
8394 tree comp
= build2 (LT_EXPR
, boolean_type_node
, itype
,
8396 comp
= build3 (COND_EXPR
, void_type_node
, comp
,
8397 throw_bad_array_length (), void_zero_node
);
8398 finish_expr_stmt (comp
);
8400 else if (flag_sanitize
& SANITIZE_VLA
)
8402 /* From C++1y onwards, we throw an exception on a negative
8403 length size of an array; see above. */
8405 /* We have to add 1 -- in the ubsan routine we generate
8406 LE_EXPR rather than LT_EXPR. */
8407 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8408 build_one_cst (TREE_TYPE (itype
)));
8409 t
= fold_build2 (COMPOUND_EXPR
, TREE_TYPE (t
),
8410 ubsan_instrument_vla (input_location
, t
), t
);
8411 finish_expr_stmt (t
);
8414 /* Make sure that there was no overflow when creating to a signed
8415 index type. (For example, on a 32-bit machine, an array with
8416 size 2^32 - 1 is too big.) */
8417 else if (TREE_CODE (itype
) == INTEGER_CST
8418 && TREE_OVERFLOW (itype
))
8420 if (!(complain
& tf_error
))
8421 return error_mark_node
;
8422 error ("overflow in array dimension");
8423 TREE_OVERFLOW (itype
) = 0;
8427 /* Create and return the appropriate index type. */
8428 if (abi_1_itype
&& abi_1_itype
!= error_mark_node
)
8430 tree t
= build_index_type (itype
);
8431 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
8432 itype
= abi_1_itype
;
8435 itype
= build_index_type (itype
);
8437 /* If the index type were dependent, we would have returned early, so
8438 remember that it isn't. */
8439 TYPE_DEPENDENT_P (itype
) = 0;
8440 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8444 /* Returns the scope (if any) in which the entity declared by
8445 DECLARATOR will be located. If the entity was declared with an
8446 unqualified name, NULL_TREE is returned. */
8449 get_scope_of_declarator (const cp_declarator
*declarator
)
8451 while (declarator
&& declarator
->kind
!= cdk_id
)
8452 declarator
= declarator
->declarator
;
8454 /* If the declarator-id is a SCOPE_REF, the scope in which the
8455 declaration occurs is the first operand. */
8457 && declarator
->u
.id
.qualifying_scope
)
8458 return declarator
->u
.id
.qualifying_scope
;
8460 /* Otherwise, the declarator is not a qualified name; the entity will
8461 be declared in the current scope. */
8465 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8466 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8470 create_array_type_for_decl (tree name
, tree type
, tree size
)
8472 tree itype
= NULL_TREE
;
8474 /* If things have already gone awry, bail now. */
8475 if (type
== error_mark_node
|| size
== error_mark_node
)
8476 return error_mark_node
;
8478 /* 8.3.4/1: If the type of the identifier of D contains the auto
8479 type-specifier, the program is ill-formed. */
8480 if (pedantic
&& type_uses_auto (type
))
8481 pedwarn (input_location
, OPT_Wpedantic
,
8482 "declaration of %qD as array of %<auto%>", name
);
8484 /* If there are some types which cannot be array elements,
8485 issue an error-message and return. */
8486 switch (TREE_CODE (type
))
8490 error ("declaration of %qD as array of void", name
);
8492 error ("creating array of void");
8493 return error_mark_node
;
8497 error ("declaration of %qD as array of functions", name
);
8499 error ("creating array of functions");
8500 return error_mark_node
;
8502 case REFERENCE_TYPE
:
8504 error ("declaration of %qD as array of references", name
);
8506 error ("creating array of references");
8507 return error_mark_node
;
8511 error ("declaration of %qD as array of function members", name
);
8513 error ("creating array of function members");
8514 return error_mark_node
;
8522 The constant expressions that specify the bounds of the arrays
8523 can be omitted only for the first member of the sequence. */
8524 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8527 error ("declaration of %qD as multidimensional array must "
8528 "have bounds for all dimensions except the first",
8531 error ("multidimensional array must have bounds for all "
8532 "dimensions except the first");
8534 return error_mark_node
;
8537 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
))
8538 pedwarn (input_location
, OPT_Wvla
, "array of array of runtime bound");
8540 /* Figure out the index type for the array. */
8542 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8545 T is called the array element type; this type shall not be [...] an
8546 abstract class type. */
8547 abstract_virtuals_error (name
, type
);
8549 return build_cplus_array_type (type
, itype
);
8552 /* Check that it's OK to declare a function with the indicated TYPE.
8553 SFK indicates the kind of special function (if any) that this
8554 function is. OPTYPE is the type given in a conversion operator
8555 declaration, or the class type for a constructor/destructor.
8556 Returns the actual return type of the function; that
8557 may be different than TYPE if an error occurs, or for certain
8558 special functions. */
8561 check_special_function_return_type (special_function_kind sfk
,
8567 case sfk_constructor
:
8569 error ("return type specification for constructor invalid");
8571 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8572 type
= build_pointer_type (optype
);
8574 type
= void_type_node
;
8577 case sfk_destructor
:
8579 error ("return type specification for destructor invalid");
8580 /* We can't use the proper return type here because we run into
8581 problems with ambiguous bases and covariant returns.
8582 Java classes are left unchanged because (void *) isn't a valid
8583 Java type, and we don't want to change the Java ABI. */
8584 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8585 type
= build_pointer_type (void_type_node
);
8587 type
= void_type_node
;
8590 case sfk_conversion
:
8592 error ("return type specified for %<operator %T%>", optype
);
8603 /* A variable or data member (whose unqualified name is IDENTIFIER)
8604 has been declared with the indicated TYPE. If the TYPE is not
8605 acceptable, issue an error message and return a type to use for
8606 error-recovery purposes. */
8609 check_var_type (tree identifier
, tree type
)
8611 if (VOID_TYPE_P (type
))
8614 error ("unnamed variable or field declared void");
8615 else if (identifier_p (identifier
))
8617 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8618 error ("variable or field %qE declared void", identifier
);
8621 error ("variable or field declared void");
8622 type
= error_mark_node
;
8628 /* Functions for adjusting the visibility of a tagged type and its nested
8629 types when it gets a name for linkage purposes from a typedef. */
8631 static void bt_reset_linkage (binding_entry
, void *);
8633 reset_type_linkage (tree type
)
8635 set_linkage_according_to_type (type
, TYPE_MAIN_DECL (type
));
8636 if (CLASS_TYPE_P (type
))
8637 binding_table_foreach (CLASSTYPE_NESTED_UTDS (type
), bt_reset_linkage
, NULL
);
8640 bt_reset_linkage (binding_entry b
, void */
*data*/
)
8642 reset_type_linkage (b
->type
);
8645 /* Given declspecs and a declarator (abstract or otherwise), determine
8646 the name and type of the object declared and construct a DECL node
8649 DECLSPECS points to the representation of declaration-specifier
8650 sequence that precedes declarator.
8652 DECL_CONTEXT says which syntactic context this declaration is in:
8653 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8654 FUNCDEF for a function definition. Like NORMAL but a few different
8655 error messages in each case. Return value may be zero meaning
8656 this definition is too screwy to try to parse.
8657 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8658 handle member functions (which have FIELD context).
8659 Return value may be zero meaning this definition is too screwy to
8661 PARM for a parameter declaration (either within a function prototype
8662 or before a function body). Make a PARM_DECL, or return void_type_node.
8663 TPARM for a template parameter declaration.
8664 CATCHPARM for a parameter declaration before a catch clause.
8665 TYPENAME if for a typename (in a cast or sizeof).
8666 Don't make a DECL node; just return the ..._TYPE node.
8667 FIELD for a struct or union field; make a FIELD_DECL.
8668 BITFIELD for a field with specified width.
8670 INITIALIZED is as for start_decl.
8672 ATTRLIST is a pointer to the list of attributes, which may be NULL
8673 if there are none; *ATTRLIST may be modified if attributes from inside
8674 the declarator should be applied to the declaration.
8676 When this function is called, scoping variables (such as
8677 CURRENT_CLASS_TYPE) should reflect the scope in which the
8678 declaration occurs, not the scope in which the new declaration will
8679 be placed. For example, on:
8683 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8686 Returns a DECL (if a declarator is present), a TYPE (if there is no
8687 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8691 grokdeclarator (const cp_declarator
*declarator
,
8692 cp_decl_specifier_seq
*declspecs
,
8693 enum decl_context decl_context
,
8697 tree type
= NULL_TREE
;
8699 int explicit_int128
= 0;
8700 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8701 int explicit_int
= 0;
8702 int explicit_char
= 0;
8703 int defaulted_int
= 0;
8705 tree typedef_decl
= NULL_TREE
;
8706 const char *name
= NULL
;
8707 tree typedef_type
= NULL_TREE
;
8708 /* True if this declarator is a function definition. */
8709 bool funcdef_flag
= false;
8710 cp_declarator_kind innermost_code
= cdk_error
;
8713 /* See the code below that used this. */
8714 tree decl_attr
= NULL_TREE
;
8717 /* Keep track of what sort of function is being processed
8718 so that we can warn about default return values, or explicit
8719 return values which do not match prescribed defaults. */
8720 special_function_kind sfk
= sfk_none
;
8722 tree dname
= NULL_TREE
;
8723 tree ctor_return_type
= NULL_TREE
;
8724 enum overload_flags flags
= NO_SPECIAL
;
8725 /* cv-qualifiers that apply to the declarator, for a declaration of
8726 a member function. */
8727 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8728 /* virt-specifiers that apply to the declarator, for a declaration of
8729 a member function. */
8730 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8731 /* ref-qualifier that applies to the declarator, for a declaration of
8732 a member function. */
8733 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
8734 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8736 tree raises
= NULL_TREE
;
8737 int template_count
= 0;
8738 tree returned_attrs
= NULL_TREE
;
8739 tree parms
= NULL_TREE
;
8740 const cp_declarator
*id_declarator
;
8741 /* The unqualified name of the declarator; either an
8742 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8743 tree unqualified_id
;
8744 /* The class type, if any, in which this entity is located,
8745 or NULL_TREE if none. Note that this value may be different from
8746 the current class type; for example if an attempt is made to declare
8747 "A::f" inside "B", this value will be "A". */
8748 tree ctype
= current_class_type
;
8749 /* The NAMESPACE_DECL for the namespace in which this entity is
8750 located. If an unqualified name is used to declare the entity,
8751 this value will be NULL_TREE, even if the entity is located at
8753 tree in_namespace
= NULL_TREE
;
8754 cp_storage_class storage_class
;
8755 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8756 bool type_was_error_mark_node
= false;
8757 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8758 bool template_type_arg
= false;
8759 bool template_parm_flag
= false;
8760 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
8761 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8762 source_location saved_loc
= input_location
;
8765 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8766 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8767 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8768 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8769 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8770 explicit_int128
= declspecs
->explicit_int128_p
;
8771 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8773 if (decl_context
== FUNCDEF
)
8774 funcdef_flag
= true, decl_context
= NORMAL
;
8775 else if (decl_context
== MEMFUNCDEF
)
8776 funcdef_flag
= true, decl_context
= FIELD
;
8777 else if (decl_context
== BITFIELD
)
8778 bitfield
= 1, decl_context
= FIELD
;
8779 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8780 template_type_arg
= true, decl_context
= TYPENAME
;
8781 else if (decl_context
== TPARM
)
8782 template_parm_flag
= true, decl_context
= PARM
;
8784 if (initialized
> 1)
8785 funcdef_flag
= true;
8787 /* Look inside a declarator for the name being declared
8788 and get it as a string, for an error message. */
8789 for (id_declarator
= declarator
;
8791 id_declarator
= id_declarator
->declarator
)
8793 if (id_declarator
->kind
!= cdk_id
)
8794 innermost_code
= id_declarator
->kind
;
8796 switch (id_declarator
->kind
)
8799 if (id_declarator
->declarator
8800 && id_declarator
->declarator
->kind
== cdk_id
)
8802 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8803 if (sfk
== sfk_destructor
)
8810 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8811 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8814 if (qualifying_scope
)
8816 if (at_function_scope_p ())
8820 A declarator-id shall not be qualified except
8823 None of the cases are permitted in block
8825 if (qualifying_scope
== global_namespace
)
8826 error ("invalid use of qualified-name %<::%D%>",
8828 else if (TYPE_P (qualifying_scope
))
8829 error ("invalid use of qualified-name %<%T::%D%>",
8830 qualifying_scope
, decl
);
8832 error ("invalid use of qualified-name %<%D::%D%>",
8833 qualifying_scope
, decl
);
8834 return error_mark_node
;
8836 else if (TYPE_P (qualifying_scope
))
8838 ctype
= qualifying_scope
;
8839 if (!MAYBE_CLASS_TYPE_P (ctype
))
8841 error ("%q#T is not a class or a namespace", ctype
);
8844 else if (innermost_code
!= cdk_function
8845 && current_class_type
8846 && !uniquely_derived_from_p (ctype
,
8847 current_class_type
))
8849 error ("invalid use of qualified-name %<%T::%D%>",
8850 qualifying_scope
, decl
);
8851 return error_mark_node
;
8854 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
8855 in_namespace
= qualifying_scope
;
8857 switch (TREE_CODE (decl
))
8863 if (innermost_code
!= cdk_function
)
8865 error ("declaration of %qD as non-function", decl
);
8866 return error_mark_node
;
8868 else if (!qualifying_scope
8869 && !(current_class_type
&& at_class_scope_p ()))
8871 error ("declaration of %qD as non-member", decl
);
8872 return error_mark_node
;
8875 type
= TREE_OPERAND (decl
, 0);
8877 type
= constructor_name (type
);
8878 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
8883 case TEMPLATE_ID_EXPR
:
8885 tree fns
= TREE_OPERAND (decl
, 0);
8888 if (!identifier_p (dname
))
8890 gcc_assert (is_overloaded_fn (dname
));
8891 dname
= DECL_NAME (get_first_fn (dname
));
8896 case IDENTIFIER_NODE
:
8897 if (identifier_p (decl
))
8900 if (C_IS_RESERVED_WORD (dname
))
8902 error ("declarator-id missing; using reserved word %qD",
8904 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8906 else if (!IDENTIFIER_TYPENAME_P (dname
))
8907 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8910 gcc_assert (flags
== NO_SPECIAL
);
8911 flags
= TYPENAME_FLAG
;
8912 ctor_return_type
= TREE_TYPE (dname
);
8913 sfk
= sfk_conversion
;
8914 if (is_typename_at_global_scope (dname
))
8915 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8917 name
= "<invalid operator>";
8934 return error_mark_node
;
8939 if (id_declarator
->kind
== cdk_id
)
8945 The declarator in a function-definition shall have the form
8946 D1 ( parameter-declaration-clause) ... */
8947 if (funcdef_flag
&& innermost_code
!= cdk_function
)
8949 error ("function definition does not declare parameters");
8950 return error_mark_node
;
8953 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8954 && innermost_code
!= cdk_function
8955 && ! (ctype
&& !declspecs
->any_specifiers_p
))
8957 error ("declaration of %qD as non-function", dname
);
8958 return error_mark_node
;
8962 && identifier_p (dname
)
8963 && UDLIT_OPER_P (dname
)
8964 && innermost_code
!= cdk_function
)
8966 error ("declaration of %qD as non-function", dname
);
8967 return error_mark_node
;
8970 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
8974 error ("declaration of %qD as %<typedef%>", dname
);
8975 return error_mark_node
;
8977 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8979 error ("declaration of %qD as parameter", dname
);
8980 return error_mark_node
;
8984 /* Anything declared one level down from the top level
8985 must be one of the parameters of a function
8986 (because the body is at least two levels down). */
8988 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8989 by not allowing C++ class definitions to specify their parameters
8990 with xdecls (must be spec.d in the parmlist).
8992 Since we now wait to push a class scope until we are sure that
8993 we are in a legitimate method context, we must set oldcname
8994 explicitly (since current_class_name is not yet alive).
8996 We also want to avoid calling this a PARM if it is in a namespace. */
8998 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9000 cp_binding_level
*b
= current_binding_level
;
9001 current_binding_level
= b
->level_chain
;
9002 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9003 decl_context
= PARM
;
9004 current_binding_level
= b
;
9008 name
= decl_context
== PARM
? "parameter" : "type name";
9010 if (constexpr_p
&& typedef_p
)
9012 error ("%<constexpr%> cannot appear in a typedef declaration");
9013 return error_mark_node
;
9016 /* If there were multiple types specified in the decl-specifier-seq,
9017 issue an error message. */
9018 if (declspecs
->multiple_types_p
)
9020 error ("two or more data types in declaration of %qs", name
);
9021 return error_mark_node
;
9024 if (declspecs
->conflicting_specifiers_p
)
9026 error ("conflicting specifiers in declaration of %qs", name
);
9027 return error_mark_node
;
9030 /* Extract the basic type from the decl-specifier-seq. */
9031 type
= declspecs
->type
;
9032 if (type
== error_mark_node
)
9035 type_was_error_mark_node
= true;
9037 /* If the entire declaration is itself tagged as deprecated then
9038 suppress reports of deprecated items. */
9039 if (type
&& TREE_DEPRECATED (type
)
9040 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9041 warn_deprecated_use (type
, NULL_TREE
);
9042 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9044 typedef_decl
= type
;
9045 type
= TREE_TYPE (typedef_decl
);
9046 if (TREE_DEPRECATED (type
)
9047 && DECL_ARTIFICIAL (typedef_decl
)
9048 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9049 warn_deprecated_use (type
, NULL_TREE
);
9051 /* No type at all: default to `int', and set DEFAULTED_INT
9052 because it was not a user-defined typedef. */
9053 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
9055 /* These imply 'int'. */
9056 type
= integer_type_node
;
9060 explicit_int
= declspecs
->explicit_int_p
;
9061 explicit_char
= declspecs
->explicit_char_p
;
9064 /* See the code below that used this. */
9066 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9068 typedef_type
= type
;
9071 if (sfk
!= sfk_conversion
)
9072 ctor_return_type
= ctype
;
9074 if (sfk
!= sfk_none
)
9075 type
= check_special_function_return_type (sfk
, type
,
9077 else if (type
== NULL_TREE
)
9083 /* We handle `main' specially here, because 'main () { }' is so
9084 common. With no options, it is allowed. With -Wreturn-type,
9085 it is a warning. It is only an error with -pedantic-errors. */
9086 is_main
= (funcdef_flag
9087 && dname
&& identifier_p (dname
)
9088 && MAIN_NAME_P (dname
)
9089 && ctype
== NULL_TREE
9090 && in_namespace
== NULL_TREE
9091 && current_namespace
== global_namespace
);
9093 if (type_was_error_mark_node
)
9094 /* We've already issued an error, don't complain more. */;
9095 else if (in_system_header
|| flag_ms_extensions
)
9096 /* Allow it, sigh. */;
9098 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9100 pedwarn (input_location
, OPT_Wpedantic
,
9101 "ISO C++ forbids declaration of %qs with no type", name
);
9103 warning (OPT_Wreturn_type
,
9104 "ISO C++ forbids declaration of %qs with no type", name
);
9106 type
= integer_type_node
;
9111 if (explicit_int128
)
9113 if (int128_integer_type_node
== NULL_TREE
)
9115 error ("%<__int128%> is not supported by this target");
9116 explicit_int128
= false;
9118 else if (pedantic
&& ! in_system_header
)
9119 pedwarn (input_location
, OPT_Wpedantic
,
9120 "ISO C++ does not support %<__int128%> for %qs", name
);
9123 /* Now process the modifiers that were specified
9124 and check for invalid combinations. */
9126 /* Long double is a special combination. */
9127 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9130 type
= cp_build_qualified_type (long_double_type_node
,
9131 cp_type_quals (type
));
9134 /* Check all other uses of type modifiers. */
9136 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9140 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9141 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9142 else if (signed_p
&& unsigned_p
)
9143 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9144 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9145 error ("%<long long%> invalid for %qs", name
);
9146 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9147 error ("%<long%> invalid for %qs", name
);
9148 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9149 error ("%<short%> invalid for %qs", name
);
9150 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9151 error ("%<long%> or %<short%> invalid for %qs", name
);
9152 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_int128
)
9153 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9154 else if ((long_p
|| short_p
) && explicit_char
)
9155 error ("%<long%> or %<short%> specified with char for %qs", name
);
9156 else if (long_p
&& short_p
)
9157 error ("%<long%> and %<short%> specified together for %qs", name
);
9158 else if (type
== char16_type_node
|| type
== char32_type_node
)
9160 if (signed_p
|| unsigned_p
)
9161 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9162 else if (short_p
|| long_p
)
9163 error ("%<short%> or %<long%> invalid for %qs", name
);
9168 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_int128
&& pedantic
)
9170 pedwarn (input_location
, OPT_Wpedantic
,
9171 "long, short, signed or unsigned used invalidly for %qs",
9173 if (flag_pedantic_errors
)
9178 /* Discard the type modifiers if they are invalid. */
9189 /* Decide whether an integer type is signed or not.
9190 Optionally treat bitfields as signed by default. */
9194 It is implementation-defined whether a plain (neither
9195 explicitly signed or unsigned) char, short, int, or long
9196 bit-field is signed or unsigned.
9198 Naturally, we extend this to long long as well. Note that
9199 this does not include wchar_t. */
9200 || (bitfield
&& !flag_signed_bitfields
9202 /* A typedef for plain `int' without `signed' can be
9203 controlled just like plain `int', but a typedef for
9204 `signed int' cannot be so controlled. */
9206 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9207 && TREE_CODE (type
) == INTEGER_TYPE
9208 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9210 if (explicit_int128
)
9211 type
= int128_unsigned_type_node
;
9213 type
= long_long_unsigned_type_node
;
9215 type
= long_unsigned_type_node
;
9217 type
= short_unsigned_type_node
;
9218 else if (type
== char_type_node
)
9219 type
= unsigned_char_type_node
;
9220 else if (typedef_decl
)
9221 type
= unsigned_type_for (type
);
9223 type
= unsigned_type_node
;
9225 else if (signed_p
&& type
== char_type_node
)
9226 type
= signed_char_type_node
;
9227 else if (explicit_int128
)
9228 type
= int128_integer_type_node
;
9230 type
= long_long_integer_type_node
;
9232 type
= long_integer_type_node
;
9234 type
= short_integer_type_node
;
9236 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9238 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9239 error ("complex invalid for %qs", name
);
9240 /* If we just have "complex", it is equivalent to
9241 "complex double", but if any modifiers at all are specified it is
9242 the complex form of TYPE. E.g, "complex short" is
9243 "complex short int". */
9244 else if (defaulted_int
&& ! longlong
&& ! explicit_int128
9245 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
9246 type
= complex_double_type_node
;
9247 else if (type
== integer_type_node
)
9248 type
= complex_integer_type_node
;
9249 else if (type
== float_type_node
)
9250 type
= complex_float_type_node
;
9251 else if (type
== double_type_node
)
9252 type
= complex_double_type_node
;
9253 else if (type
== long_double_type_node
)
9254 type
= complex_long_double_type_node
;
9256 type
= build_complex_type (type
);
9259 type_quals
= TYPE_UNQUALIFIED
;
9260 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9261 type_quals
|= TYPE_QUAL_CONST
;
9262 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9263 type_quals
|= TYPE_QUAL_VOLATILE
;
9264 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9265 type_quals
|= TYPE_QUAL_RESTRICT
;
9266 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9267 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9270 /* If we're using the injected-class-name to form a compound type or a
9271 declaration, replace it with the underlying class so we don't get
9272 redundant typedefs in the debug output. But if we are returning the
9273 type unchanged, leave it alone so that it's available to
9274 maybe_get_template_decl_from_type_decl. */
9275 if (CLASS_TYPE_P (type
)
9276 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9277 && type
== TREE_TYPE (TYPE_NAME (type
))
9278 && (declarator
|| type_quals
))
9279 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9281 type_quals
|= cp_type_quals (type
);
9282 type
= cp_build_qualified_type_real
9283 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
9284 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9285 /* We might have ignored or rejected some of the qualifiers. */
9286 type_quals
= cp_type_quals (type
);
9289 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9290 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9291 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9293 storage_class
= declspecs
->storage_class
;
9294 if (storage_class
== sc_static
)
9295 staticp
= 1 + (decl_context
== FIELD
);
9297 if (virtualp
&& staticp
== 2)
9299 error ("member %qD cannot be declared both virtual and static", dname
);
9300 storage_class
= sc_none
;
9303 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9305 /* Issue errors about use of storage classes for parameters. */
9306 if (decl_context
== PARM
)
9310 error ("typedef declaration invalid in parameter declaration");
9311 return error_mark_node
;
9313 else if (template_parm_flag
&& storage_class
!= sc_none
)
9315 error ("storage class specified for template parameter %qs", name
);
9316 return error_mark_node
;
9318 else if (storage_class
== sc_static
9319 || storage_class
== sc_extern
9321 error ("storage class specifiers invalid in parameter declarations");
9323 /* Function parameters cannot be constexpr. If we saw one, moan
9324 and pretend it wasn't there. */
9327 error ("a parameter cannot be declared %<constexpr%>");
9332 /* Give error if `virtual' is used outside of class declaration. */
9334 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9336 error ("%<virtual%> outside class declaration");
9340 /* Static anonymous unions are dealt with here. */
9341 if (staticp
&& decl_context
== TYPENAME
9343 && ANON_AGGR_TYPE_P (declspecs
->type
))
9344 decl_context
= FIELD
;
9346 /* Warn about storage classes that are invalid for certain
9347 kinds of declarations (parameters, typenames, etc.). */
9350 && storage_class
!= sc_extern
9351 && storage_class
!= sc_static
)
9354 error ("multiple storage classes in declaration of %qs", name
);
9357 if (decl_context
!= NORMAL
9358 && ((storage_class
!= sc_none
9359 && storage_class
!= sc_mutable
)
9362 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9363 && (storage_class
== sc_register
9364 || storage_class
== sc_auto
))
9368 else if (decl_context
== FIELD
9369 /* C++ allows static class elements. */
9370 && storage_class
== sc_static
)
9371 /* C++ also allows inlines and signed and unsigned elements,
9372 but in those cases we don't come in here. */
9376 if (decl_context
== FIELD
)
9377 error ("storage class specified for %qs", name
);
9380 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9381 error ("storage class specified for parameter %qs", name
);
9383 error ("storage class specified for typename");
9385 if (storage_class
== sc_register
9386 || storage_class
== sc_auto
9387 || storage_class
== sc_extern
9389 storage_class
= sc_none
;
9392 else if (storage_class
== sc_extern
&& funcdef_flag
9393 && ! toplevel_bindings_p ())
9394 error ("nested function %qs declared %<extern%>", name
);
9395 else if (toplevel_bindings_p ())
9397 if (storage_class
== sc_auto
)
9398 error ("top-level declaration of %qs specifies %<auto%>", name
);
9401 && storage_class
!= sc_extern
9402 && storage_class
!= sc_static
)
9404 if (declspecs
->gnu_thread_keyword_p
)
9405 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9406 "declared %<__thread%>", name
);
9408 /* When thread_local is applied to a variable of block scope the
9409 storage-class-specifier static is implied if it does not appear
9411 storage_class
= declspecs
->storage_class
= sc_static
;
9415 if (storage_class
&& friendp
)
9417 error ("storage class specifiers invalid in friend function declarations");
9418 storage_class
= sc_none
;
9423 unqualified_id
= NULL_TREE
;
9426 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9427 switch (TREE_CODE (unqualified_id
))
9430 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9431 if (TYPE_P (unqualified_id
))
9432 unqualified_id
= constructor_name (unqualified_id
);
9435 case IDENTIFIER_NODE
:
9436 case TEMPLATE_ID_EXPR
:
9444 if (declspecs
->std_attributes
)
9446 /* Apply the c++11 attributes to the type preceding them. */
9447 input_location
= declspecs
->locations
[ds_std_attribute
];
9448 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9449 input_location
= saved_loc
;
9452 /* Determine the type of the entity declared by recurring on the
9454 for (; declarator
; declarator
= declarator
->declarator
)
9456 const cp_declarator
*inner_declarator
;
9459 if (type
== error_mark_node
)
9460 return error_mark_node
;
9462 attrs
= declarator
->attributes
;
9468 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9469 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9470 if (declarator
->kind
== cdk_function
)
9471 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9472 if (declarator
->kind
== cdk_array
)
9473 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9474 returned_attrs
= decl_attributes (&type
,
9475 chainon (returned_attrs
, attrs
),
9479 if (declarator
->kind
== cdk_id
)
9482 inner_declarator
= declarator
->declarator
;
9484 switch (declarator
->kind
)
9487 type
= create_array_type_for_decl (dname
, type
,
9488 declarator
->u
.array
.bounds
);
9489 if (declarator
->std_attributes
)
9492 The optional attribute-specifier-seq appertains to the
9494 returned_attrs
= chainon (returned_attrs
,
9495 declarator
->std_attributes
);
9503 /* Declaring a function type.
9504 Make sure we have a valid type for the function to return. */
9506 if (type_quals
!= TYPE_UNQUALIFIED
)
9508 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9509 warning (OPT_Wignored_qualifiers
,
9510 "type qualifiers ignored on function return type");
9511 /* We now know that the TYPE_QUALS don't apply to the
9512 decl, but to its return type. */
9513 type_quals
= TYPE_UNQUALIFIED
;
9515 errmsg
= targetm
.invalid_return_type (type
);
9519 type
= integer_type_node
;
9522 /* Error about some types functions can't return. */
9524 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9526 error ("%qs declared as function returning a function", name
);
9527 return error_mark_node
;
9529 if (TREE_CODE (type
) == ARRAY_TYPE
)
9531 error ("%qs declared as function returning an array", name
);
9532 return error_mark_node
;
9535 input_location
= declspecs
->locations
[ds_type_spec
];
9536 abstract_virtuals_error (ACU_RETURN
, type
);
9537 input_location
= saved_loc
;
9539 /* Pick up type qualifiers which should be applied to `this'. */
9540 memfn_quals
= declarator
->u
.function
.qualifiers
;
9541 /* Pick up virt-specifiers. */
9542 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9543 /* And ref-qualifier, too */
9544 rqual
= declarator
->u
.function
.ref_qualifier
;
9545 /* Pick up the exception specifications. */
9546 raises
= declarator
->u
.function
.exception_specification
;
9547 /* If the exception-specification is ill-formed, let's pretend
9548 there wasn't one. */
9549 if (raises
== error_mark_node
)
9552 /* Say it's a definition only for the CALL_EXPR
9553 closest to the identifier. */
9554 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9556 /* Handle a late-specified return type. */
9559 if (type_uses_auto (type
))
9561 if (!declarator
->u
.function
.late_return_type
)
9563 if (current_class_type
9564 && LAMBDA_TYPE_P (current_class_type
))
9565 /* OK for C++11 lambdas. */;
9566 else if (cxx_dialect
< cxx1y
)
9567 pedwarn (input_location
, 0, "%qs function uses "
9568 "%<auto%> type specifier without trailing "
9569 "return type", name
);
9571 permerror (input_location
, "virtual function cannot "
9572 "have deduced return type");
9574 else if (!is_auto (type
))
9576 error ("%qs function with trailing return type has"
9577 " %qT as its type rather than plain %<auto%>",
9579 return error_mark_node
;
9582 else if (declarator
->u
.function
.late_return_type
)
9584 if (cxx_dialect
< cxx11
)
9585 /* Not using maybe_warn_cpp0x because this should
9586 always be an error. */
9587 error ("trailing return type only available with "
9588 "-std=c++11 or -std=gnu++11");
9590 error ("%qs function with trailing return type not "
9591 "declared with %<auto%> type specifier", name
);
9592 return error_mark_node
;
9595 type
= splice_late_return_type
9596 (type
, declarator
->u
.function
.late_return_type
);
9597 if (type
== error_mark_node
)
9598 return error_mark_node
;
9600 if (ctype
== NULL_TREE
9601 && decl_context
== FIELD
9603 && (friendp
== 0 || dname
== current_class_name
))
9604 ctype
= current_class_type
;
9606 if (ctype
&& (sfk
== sfk_constructor
9607 || sfk
== sfk_destructor
))
9609 /* We are within a class's scope. If our declarator name
9610 is the same as the class name, and we are defining
9611 a function, then it is a constructor/destructor, and
9612 therefore returns a void type. */
9614 /* ISO C++ 12.4/2. A destructor may not be declared
9615 const or volatile. A destructor may not be static.
9616 A destructor may not be declared with ref-qualifier.
9618 ISO C++ 12.1. A constructor may not be declared
9619 const or volatile. A constructor may not be
9620 virtual. A constructor may not be static.
9621 A constructor may not be declared with ref-qualifier. */
9623 error ((flags
== DTOR_FLAG
)
9624 ? G_("destructor cannot be static member function")
9625 : G_("constructor cannot be static member function"));
9628 error ((flags
== DTOR_FLAG
)
9629 ? G_("destructors may not be cv-qualified")
9630 : G_("constructors may not be cv-qualified"));
9631 memfn_quals
= TYPE_UNQUALIFIED
;
9636 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
9637 error ((flags
== DTOR_FLAG
)
9638 ? "destructors may not be ref-qualified"
9639 : "constructors may not be ref-qualified");
9640 rqual
= REF_QUAL_NONE
;
9643 if (decl_context
== FIELD
9644 && !member_function_or_else (ctype
,
9647 return error_mark_node
;
9649 if (flags
!= DTOR_FLAG
)
9651 /* It's a constructor. */
9656 permerror (input_location
, "constructors cannot be declared virtual");
9659 if (decl_context
== FIELD
9660 && sfk
!= sfk_constructor
)
9661 return error_mark_node
;
9663 if (decl_context
== FIELD
)
9669 error ("can%'t initialize friend function %qs", name
);
9672 /* Cannot be both friend and virtual. */
9673 error ("virtual functions cannot be friends");
9676 if (decl_context
== NORMAL
)
9677 error ("friend declaration not in class definition");
9678 if (current_function_decl
&& funcdef_flag
)
9679 error ("can%'t define friend function %qs in a local "
9683 else if (ctype
&& sfk
== sfk_conversion
)
9687 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9692 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9695 if (inner_declarator
9696 && inner_declarator
->kind
== cdk_id
9697 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9698 && arg_types
!= void_list_node
)
9700 error ("destructors may not have parameters");
9701 arg_types
= void_list_node
;
9705 type
= build_function_type (type
, arg_types
);
9706 if (declarator
->std_attributes
)
9709 The optional attribute-specifier-seq appertains to
9710 the function type. */
9711 decl_attributes (&type
, declarator
->std_attributes
,
9719 /* Filter out pointers-to-references and references-to-references.
9720 We can get these if a TYPE_DECL is used. */
9722 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9724 if (declarator
->kind
!= cdk_reference
)
9726 error ("cannot declare pointer to %q#T", type
);
9727 type
= TREE_TYPE (type
);
9730 /* In C++0x, we allow reference to reference declarations
9731 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9732 and template type arguments [14.3.1/4 temp.arg.type]. The
9733 check for direct reference to reference declarations, which
9734 are still forbidden, occurs below. Reasoning behind the change
9735 can be found in DR106, DR540, and the rvalue reference
9737 else if (cxx_dialect
== cxx98
)
9739 error ("cannot declare reference to %q#T", type
);
9740 type
= TREE_TYPE (type
);
9743 else if (VOID_TYPE_P (type
))
9745 if (declarator
->kind
== cdk_reference
)
9746 error ("cannot declare reference to %q#T", type
);
9747 else if (declarator
->kind
== cdk_ptrmem
)
9748 error ("cannot declare pointer to %q#T member", type
);
9751 /* We now know that the TYPE_QUALS don't apply to the decl,
9752 but to the target of the pointer. */
9753 type_quals
= TYPE_UNQUALIFIED
;
9755 /* This code used to handle METHOD_TYPE, but I don't think it's
9756 possible to get it here anymore. */
9757 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9758 if (declarator
->kind
== cdk_ptrmem
9759 && TREE_CODE (type
) == FUNCTION_TYPE
)
9761 memfn_quals
|= type_memfn_quals (type
);
9762 type
= build_memfn_type (type
,
9763 declarator
->u
.pointer
.class_type
,
9766 if (type
== error_mark_node
)
9767 return error_mark_node
;
9769 rqual
= REF_QUAL_NONE
;
9770 memfn_quals
= TYPE_UNQUALIFIED
;
9773 if (TREE_CODE (type
) == FUNCTION_TYPE
9774 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
9775 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
9776 error (declarator
->kind
== cdk_reference
9777 ? G_("cannot declare reference to qualified function type %qT")
9778 : G_("cannot declare pointer to qualified function type %qT"),
9781 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
))
9782 pedwarn (input_location
, OPT_Wvla
,
9783 declarator
->kind
== cdk_reference
9784 ? G_("reference to array of runtime bound")
9785 : G_("pointer to array of runtime bound"));
9787 /* When the pointed-to type involves components of variable size,
9788 care must be taken to ensure that the size evaluation code is
9789 emitted early enough to dominate all the possible later uses
9790 and late enough for the variables on which it depends to have
9793 This is expected to happen automatically when the pointed-to
9794 type has a name/declaration of it's own, but special attention
9795 is required if the type is anonymous.
9797 We handle the NORMAL and FIELD contexts here by inserting a
9798 dummy statement that just evaluates the size at a safe point
9799 and ensures it is not deferred until e.g. within a deeper
9800 conditional context (c++/43555).
9802 We expect nothing to be needed here for PARM or TYPENAME.
9803 Evaluating the size at this point for TYPENAME would
9804 actually be incorrect, as we might be in the middle of an
9805 expression with side effects on the pointed-to type size
9806 "arguments" prior to the pointer declaration point and the
9807 size evaluation could end up prior to the side effects. */
9809 if (!TYPE_NAME (type
)
9810 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9811 && at_function_scope_p ()
9812 && variably_modified_type_p (type
, NULL_TREE
))
9813 /* Force evaluation of the SAVE_EXPR. */
9814 finish_expr_stmt (TYPE_SIZE (type
));
9816 if (declarator
->kind
== cdk_reference
)
9818 /* In C++0x, the type we are creating a reference to might be
9819 a typedef which is itself a reference type. In that case,
9820 we follow the reference collapsing rules in
9821 [7.1.3/8 dcl.typedef] to create the final reference type:
9823 "If a typedef TD names a type that is a reference to a type
9824 T, an attempt to create the type 'lvalue reference to cv TD'
9825 creates the type 'lvalue reference to T,' while an attempt
9826 to create the type "rvalue reference to cv TD' creates the
9829 if (VOID_TYPE_P (type
))
9830 /* We already gave an error. */;
9831 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9833 if (declarator
->u
.reference
.rvalue_ref
)
9834 /* Leave type alone. */;
9836 type
= cp_build_reference_type (TREE_TYPE (type
), false);
9839 type
= cp_build_reference_type
9840 (type
, declarator
->u
.reference
.rvalue_ref
);
9842 /* In C++0x, we need this check for direct reference to
9843 reference declarations, which are forbidden by
9844 [8.3.2/5 dcl.ref]. Reference to reference declarations
9845 are only allowed indirectly through typedefs and template
9846 type arguments. Example:
9848 void foo(int & &); // invalid ref-to-ref decl
9850 typedef int & int_ref;
9851 void foo(int_ref &); // valid ref-to-ref decl
9853 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
9854 error ("cannot declare reference to %q#T, which is not "
9855 "a typedef or a template type argument", type
);
9857 else if (TREE_CODE (type
) == METHOD_TYPE
)
9858 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9859 else if (declarator
->kind
== cdk_ptrmem
)
9861 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
9863 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
9864 /* We will already have complained. */
9865 type
= error_mark_node
;
9867 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
9871 type
= build_pointer_type (type
);
9873 /* Process a list of type modifier keywords (such as
9874 const or volatile) that were given inside the `*' or `&'. */
9876 if (declarator
->u
.pointer
.qualifiers
)
9879 = cp_build_qualified_type (type
,
9880 declarator
->u
.pointer
.qualifiers
);
9881 type_quals
= cp_type_quals (type
);
9884 /* Apply C++11 attributes to the pointer, and not to the
9885 type pointed to. This is unlike what is done for GNU
9886 attributes above. It is to comply with [dcl.ptr]/1:
9888 [the optional attribute-specifier-seq (7.6.1) appertains
9889 to the pointer and not to the object pointed to]. */
9890 if (declarator
->std_attributes
)
9891 decl_attributes (&type
, declarator
->std_attributes
,
9905 /* A `constexpr' specifier used in an object declaration declares
9906 the object as `const'. */
9907 if (constexpr_p
&& innermost_code
!= cdk_function
)
9909 if (type_quals
& TYPE_QUAL_VOLATILE
)
9910 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9911 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9913 type_quals
|= TYPE_QUAL_CONST
;
9914 type
= cp_build_qualified_type (type
, type_quals
);
9918 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
9919 && TREE_CODE (type
) != FUNCTION_TYPE
9920 && TREE_CODE (type
) != METHOD_TYPE
)
9922 error ("template-id %qD used as a declarator",
9924 unqualified_id
= dname
;
9927 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9928 qualified with a class-name, turn it into a METHOD_TYPE, unless
9929 we know that the function is static. We take advantage of this
9930 opportunity to do other processing that pertains to entities
9931 explicitly declared to be class members. Note that if DECLARATOR
9932 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9933 would not have exited the loop above. */
9935 && declarator
->u
.id
.qualifying_scope
9936 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
9938 ctype
= declarator
->u
.id
.qualifying_scope
;
9939 ctype
= TYPE_MAIN_VARIANT (ctype
);
9940 template_count
= num_template_headers_for_class (ctype
);
9942 if (ctype
== current_class_type
)
9946 permerror (input_location
, "member functions are implicitly friends of their class");
9950 permerror (declarator
->id_loc
,
9951 "extra qualification %<%T::%> on member %qs",
9954 else if (/* If the qualifying type is already complete, then we
9955 can skip the following checks. */
9956 !COMPLETE_TYPE_P (ctype
)
9957 && (/* If the function is being defined, then
9958 qualifying type must certainly be complete. */
9960 /* A friend declaration of "T::f" is OK, even if
9961 "T" is a template parameter. But, if this
9962 function is not a friend, the qualifying type
9964 || (!friendp
&& !CLASS_TYPE_P (ctype
))
9965 /* For a declaration, the type need not be
9966 complete, if either it is dependent (since there
9967 is no meaningful definition of complete in that
9968 case) or the qualifying class is currently being
9970 || !(dependent_type_p (ctype
)
9971 || currently_open_class (ctype
)))
9972 /* Check that the qualifying type is complete. */
9973 && !complete_type_or_else (ctype
, NULL_TREE
))
9974 return error_mark_node
;
9975 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9977 if (current_class_type
9978 && (!friendp
|| funcdef_flag
))
9981 ? G_("cannot define member function %<%T::%s%> "
9983 : G_("cannot declare member function %<%T::%s%> "
9985 ctype
, name
, current_class_type
);
9986 return error_mark_node
;
9989 else if (typedef_p
&& current_class_type
)
9991 error ("cannot declare member %<%T::%s%> within %qT",
9992 ctype
, name
, current_class_type
);
9993 return error_mark_node
;
9997 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
9998 ctype
= current_class_type
;
10000 /* Now TYPE has the actual type. */
10002 if (returned_attrs
)
10005 *attrlist
= chainon (returned_attrs
, *attrlist
);
10007 attrlist
= &returned_attrs
;
10011 && declarator
->kind
== cdk_id
10012 && declarator
->std_attributes
)
10013 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10014 a declarator-id appertains to the entity that is declared. */
10015 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10017 /* Handle parameter packs. */
10018 if (parameter_pack_p
)
10020 if (decl_context
== PARM
)
10021 /* Turn the type into a pack expansion.*/
10022 type
= make_pack_expansion (type
);
10024 error ("non-parameter %qs cannot be a parameter pack", name
);
10027 /* Did array size calculations overflow or does the array cover more
10028 than half of the address-space? */
10029 if (TREE_CODE (type
) == ARRAY_TYPE
10030 && COMPLETE_TYPE_P (type
)
10031 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
10032 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
10034 error ("size of array %qs is too large", name
);
10035 /* If we proceed with the array type as it is, we'll eventually
10036 crash in tree_to_[su]hwi(). */
10037 type
= error_mark_node
;
10040 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10041 && !processing_template_decl
10042 && variably_modified_type_p (type
, NULL_TREE
))
10044 if (decl_context
== FIELD
)
10045 error ("data member may not have variably modified type %qT", type
);
10047 error ("parameter may not have variably modified type %qT", type
);
10048 type
= error_mark_node
;
10051 if (explicitp
== 1 || (explicitp
&& friendp
))
10053 /* [dcl.fct.spec] The explicit specifier shall only be used in
10054 declarations of constructors within a class definition. */
10055 error ("only declarations of constructors can be %<explicit%>");
10059 if (storage_class
== sc_mutable
)
10061 if (decl_context
!= FIELD
|| friendp
)
10063 error ("non-member %qs cannot be declared %<mutable%>", name
);
10064 storage_class
= sc_none
;
10066 else if (decl_context
== TYPENAME
|| typedef_p
)
10068 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10069 storage_class
= sc_none
;
10071 else if (TREE_CODE (type
) == FUNCTION_TYPE
10072 || TREE_CODE (type
) == METHOD_TYPE
)
10074 error ("function %qs cannot be declared %<mutable%>", name
);
10075 storage_class
= sc_none
;
10079 error ("static %qs cannot be declared %<mutable%>", name
);
10080 storage_class
= sc_none
;
10082 else if (type_quals
& TYPE_QUAL_CONST
)
10084 error ("const %qs cannot be declared %<mutable%>", name
);
10085 storage_class
= sc_none
;
10087 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10089 permerror (input_location
, "reference %qs cannot be declared "
10090 "%<mutable%>", name
);
10091 storage_class
= sc_none
;
10095 /* If this is declaring a typedef name, return a TYPE_DECL. */
10096 if (typedef_p
&& decl_context
!= TYPENAME
)
10100 /* Note that the grammar rejects storage classes
10101 in typenames, fields or parameters. */
10102 if (current_lang_name
== lang_name_java
)
10103 TYPE_FOR_JAVA (type
) = 1;
10105 /* This declaration:
10107 typedef void f(int) const;
10109 declares a function type which is not a member of any
10110 particular class, but which is cv-qualified; for
10111 example "f S::*" declares a pointer to a const-qualified
10112 member function of S. We record the cv-qualification in the
10114 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10116 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10118 /* We have now dealt with these qualifiers. */
10119 memfn_quals
= TYPE_UNQUALIFIED
;
10120 rqual
= REF_QUAL_NONE
;
10123 if (type_uses_auto (type
))
10125 error ("typedef declared %<auto%>");
10126 type
= error_mark_node
;
10129 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
))
10130 pedwarn (input_location
, OPT_Wvla
,
10131 "typedef naming array of runtime bound");
10133 if (decl_context
== FIELD
)
10134 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10136 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10137 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10138 error_at (DECL_SOURCE_LOCATION (decl
),
10139 "typedef name may not be a nested-name-specifier");
10140 TREE_TYPE (decl
) = error_mark_node
;
10143 if (decl_context
!= FIELD
)
10145 if (!current_function_decl
)
10146 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10147 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10148 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10149 (current_function_decl
)))
10150 /* The TYPE_DECL is "abstract" because there will be
10151 clones of this constructor/destructor, and there will
10152 be copies of this TYPE_DECL generated in those
10154 DECL_ABSTRACT (decl
) = 1;
10156 else if (current_class_type
10157 && constructor_name_p (unqualified_id
, current_class_type
))
10158 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10159 "as enclosing class",
10162 /* If the user declares "typedef struct {...} foo" then the
10163 struct will have an anonymous name. Fill that name in now.
10164 Nothing can refer to it, so nothing needs know about the name
10166 if (type
!= error_mark_node
10168 && TYPE_NAME (type
)
10169 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10170 && TYPE_ANONYMOUS_P (type
)
10171 && declspecs
->type_definition_p
10172 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10176 /* Replace the anonymous name with the real name everywhere. */
10177 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10179 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10180 /* We do not rename the debug info representing the
10181 anonymous tagged type because the standard says in
10182 [dcl.typedef] that the naming applies only for
10183 linkage purposes. */
10184 /*debug_hooks->set_name (t, decl);*/
10185 TYPE_NAME (t
) = decl
;
10188 if (TYPE_LANG_SPECIFIC (type
))
10189 TYPE_WAS_ANONYMOUS (type
) = 1;
10191 /* If this is a typedef within a template class, the nested
10192 type is a (non-primary) template. The name for the
10193 template needs updating as well. */
10194 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10195 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10196 = TYPE_IDENTIFIER (type
);
10198 /* Adjust linkage now that we aren't anonymous anymore. */
10199 reset_type_linkage (type
);
10201 /* FIXME remangle member functions; member functions of a
10202 type with external linkage have external linkage. */
10206 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10207 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10209 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10210 memfn_quals
!= TYPE_UNQUALIFIED
,
10211 inlinep
, friendp
, raises
!= NULL_TREE
);
10213 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10214 /* Acknowledge that this was written:
10215 `using analias = atype;'. */
10216 TYPE_DECL_ALIAS_P (decl
) = 1;
10221 /* Detect the case of an array type of unspecified size
10222 which came, as such, direct from a typedef name.
10223 We must copy the type, so that the array's domain can be
10224 individually set by the object's initializer. */
10226 if (type
&& typedef_type
10227 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10228 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10229 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10231 /* Detect where we're using a typedef of function type to declare a
10232 function. PARMS will not be set, so we must create it now. */
10234 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10236 tree decls
= NULL_TREE
;
10239 for (args
= TYPE_ARG_TYPES (type
);
10240 args
&& args
!= void_list_node
;
10241 args
= TREE_CHAIN (args
))
10243 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10245 DECL_CHAIN (decl
) = decls
;
10249 parms
= nreverse (decls
);
10251 if (decl_context
!= TYPENAME
)
10253 /* A cv-qualifier-seq shall only be part of the function type
10254 for a non-static member function. A ref-qualifier shall only
10255 .... /same as above/ [dcl.fct] */
10256 if ((type_memfn_quals (type
) != TYPE_UNQUALIFIED
10257 || type_memfn_rqual (type
) != REF_QUAL_NONE
)
10258 && (current_class_type
== NULL_TREE
|| staticp
) )
10261 ? G_("qualified function types cannot be used to "
10262 "declare static member functions")
10263 : G_("qualified function types cannot be used to "
10264 "declare free functions"));
10265 type
= TYPE_MAIN_VARIANT (type
);
10268 /* The qualifiers on the function type become the qualifiers on
10269 the non-static member function. */
10270 memfn_quals
|= type_memfn_quals (type
);
10271 rqual
= type_memfn_rqual (type
);
10272 type_quals
= TYPE_UNQUALIFIED
;
10276 /* If this is a type name (such as, in a cast or sizeof),
10277 compute the type and return it now. */
10279 if (decl_context
== TYPENAME
)
10281 /* Note that the grammar rejects storage classes
10282 in typenames, fields or parameters. */
10283 if (type_quals
!= TYPE_UNQUALIFIED
)
10284 type_quals
= TYPE_UNQUALIFIED
;
10286 /* Special case: "friend class foo" looks like a TYPENAME context. */
10289 if (type_quals
!= TYPE_UNQUALIFIED
)
10291 error ("type qualifiers specified for friend class declaration");
10292 type_quals
= TYPE_UNQUALIFIED
;
10296 error ("%<inline%> specified for friend class declaration");
10302 /* Don't allow friend declaration without a class-key. */
10303 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10304 permerror (input_location
, "template parameters cannot be friends");
10305 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10306 permerror (input_location
, "friend declaration requires class-key, "
10307 "i.e. %<friend class %T::%D%>",
10308 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10310 permerror (input_location
, "friend declaration requires class-key, "
10311 "i.e. %<friend %#T%>",
10315 /* Only try to do this stuff if we didn't already give up. */
10316 if (type
!= integer_type_node
)
10318 /* A friendly class? */
10319 if (current_class_type
)
10320 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10321 /*complain=*/true);
10323 error ("trying to make class %qT a friend of global scope",
10326 type
= void_type_node
;
10329 else if (memfn_quals
|| rqual
)
10331 if (ctype
== NULL_TREE
10332 && TREE_CODE (type
) == METHOD_TYPE
)
10333 ctype
= TYPE_METHOD_BASETYPE (type
);
10336 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10337 /* Core issue #547: need to allow this in template type args.
10338 Allow it in general in C++11 for alias-declarations. */
10339 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10340 && TREE_CODE (type
) == FUNCTION_TYPE
)
10341 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10343 error ("invalid qualifiers on non-member function type");
10348 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10349 && decl_context
!= CATCHPARM
10350 && TREE_CODE (type
) != UNION_TYPE
10353 error ("abstract declarator %qT used as declaration", type
);
10354 return error_mark_node
;
10357 /* Only functions may be declared using an operator-function-id. */
10359 && IDENTIFIER_OPNAME_P (unqualified_id
)
10360 && TREE_CODE (type
) != FUNCTION_TYPE
10361 && TREE_CODE (type
) != METHOD_TYPE
)
10363 error ("declaration of %qD as non-function", unqualified_id
);
10364 return error_mark_node
;
10367 /* We don't check parameter types here because we can emit a better
10368 error message later. */
10369 if (decl_context
!= PARM
)
10371 type
= check_var_type (unqualified_id
, type
);
10372 if (type
== error_mark_node
)
10373 return error_mark_node
;
10376 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10377 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10379 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10381 if (ctype
|| in_namespace
)
10382 error ("cannot use %<::%> in parameter declaration");
10384 if (type_uses_auto (type
))
10386 if (cxx_dialect
>= cxx1y
)
10387 error ("%<auto%> parameter not permitted in this context");
10389 error ("parameter declared %<auto%>");
10390 type
= error_mark_node
;
10393 /* A parameter declared as an array of T is really a pointer to T.
10394 One declared as a function is really a pointer to a function.
10395 One declared as a member is really a pointer to member. */
10397 if (TREE_CODE (type
) == ARRAY_TYPE
)
10399 /* Transfer const-ness of array into that of type pointed to. */
10400 type
= build_pointer_type (TREE_TYPE (type
));
10401 type_quals
= TYPE_UNQUALIFIED
;
10403 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10404 type
= build_pointer_type (type
);
10407 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10408 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10410 cp_cv_quals real_quals
= memfn_quals
;
10411 if (constexpr_p
&& sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10412 real_quals
|= TYPE_QUAL_CONST
;
10413 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10419 if (decl_context
== PARM
)
10421 decl
= cp_build_parm_decl (unqualified_id
, type
);
10423 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10424 memfn_quals
!= TYPE_UNQUALIFIED
,
10425 inlinep
, friendp
, raises
!= NULL_TREE
);
10427 else if (decl_context
== FIELD
)
10429 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10430 && type_uses_auto (type
))
10432 error ("non-static data member declared %<auto%>");
10433 type
= error_mark_node
;
10436 /* The C99 flexible array extension. */
10437 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10438 && TYPE_DOMAIN (type
) == NULL_TREE
)
10440 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10441 tf_warning_or_error
);
10442 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10445 if (type
== error_mark_node
)
10447 /* Happens when declaring arrays of sizes which
10448 are error_mark_node, for example. */
10451 else if (in_namespace
&& !friendp
)
10453 /* Something like struct S { int N::j; }; */
10454 error ("invalid use of %<::%>");
10455 return error_mark_node
;
10457 else if (TREE_CODE (type
) == FUNCTION_TYPE
10458 || TREE_CODE (type
) == METHOD_TYPE
)
10461 tree function_context
;
10465 /* This should never happen in pure C++ (the check
10466 could be an assert). It could happen in
10467 Objective-C++ if someone writes invalid code that
10468 uses a function declaration for an instance
10469 variable or property (instance variables and
10470 properties are parsed as FIELD_DECLs, but they are
10471 part of an Objective-C class, not a C++ class).
10472 That code is invalid and is caught by this
10476 error ("declaration of function %qD in invalid context",
10478 return error_mark_node
;
10481 /* ``A union may [ ... ] not [ have ] virtual functions.''
10483 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10485 error ("function %qD declared virtual inside a union",
10487 return error_mark_node
;
10490 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10494 error ("%qD cannot be declared virtual, since it "
10495 "is always static",
10502 /* Check that the name used for a destructor makes sense. */
10503 if (sfk
== sfk_destructor
)
10505 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10509 gcc_assert (friendp
);
10510 error ("expected qualified name in friend declaration "
10511 "for destructor %qD", uqname
);
10512 return error_mark_node
;
10515 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10517 error ("declaration of %qD as member of %qT",
10519 return error_mark_node
;
10523 error ("a destructor cannot be %<constexpr%>");
10524 return error_mark_node
;
10527 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10529 error ("expected qualified name in friend declaration "
10530 "for constructor %qD",
10531 id_declarator
->u
.id
.unqualified_name
);
10532 return error_mark_node
;
10535 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10536 function_context
= (ctype
!= NULL_TREE
) ?
10537 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10538 publicp
= (! friendp
|| ! staticp
)
10539 && function_context
== NULL_TREE
;
10540 decl
= grokfndecl (ctype
, type
,
10541 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10542 ? unqualified_id
: dname
,
10545 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10546 friendp
? -1 : 0, friendp
, publicp
,
10547 inlinep
| (2 * constexpr_p
),
10549 funcdef_flag
, template_count
, in_namespace
,
10550 attrlist
, declarator
->id_loc
);
10551 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10552 if (decl
== NULL_TREE
)
10553 return error_mark_node
;
10555 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10556 /* The decl and setting of decl_attr is also turned off. */
10557 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10560 /* [class.conv.ctor]
10562 A constructor declared without the function-specifier
10563 explicit that can be called with a single parameter
10564 specifies a conversion from the type of its first
10565 parameter to the type of its class. Such a constructor
10566 is called a converting constructor. */
10567 if (explicitp
== 2)
10568 DECL_NONCONVERTING_P (decl
) = 1;
10570 else if (!staticp
&& !dependent_type_p (type
)
10571 && !COMPLETE_TYPE_P (complete_type (type
))
10572 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10574 if (unqualified_id
)
10575 error ("field %qD has incomplete type %qT",
10576 unqualified_id
, type
);
10578 error ("name %qT has incomplete type", type
);
10580 type
= error_mark_node
;
10587 error ("%qE is neither function nor member function; "
10588 "cannot be declared friend", unqualified_id
);
10596 /* Friends are treated specially. */
10597 if (ctype
== current_class_type
)
10598 ; /* We already issued a permerror. */
10599 else if (decl
&& DECL_NAME (decl
))
10601 if (template_class_depth (current_class_type
) == 0)
10603 decl
= check_explicit_specialization
10604 (unqualified_id
, decl
, template_count
,
10605 2 * funcdef_flag
+ 4);
10606 if (decl
== error_mark_node
)
10607 return error_mark_node
;
10610 decl
= do_friend (ctype
, unqualified_id
, decl
,
10616 return error_mark_node
;
10619 /* Structure field. It may not be a function, except for C++. */
10621 if (decl
== NULL_TREE
)
10625 /* C++ allows static class members. All other work
10626 for this is done by grokfield. */
10627 decl
= build_lang_decl_loc (declarator
->id_loc
,
10628 VAR_DECL
, unqualified_id
, type
);
10629 set_linkage_for_static_data_member (decl
);
10630 /* Even if there is an in-class initialization, DECL
10631 is considered undefined until an out-of-class
10632 definition is provided. */
10633 DECL_EXTERNAL (decl
) = 1;
10637 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
10638 if (declspecs
->gnu_thread_keyword_p
)
10639 DECL_GNU_TLS_P (decl
) = true;
10642 if (constexpr_p
&& !initialized
)
10644 error ("constexpr static data member %qD must have an "
10645 "initializer", decl
);
10646 constexpr_p
= false;
10653 error ("non-static data member %qE declared %<constexpr%>",
10655 constexpr_p
= false;
10657 decl
= build_decl (input_location
,
10658 FIELD_DECL
, unqualified_id
, type
);
10659 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10660 if (bitfield
&& !unqualified_id
)
10661 TREE_NO_WARNING (decl
) = 1;
10663 if (storage_class
== sc_mutable
)
10665 DECL_MUTABLE_P (decl
) = 1;
10666 storage_class
= sc_none
;
10671 /* An attempt is being made to initialize a non-static
10672 member. This is new in C++11. */
10673 maybe_warn_cpp0x (CPP0X_NSDMI
);
10675 /* If this has been parsed with static storage class, but
10676 errors forced staticp to be cleared, ensure NSDMI is
10678 if (declspecs
->storage_class
== sc_static
)
10679 DECL_INITIAL (decl
) = error_mark_node
;
10683 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10684 memfn_quals
!= TYPE_UNQUALIFIED
,
10685 inlinep
, friendp
, raises
!= NULL_TREE
);
10688 else if (TREE_CODE (type
) == FUNCTION_TYPE
10689 || TREE_CODE (type
) == METHOD_TYPE
)
10691 tree original_name
;
10694 if (!unqualified_id
)
10695 return error_mark_node
;
10697 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10698 original_name
= dname
;
10700 original_name
= unqualified_id
;
10702 if (storage_class
== sc_auto
)
10703 error ("storage class %<auto%> invalid for function %qs", name
);
10704 else if (storage_class
== sc_register
)
10705 error ("storage class %<register%> invalid for function %qs", name
);
10708 if (declspecs
->gnu_thread_keyword_p
)
10709 error ("storage class %<__thread%> invalid for function %qs",
10712 error ("storage class %<thread_local%> invalid for function %qs",
10716 if (virt_specifiers
)
10717 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10718 /* Function declaration not at top level.
10719 Storage classes other than `extern' are not allowed
10720 and `extern' makes no difference. */
10721 if (! toplevel_bindings_p ()
10722 && (storage_class
== sc_static
10723 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10726 if (storage_class
== sc_static
)
10727 pedwarn (input_location
, OPT_Wpedantic
,
10728 "%<static%> specified invalid for function %qs "
10729 "declared out of global scope", name
);
10731 pedwarn (input_location
, OPT_Wpedantic
,
10732 "%<inline%> specifier invalid for function %qs "
10733 "declared out of global scope", name
);
10736 if (ctype
== NULL_TREE
)
10740 error ("virtual non-class function %qs", name
);
10743 else if (sfk
== sfk_constructor
10744 || sfk
== sfk_destructor
)
10746 error (funcdef_flag
10747 ? G_("%qs defined in a non-class scope")
10748 : G_("%qs declared in a non-class scope"), name
);
10753 /* Record whether the function is public. */
10754 publicp
= (ctype
!= NULL_TREE
10755 || storage_class
!= sc_static
);
10757 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10758 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10760 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10762 template_count
, in_namespace
, attrlist
,
10763 declarator
->id_loc
);
10764 if (decl
== NULL_TREE
)
10765 return error_mark_node
;
10769 int invalid_static
= 0;
10771 /* Don't allow a static member function in a class, and forbid
10772 declaring main to be static. */
10773 if (TREE_CODE (type
) == METHOD_TYPE
)
10775 permerror (input_location
, "cannot declare member function %qD to have "
10776 "static linkage", decl
);
10777 invalid_static
= 1;
10779 else if (current_function_decl
)
10781 /* FIXME need arm citation */
10782 error ("cannot declare static function inside another function");
10783 invalid_static
= 1;
10786 if (invalid_static
)
10789 storage_class
= sc_none
;
10795 /* It's a variable. */
10797 /* An uninitialized decl with `extern' is a reference. */
10798 decl
= grokvardecl (type
, unqualified_id
,
10801 (type_quals
& TYPE_QUAL_CONST
) != 0,
10802 ctype
? ctype
: in_namespace
);
10803 bad_specifiers (decl
, BSP_VAR
, virtualp
,
10804 memfn_quals
!= TYPE_UNQUALIFIED
,
10805 inlinep
, friendp
, raises
!= NULL_TREE
);
10809 DECL_CONTEXT (decl
) = ctype
;
10812 permerror (input_location
, "%<static%> may not be used when defining "
10813 "(as opposed to declaring) a static data member");
10815 storage_class
= sc_none
;
10817 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
10819 error ("static member %qD declared %<register%>", decl
);
10820 storage_class
= sc_none
;
10822 if (storage_class
== sc_extern
&& pedantic
)
10824 pedwarn (input_location
, OPT_Wpedantic
,
10825 "cannot explicitly declare member %q#D to have "
10826 "extern linkage", decl
);
10827 storage_class
= sc_none
;
10830 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
10832 error ("declaration of constexpr variable %qD is not a definition",
10834 constexpr_p
= false;
10838 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
10840 if (toplevel_bindings_p ())
10842 /* It's common practice (and completely valid) to have a const
10843 be initialized and declared extern. */
10844 if (!(type_quals
& TYPE_QUAL_CONST
))
10845 warning (0, "%qs initialized and declared %<extern%>", name
);
10849 error ("%qs has both %<extern%> and initializer", name
);
10850 return error_mark_node
;
10854 /* Record `register' declaration for warnings on &
10855 and in case doing stupid register allocation. */
10857 if (storage_class
== sc_register
)
10858 DECL_REGISTER (decl
) = 1;
10859 else if (storage_class
== sc_extern
)
10860 DECL_THIS_EXTERN (decl
) = 1;
10861 else if (storage_class
== sc_static
)
10862 DECL_THIS_STATIC (decl
) = 1;
10864 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10865 if (constexpr_p
&& VAR_P (decl
))
10866 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
10868 /* Record constancy and volatility on the DECL itself . There's
10869 no need to do this when processing a template; we'll do this
10870 for the instantiated declaration based on the type of DECL. */
10871 if (!processing_template_decl
)
10872 cp_apply_type_quals_to_decl (type_quals
, decl
);
10878 /* Subroutine of start_function. Ensure that each of the parameter
10879 types (as listed in PARMS) is complete, as is required for a
10880 function definition. */
10883 require_complete_types_for_parms (tree parms
)
10885 for (; parms
; parms
= DECL_CHAIN (parms
))
10887 if (dependent_type_p (TREE_TYPE (parms
)))
10889 if (!VOID_TYPE_P (TREE_TYPE (parms
))
10890 && complete_type_or_else (TREE_TYPE (parms
), parms
))
10892 relayout_decl (parms
);
10893 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
10896 /* grokparms or complete_type_or_else will have already issued
10898 TREE_TYPE (parms
) = error_mark_node
;
10902 /* Returns nonzero if T is a local variable. */
10905 local_variable_p (const_tree t
)
10908 /* A VAR_DECL with a context that is a _TYPE is a static data
10910 && !TYPE_P (CP_DECL_CONTEXT (t
))
10911 /* Any other non-local variable must be at namespace scope. */
10912 && !DECL_NAMESPACE_SCOPE_P (t
))
10913 || (TREE_CODE (t
) == PARM_DECL
))
10919 /* Like local_variable_p, but suitable for use as a tree-walking
10923 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
10926 if (local_variable_p (*tp
)
10927 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
10929 else if (TYPE_P (*tp
))
10930 *walk_subtrees
= 0;
10935 /* Check that ARG, which is a default-argument expression for a
10936 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10937 something goes wrong. DECL may also be a _TYPE node, rather than a
10938 DECL, if there is no DECL available. */
10941 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
10946 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10947 /* We get a DEFAULT_ARG when looking at an in-class declaration
10948 with a default argument. Ignore the argument for now; we'll
10949 deal with it after the class is complete. */
10958 decl_type
= TREE_TYPE (decl
);
10960 if (arg
== error_mark_node
10961 || decl
== error_mark_node
10962 || TREE_TYPE (arg
) == error_mark_node
10963 || decl_type
== error_mark_node
)
10964 /* Something already went wrong. There's no need to check
10966 return error_mark_node
;
10968 /* [dcl.fct.default]
10970 A default argument expression is implicitly converted to the
10972 ++cp_unevaluated_operand
;
10973 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
10975 --cp_unevaluated_operand
;
10977 if (warn_zero_as_null_pointer_constant
10978 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
10979 && null_ptr_cst_p (arg
)
10980 && (complain
& tf_warning
)
10981 && maybe_warn_zero_as_null_pointer_constant (arg
, input_location
))
10982 return nullptr_node
;
10984 /* [dcl.fct.default]
10986 Local variables shall not be used in default argument
10989 The keyword `this' shall not be used in a default argument of a
10990 member function. */
10991 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
10994 if (complain
& tf_warning_or_error
)
10996 if (DECL_NAME (var
) == this_identifier
)
10997 permerror (input_location
, "default argument %qE uses %qD",
11000 error ("default argument %qE uses local variable %qD", arg
, var
);
11002 return error_mark_node
;
11009 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11012 type_is_deprecated (tree type
)
11014 enum tree_code code
;
11015 if (TREE_DEPRECATED (type
))
11017 if (TYPE_NAME (type
)
11018 && TREE_DEPRECATED (TYPE_NAME (type
)))
11021 /* Do warn about using typedefs to a deprecated class. */
11022 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11023 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11025 code
= TREE_CODE (type
);
11027 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11028 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11029 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11030 return type_is_deprecated (TREE_TYPE (type
));
11032 if (TYPE_PTRMEMFUNC_P (type
))
11033 return type_is_deprecated
11034 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11039 /* Decode the list of parameter types for a function type.
11040 Given the list of things declared inside the parens,
11041 return a list of types.
11043 If this parameter does not end with an ellipsis, we append
11046 *PARMS is set to the chain of PARM_DECLs created. */
11049 grokparms (tree parmlist
, tree
*parms
)
11051 tree result
= NULL_TREE
;
11052 tree decls
= NULL_TREE
;
11056 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11058 tree type
= NULL_TREE
;
11059 tree init
= TREE_PURPOSE (parm
);
11060 tree decl
= TREE_VALUE (parm
);
11061 const char *errmsg
;
11063 if (parm
== void_list_node
)
11066 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11069 type
= TREE_TYPE (decl
);
11070 if (VOID_TYPE_P (type
))
11072 if (same_type_p (type
, void_type_node
)
11073 && DECL_SELF_REFERENCE_P (type
)
11074 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
11075 /* this is a parmlist of `(void)', which is ok. */
11077 cxx_incomplete_type_error (decl
, type
);
11078 /* It's not a good idea to actually create parameters of
11079 type `void'; other parts of the compiler assume that a
11080 void type terminates the parameter list. */
11081 type
= error_mark_node
;
11082 TREE_TYPE (decl
) = error_mark_node
;
11085 if (type
!= error_mark_node
11086 && TYPE_FOR_JAVA (type
)
11087 && MAYBE_CLASS_TYPE_P (type
))
11089 error ("parameter %qD has Java class type", decl
);
11090 type
= error_mark_node
;
11091 TREE_TYPE (decl
) = error_mark_node
;
11095 if (type
!= error_mark_node
11096 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11099 type
= error_mark_node
;
11100 TREE_TYPE (decl
) = error_mark_node
;
11103 if (type
!= error_mark_node
)
11105 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11107 tree deptype
= type_is_deprecated (type
);
11109 warn_deprecated_use (deptype
, NULL_TREE
);
11112 /* Top-level qualifiers on the parameters are
11113 ignored for function types. */
11114 type
= cp_build_qualified_type (type
, 0);
11115 if (TREE_CODE (type
) == METHOD_TYPE
)
11117 error ("parameter %qD invalidly declared method type", decl
);
11118 type
= build_pointer_type (type
);
11119 TREE_TYPE (decl
) = type
;
11121 else if (abstract_virtuals_error (decl
, type
))
11122 any_error
= 1; /* Seems like a good idea. */
11123 else if (POINTER_TYPE_P (type
))
11125 /* [dcl.fct]/6, parameter types cannot contain pointers
11126 (references) to arrays of unknown bound. */
11127 tree t
= TREE_TYPE (type
);
11128 int ptr
= TYPE_PTR_P (type
);
11132 if (TYPE_PTR_P (t
))
11134 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11136 else if (!TYPE_DOMAIN (t
))
11140 if (TREE_CODE (t
) == ARRAY_TYPE
)
11142 ? G_("parameter %qD includes pointer to array of "
11143 "unknown bound %qT")
11144 : G_("parameter %qD includes reference to array of "
11145 "unknown bound %qT"),
11151 else if (init
&& !processing_template_decl
)
11152 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11155 DECL_CHAIN (decl
) = decls
;
11157 result
= tree_cons (init
, type
, result
);
11159 decls
= nreverse (decls
);
11160 result
= nreverse (result
);
11162 result
= chainon (result
, void_list_node
);
11169 /* D is a constructor or overloaded `operator='.
11171 Let T be the class in which D is declared. Then, this function
11174 -1 if D's is an ill-formed constructor or copy assignment operator
11175 whose first parameter is of type `T'.
11176 0 if D is not a copy constructor or copy assignment
11178 1 if D is a copy constructor or copy assignment operator whose
11179 first parameter is a reference to non-const qualified T.
11180 2 if D is a copy constructor or copy assignment operator whose
11181 first parameter is a reference to const qualified T.
11183 This function can be used as a predicate. Positive values indicate
11184 a copy constructor and nonzero values indicate a copy assignment
11188 copy_fn_p (const_tree d
)
11194 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11196 if (TREE_CODE (d
) == TEMPLATE_DECL
11197 || (DECL_TEMPLATE_INFO (d
)
11198 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11199 /* Instantiations of template member functions are never copy
11200 functions. Note that member functions of templated classes are
11201 represented as template functions internally, and we must
11202 accept those as copy functions. */
11205 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11209 arg_type
= TREE_VALUE (args
);
11210 if (arg_type
== error_mark_node
)
11213 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11215 /* Pass by value copy assignment operator. */
11218 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11219 && !TYPE_REF_IS_RVALUE (arg_type
)
11220 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11222 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11228 args
= TREE_CHAIN (args
);
11230 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11231 /* There are more non-optional args. */
11237 /* D is a constructor or overloaded `operator='.
11239 Let T be the class in which D is declared. Then, this function
11240 returns true when D is a move constructor or move assignment
11241 operator, false otherwise. */
11244 move_fn_p (const_tree d
)
11246 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11248 if (cxx_dialect
== cxx98
)
11249 /* There are no move constructors if we are in C++98 mode. */
11252 if (TREE_CODE (d
) == TEMPLATE_DECL
11253 || (DECL_TEMPLATE_INFO (d
)
11254 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11255 /* Instantiations of template member functions are never move
11256 functions. Note that member functions of templated classes are
11257 represented as template functions internally, and we must
11258 accept those as move functions. */
11261 return move_signature_fn_p (d
);
11264 /* D is a constructor or overloaded `operator='.
11266 Then, this function returns true when D has the same signature as a move
11267 constructor or move assignment operator (because either it is such a
11268 ctor/op= or it is a template specialization with the same signature),
11269 false otherwise. */
11272 move_signature_fn_p (const_tree d
)
11276 bool result
= false;
11278 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11282 arg_type
= TREE_VALUE (args
);
11283 if (arg_type
== error_mark_node
)
11286 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11287 && TYPE_REF_IS_RVALUE (arg_type
)
11288 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11292 args
= TREE_CHAIN (args
);
11294 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11295 /* There are more non-optional args. */
11301 /* Remember any special properties of member function DECL. */
11304 grok_special_member_properties (tree decl
)
11308 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11311 class_type
= DECL_CONTEXT (decl
);
11312 if (DECL_CONSTRUCTOR_P (decl
))
11314 int ctor
= copy_fn_p (decl
);
11316 if (!DECL_ARTIFICIAL (decl
))
11317 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11323 A non-template constructor for class X is a copy
11324 constructor if its first parameter is of type X&, const
11325 X&, volatile X& or const volatile X&, and either there
11326 are no other parameters or else all other parameters have
11327 default arguments. */
11328 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11329 if (user_provided_p (decl
))
11330 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11332 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11334 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11336 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11337 if (user_provided_p (decl
))
11338 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
11340 else if (move_fn_p (decl
) && user_provided_p (decl
))
11341 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11342 else if (is_list_ctor (decl
))
11343 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11345 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11346 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11347 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11349 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11353 A non-template assignment operator for class X is a copy
11354 assignment operator if its parameter is of type X, X&, const
11355 X&, volatile X& or const volatile X&. */
11357 int assop
= copy_fn_p (decl
);
11361 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11362 if (user_provided_p (decl
))
11363 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11365 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11367 else if (move_fn_p (decl
) && user_provided_p (decl
))
11368 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11370 /* Destructors are handled in check_methods. */
11373 /* Check a constructor DECL has the correct form. Complains
11374 if the class has a constructor of the form X(X). */
11377 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11379 int ctor_parm
= copy_fn_p (decl
);
11385 A declaration of a constructor for a class X is ill-formed if
11386 its first parameter is of type (optionally cv-qualified) X
11387 and either there are no other parameters or else all other
11388 parameters have default arguments.
11390 We *don't* complain about member template instantiations that
11391 have this form, though; they can occur as we try to decide
11392 what constructor to use during overload resolution. Since
11393 overload resolution will never prefer such a constructor to
11394 the non-template copy constructor (which is either explicitly
11395 or implicitly defined), there's no need to worry about their
11396 existence. Theoretically, they should never even be
11397 instantiated, but that's hard to forestall. */
11398 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11406 /* An operator with this code is unary, but can also be binary. */
11409 ambi_op_p (enum tree_code code
)
11411 return (code
== INDIRECT_REF
11412 || code
== ADDR_EXPR
11413 || code
== UNARY_PLUS_EXPR
11414 || code
== NEGATE_EXPR
11415 || code
== PREINCREMENT_EXPR
11416 || code
== PREDECREMENT_EXPR
);
11419 /* An operator with this name can only be unary. */
11422 unary_op_p (enum tree_code code
)
11424 return (code
== TRUTH_NOT_EXPR
11425 || code
== BIT_NOT_EXPR
11426 || code
== COMPONENT_REF
11427 || code
== TYPE_EXPR
);
11430 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11431 errors are issued for invalid declarations. */
11434 grok_op_properties (tree decl
, bool complain
)
11436 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11438 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11439 tree name
= DECL_NAME (decl
);
11440 enum tree_code operator_code
;
11445 /* Count the number of arguments and check for ellipsis. */
11446 for (argtype
= argtypes
, arity
= 0;
11447 argtype
&& argtype
!= void_list_node
;
11448 argtype
= TREE_CHAIN (argtype
))
11450 ellipsis_p
= !argtype
;
11452 class_type
= DECL_CONTEXT (decl
);
11453 if (class_type
&& !CLASS_TYPE_P (class_type
))
11454 class_type
= NULL_TREE
;
11456 if (DECL_CONV_FN_P (decl
))
11457 operator_code
= TYPE_EXPR
;
11461 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11462 if (ansi_opname (CODE) == name) \
11464 operator_code = (CODE); \
11467 else if (ansi_assopname (CODE) == name) \
11469 operator_code = (CODE); \
11470 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11474 #include "operators.def"
11475 #undef DEF_OPERATOR
11477 gcc_unreachable ();
11480 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11481 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11484 switch (operator_code
)
11487 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11491 TYPE_GETS_DELETE (class_type
) |= 1;
11495 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11498 case VEC_DELETE_EXPR
:
11499 TYPE_GETS_DELETE (class_type
) |= 2;
11506 /* [basic.std.dynamic.allocation]/1:
11508 A program is ill-formed if an allocation function is declared
11509 in a namespace scope other than global scope or declared static
11512 The same also holds true for deallocation functions. */
11513 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11514 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11516 if (DECL_NAMESPACE_SCOPE_P (decl
))
11518 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11520 error ("%qD may not be declared within a namespace", decl
);
11523 else if (!TREE_PUBLIC (decl
))
11525 error ("%qD may not be declared as static", decl
);
11531 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11533 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11534 DECL_IS_OPERATOR_NEW (decl
) = 1;
11536 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11537 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11540 /* An operator function must either be a non-static member function
11541 or have at least one parameter of a class, a reference to a class,
11542 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11543 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11545 if (operator_code
== TYPE_EXPR
11546 || operator_code
== CALL_EXPR
11547 || operator_code
== COMPONENT_REF
11548 || operator_code
== ARRAY_REF
11549 || operator_code
== NOP_EXPR
)
11551 error ("%qD must be a nonstatic member function", decl
);
11558 if (DECL_STATIC_FUNCTION_P (decl
))
11560 error ("%qD must be either a non-static member "
11561 "function or a non-member function", decl
);
11565 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11567 tree arg
= non_reference (TREE_VALUE (p
));
11568 if (arg
== error_mark_node
)
11571 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11572 because these checks are performed even on
11573 template functions. */
11574 if (MAYBE_CLASS_TYPE_P (arg
)
11575 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11579 if (!p
|| p
== void_list_node
)
11582 error ("%qD must have an argument of class or "
11583 "enumerated type", decl
);
11589 /* There are no restrictions on the arguments to an overloaded
11591 if (operator_code
== CALL_EXPR
)
11594 /* Warn about conversion operators that will never be used. */
11595 if (IDENTIFIER_TYPENAME_P (name
)
11596 && ! DECL_TEMPLATE_INFO (decl
)
11598 /* Warn only declaring the function; there is no need to
11599 warn again about out-of-class definitions. */
11600 && class_type
== current_class_type
)
11602 tree t
= TREE_TYPE (name
);
11603 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11606 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11608 if (VOID_TYPE_P (t
))
11609 warning (OPT_Wconversion
,
11611 ? G_("conversion to a reference to void "
11612 "will never use a type conversion operator")
11613 : G_("conversion to void "
11614 "will never use a type conversion operator"));
11615 else if (class_type
)
11617 if (t
== class_type
)
11618 warning (OPT_Wconversion
,
11620 ? G_("conversion to a reference to the same type "
11621 "will never use a type conversion operator")
11622 : G_("conversion to the same type "
11623 "will never use a type conversion operator"));
11624 /* Don't force t to be complete here. */
11625 else if (MAYBE_CLASS_TYPE_P (t
)
11626 && COMPLETE_TYPE_P (t
)
11627 && DERIVED_FROM_P (t
, class_type
))
11628 warning (OPT_Wconversion
,
11630 ? G_("conversion to a reference to a base class "
11631 "will never use a type conversion operator")
11632 : G_("conversion to a base class "
11633 "will never use a type conversion operator"));
11638 if (operator_code
== COND_EXPR
)
11641 error ("ISO C++ prohibits overloading operator ?:");
11644 else if (ellipsis_p
)
11646 error ("%qD must not have variable number of arguments", decl
);
11649 else if (ambi_op_p (operator_code
))
11652 /* We pick the one-argument operator codes by default, so
11653 we don't have to change anything. */
11655 else if (arity
== 2)
11657 /* If we thought this was a unary operator, we now know
11658 it to be a binary operator. */
11659 switch (operator_code
)
11662 operator_code
= MULT_EXPR
;
11666 operator_code
= BIT_AND_EXPR
;
11669 case UNARY_PLUS_EXPR
:
11670 operator_code
= PLUS_EXPR
;
11674 operator_code
= MINUS_EXPR
;
11677 case PREINCREMENT_EXPR
:
11678 operator_code
= POSTINCREMENT_EXPR
;
11681 case PREDECREMENT_EXPR
:
11682 operator_code
= POSTDECREMENT_EXPR
;
11686 gcc_unreachable ();
11689 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11691 if ((operator_code
== POSTINCREMENT_EXPR
11692 || operator_code
== POSTDECREMENT_EXPR
)
11693 && ! processing_template_decl
11694 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11697 error ("postfix %qD must take %<int%> as its argument",
11700 error ("postfix %qD must take %<int%> as its second "
11708 error ("%qD must take either zero or one argument", decl
);
11710 error ("%qD must take either one or two arguments", decl
);
11714 /* More Effective C++ rule 6. */
11716 && (operator_code
== POSTINCREMENT_EXPR
11717 || operator_code
== POSTDECREMENT_EXPR
11718 || operator_code
== PREINCREMENT_EXPR
11719 || operator_code
== PREDECREMENT_EXPR
))
11721 tree arg
= TREE_VALUE (argtypes
);
11722 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11723 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11724 arg
= TREE_TYPE (arg
);
11725 arg
= TYPE_MAIN_VARIANT (arg
);
11726 if (operator_code
== PREINCREMENT_EXPR
11727 || operator_code
== PREDECREMENT_EXPR
)
11729 if (TREE_CODE (ret
) != REFERENCE_TYPE
11730 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11732 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11733 build_reference_type (arg
));
11737 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11738 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11742 else if (unary_op_p (operator_code
))
11747 error ("%qD must take %<void%>", decl
);
11749 error ("%qD must take exactly one argument", decl
);
11753 else /* if (binary_op_p (operator_code)) */
11758 error ("%qD must take exactly one argument", decl
);
11760 error ("%qD must take exactly two arguments", decl
);
11764 /* More Effective C++ rule 7. */
11766 && (operator_code
== TRUTH_ANDIF_EXPR
11767 || operator_code
== TRUTH_ORIF_EXPR
11768 || operator_code
== COMPOUND_EXPR
))
11769 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11773 /* Effective C++ rule 23. */
11776 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11777 && (operator_code
== PLUS_EXPR
11778 || operator_code
== MINUS_EXPR
11779 || operator_code
== TRUNC_DIV_EXPR
11780 || operator_code
== MULT_EXPR
11781 || operator_code
== TRUNC_MOD_EXPR
)
11782 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11783 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11785 /* [over.oper]/8 */
11786 for (; argtypes
&& argtypes
!= void_list_node
;
11787 argtypes
= TREE_CHAIN (argtypes
))
11788 if (TREE_PURPOSE (argtypes
))
11790 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11791 if (operator_code
== POSTINCREMENT_EXPR
11792 || operator_code
== POSTDECREMENT_EXPR
)
11794 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
11799 error ("%qD cannot have default arguments", decl
);
11807 /* Return a string giving the keyword associate with CODE. */
11809 static const char *
11810 tag_name (enum tag_types code
)
11822 case typename_type
:
11825 gcc_unreachable ();
11829 /* Name lookup in an elaborated-type-specifier (after the keyword
11830 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11831 elaborated-type-specifier is invalid, issue a diagnostic and return
11832 error_mark_node; otherwise, return the *_TYPE to which it referred.
11833 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11836 check_elaborated_type_specifier (enum tag_types tag_code
,
11838 bool allow_template_p
)
11844 struct S { struct S *p; };
11846 name lookup will find the TYPE_DECL for the implicit "S::S"
11847 typedef. Adjust for that here. */
11848 if (DECL_SELF_REFERENCE_P (decl
))
11849 decl
= TYPE_NAME (TREE_TYPE (decl
));
11851 type
= TREE_TYPE (decl
);
11853 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11854 is false for this case as well. */
11855 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11857 error ("using template type parameter %qT after %qs",
11858 type
, tag_name (tag_code
));
11859 return error_mark_node
;
11861 /* Accept template template parameters. */
11862 else if (allow_template_p
11863 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
11864 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
11868 If the identifier resolves to a typedef-name or the
11869 simple-template-id resolves to an alias template
11870 specialization, the elaborated-type-specifier is ill-formed.
11872 In other words, the only legitimate declaration to use in the
11873 elaborated type specifier is the implicit typedef created when
11874 the type is declared. */
11875 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
11876 && !DECL_SELF_REFERENCE_P (decl
)
11877 && tag_code
!= typename_type
)
11879 if (alias_template_specialization_p (type
))
11880 error ("using alias template specialization %qT after %qs",
11881 type
, tag_name (tag_code
));
11883 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
11884 inform (DECL_SOURCE_LOCATION (decl
),
11885 "%qD has a previous declaration here", decl
);
11886 return error_mark_node
;
11888 else if (TREE_CODE (type
) != RECORD_TYPE
11889 && TREE_CODE (type
) != UNION_TYPE
11890 && tag_code
!= enum_type
11891 && tag_code
!= typename_type
)
11893 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
11894 inform (input_location
, "%q+T has a previous declaration here", type
);
11895 return error_mark_node
;
11897 else if (TREE_CODE (type
) != ENUMERAL_TYPE
11898 && tag_code
== enum_type
)
11900 error ("%qT referred to as enum", type
);
11901 inform (input_location
, "%q+T has a previous declaration here", type
);
11902 return error_mark_node
;
11904 else if (!allow_template_p
11905 && TREE_CODE (type
) == RECORD_TYPE
11906 && CLASSTYPE_IS_TEMPLATE (type
))
11908 /* If a class template appears as elaborated type specifier
11909 without a template header such as:
11911 template <class T> class C {};
11912 void f(class C); // No template header here
11914 then the required template argument is missing. */
11915 error ("template argument required for %<%s %T%>",
11916 tag_name (tag_code
),
11917 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
11918 return error_mark_node
;
11924 /* Lookup NAME in elaborate type specifier in scope according to
11925 SCOPE and issue diagnostics if necessary.
11926 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11927 found, and ERROR_MARK_NODE for type error. */
11930 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
11931 tag_scope scope
, bool template_header_p
)
11935 if (scope
== ts_global
)
11937 /* First try ordinary name lookup, ignoring hidden class name
11938 injected via friend declaration. */
11939 decl
= lookup_name_prefer_type (name
, 2);
11940 /* If that fails, the name will be placed in the smallest
11941 non-class, non-function-prototype scope according to 3.3.1/5.
11942 We may already have a hidden name declared as friend in this
11943 scope. So lookup again but not ignoring hidden names.
11944 If we find one, that name will be made visible rather than
11945 creating a new tag. */
11947 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
11950 decl
= lookup_type_scope (name
, scope
);
11953 && (DECL_CLASS_TEMPLATE_P (decl
)
11954 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl
)))
11955 decl
= DECL_TEMPLATE_RESULT (decl
);
11957 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
11959 /* Look for invalid nested type:
11963 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
11965 error ("%qD has the same name as the class in which it is "
11968 return error_mark_node
;
11971 /* Two cases we need to consider when deciding if a class
11972 template is allowed as an elaborated type specifier:
11973 1. It is a self reference to its own class.
11974 2. It comes with a template header.
11978 template <class T> class C {
11979 class C *c1; // DECL_SELF_REFERENCE_P is true
11982 template <class U> class C; // template_header_p is true
11983 template <class T> class C<T>::D {
11984 class C *c2; // DECL_SELF_REFERENCE_P is true
11987 t
= check_elaborated_type_specifier (tag_code
,
11990 | DECL_SELF_REFERENCE_P (decl
));
11993 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
11995 error ("reference to %qD is ambiguous", name
);
11996 print_candidates (decl
);
11997 return error_mark_node
;
12003 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12004 Define the tag as a forward-reference if it is not defined.
12006 If a declaration is given, process it here, and report an error if
12007 multiple declarations are not identical.
12009 SCOPE is TS_CURRENT when this is also a definition. Only look in
12010 the current frame for the name (since C++ allows new names in any
12011 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12012 declaration. Only look beginning from the current scope outward up
12013 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12015 TEMPLATE_HEADER_P is true when this declaration is preceded by
12016 a set of template parameters. */
12019 xref_tag_1 (enum tag_types tag_code
, tree name
,
12020 tag_scope orig_scope
, bool template_header_p
)
12022 enum tree_code code
;
12024 tree context
= NULL_TREE
;
12027 gcc_assert (identifier_p (name
));
12033 code
= RECORD_TYPE
;
12039 code
= ENUMERAL_TYPE
;
12042 gcc_unreachable ();
12045 if (orig_scope
== ts_lambda
)
12046 scope
= ts_current
;
12048 scope
= orig_scope
;
12050 /* In case of anonymous name, xref_tag is only called to
12051 make type node and push name. Name lookup is not required. */
12052 if (ANON_AGGRNAME_P (name
))
12055 t
= lookup_and_check_tag (tag_code
, name
,
12056 scope
, template_header_p
);
12058 if (t
== error_mark_node
)
12059 return error_mark_node
;
12061 if (scope
!= ts_current
&& t
&& current_class_type
12062 && template_class_depth (current_class_type
)
12063 && template_header_p
)
12065 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12068 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12069 definition of this tag. Since, in addition, we are currently
12070 processing a (member) template declaration of a template
12071 class, we must be very careful; consider:
12078 { template <class V>
12079 friend struct S1; };
12081 Here, the S2::S1 declaration should not be confused with the
12082 outer declaration. In particular, the inner version should
12083 have a template parameter of level 2, not level 1. This
12084 would be particularly important if the member declaration
12087 template <class V = U> friend struct S1;
12089 say, when we should tsubst into `U' when instantiating
12090 S2. On the other hand, when presented with:
12100 we must find the inner binding eventually. We
12101 accomplish this by making sure that the new type we
12102 create to represent this declaration has the right
12104 context
= TYPE_CONTEXT (t
);
12110 /* If no such tag is yet defined, create a forward-reference node
12111 and record it as the "definition".
12112 When a real declaration of this type is found,
12113 the forward-reference will be altered into a real type. */
12114 if (code
== ENUMERAL_TYPE
)
12116 error ("use of enum %q#D without previous declaration", name
);
12117 return error_mark_node
;
12121 t
= make_class_type (code
);
12122 TYPE_CONTEXT (t
) = context
;
12123 if (orig_scope
== ts_lambda
)
12124 /* Remember that we're declaring a lambda to avoid bogus errors
12125 in push_template_decl. */
12126 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12127 t
= pushtag (name
, t
, scope
);
12132 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12134 if (!redeclare_class_template (t
, current_template_parms
))
12135 return error_mark_node
;
12137 else if (!processing_template_decl
12138 && CLASS_TYPE_P (t
)
12139 && CLASSTYPE_IS_TEMPLATE (t
))
12141 error ("redeclaration of %qT as a non-template", t
);
12142 error ("previous declaration %q+D", t
);
12143 return error_mark_node
;
12146 /* Make injected friend class visible. */
12147 if (scope
!= ts_within_enclosing_non_class
12148 && hidden_name_p (TYPE_NAME (t
)))
12150 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12151 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12153 if (TYPE_TEMPLATE_INFO (t
))
12155 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12156 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12164 /* Wrapper for xref_tag_1. */
12167 xref_tag (enum tag_types tag_code
, tree name
,
12168 tag_scope scope
, bool template_header_p
)
12172 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12173 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12174 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12180 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12182 enum tag_types tag_kind
;
12184 if (TREE_CODE (old
) == RECORD_TYPE
)
12185 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12187 tag_kind
= union_type
;
12189 if (id
== NULL_TREE
)
12190 id
= TYPE_IDENTIFIER (old
);
12192 return xref_tag (tag_kind
, id
, scope
, false);
12195 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12196 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12197 access_* node, and the TREE_VALUE is the type of the base-class.
12198 Non-NULL TREE_TYPE indicates virtual inheritance.
12200 Returns true if the binfo hierarchy was successfully created,
12201 false if an error was detected. */
12204 xref_basetypes (tree ref
, tree base_list
)
12207 tree binfo
, base_binfo
;
12208 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12209 unsigned max_bases
= 0; /* Maximum direct bases. */
12211 tree default_access
;
12212 tree igo_prev
; /* Track Inheritance Graph Order. */
12214 if (ref
== error_mark_node
)
12217 /* The base of a derived class is private by default, all others are
12219 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12220 && CLASSTYPE_DECLARED_CLASS (ref
)
12221 ? access_private_node
: access_public_node
);
12223 /* First, make sure that any templates in base-classes are
12224 instantiated. This ensures that if we call ourselves recursively
12225 we do not get confused about which classes are marked and which
12227 basep
= &base_list
;
12230 tree basetype
= TREE_VALUE (*basep
);
12232 /* The dependent_type_p call below should really be dependent_scope_p
12233 so that we give a hard error about using an incomplete type as a
12234 base, but we allow it with a pedwarn for backward
12236 if (processing_template_decl
12237 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12238 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12239 if (!dependent_type_p (basetype
)
12240 && !complete_type_or_else (basetype
, NULL
))
12241 /* An incomplete type. Remove it from the list. */
12242 *basep
= TREE_CHAIN (*basep
);
12246 if (TREE_TYPE (*basep
))
12248 if (CLASS_TYPE_P (basetype
))
12249 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12250 basep
= &TREE_CHAIN (*basep
);
12254 TYPE_MARKED_P (ref
) = 1;
12256 /* The binfo slot should be empty, unless this is an (ill-formed)
12258 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12260 error ("redefinition of %q#T", ref
);
12264 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12266 binfo
= make_tree_binfo (max_bases
);
12268 TYPE_BINFO (ref
) = binfo
;
12269 BINFO_OFFSET (binfo
) = size_zero_node
;
12270 BINFO_TYPE (binfo
) = ref
;
12272 /* Apply base-class info set up to the variants of this type. */
12273 fixup_type_variants (ref
);
12277 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12278 /* An aggregate cannot have baseclasses. */
12279 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12281 if (TREE_CODE (ref
) == UNION_TYPE
)
12283 error ("derived union %qT invalid", ref
);
12290 if (TYPE_FOR_JAVA (ref
))
12292 error ("Java class %qT cannot have multiple bases", ref
);
12299 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12301 if (TYPE_FOR_JAVA (ref
))
12303 error ("Java class %qT cannot have virtual bases", ref
);
12308 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12310 tree access
= TREE_PURPOSE (base_list
);
12311 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12312 tree basetype
= TREE_VALUE (base_list
);
12314 if (access
== access_default_node
)
12315 access
= default_access
;
12317 if (PACK_EXPANSION_P (basetype
))
12318 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12319 if (TREE_CODE (basetype
) == TYPE_DECL
)
12320 basetype
= TREE_TYPE (basetype
);
12321 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12323 error ("base type %qT fails to be a struct or class type",
12328 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12329 TYPE_FOR_JAVA (ref
) = 1;
12331 base_binfo
= NULL_TREE
;
12332 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12334 base_binfo
= TYPE_BINFO (basetype
);
12335 /* The original basetype could have been a typedef'd type. */
12336 basetype
= BINFO_TYPE (base_binfo
);
12338 /* Inherit flags from the base. */
12339 TYPE_HAS_NEW_OPERATOR (ref
)
12340 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12341 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12342 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12343 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12344 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12345 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12346 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12347 CLASSTYPE_REPEATED_BASE_P (ref
)
12348 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12351 /* We must do this test after we've seen through a typedef
12353 if (TYPE_MARKED_P (basetype
))
12355 if (basetype
== ref
)
12356 error ("recursive type %qT undefined", basetype
);
12358 error ("duplicate base type %qT invalid", basetype
);
12362 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12363 /* Regenerate the pack expansion for the bases. */
12364 basetype
= make_pack_expansion (basetype
);
12366 TYPE_MARKED_P (basetype
) = 1;
12368 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12369 &igo_prev
, via_virtual
);
12370 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12371 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12373 BINFO_BASE_APPEND (binfo
, base_binfo
);
12374 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12377 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12378 /* If we didn't get max_vbases vbases, we must have shared at
12379 least one of them, and are therefore diamond shaped. */
12380 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12382 /* Unmark all the types. */
12383 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12384 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12385 TYPE_MARKED_P (ref
) = 0;
12387 /* Now see if we have a repeated base type. */
12388 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12390 for (base_binfo
= binfo
; base_binfo
;
12391 base_binfo
= TREE_CHAIN (base_binfo
))
12393 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12395 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12398 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12400 for (base_binfo
= binfo
; base_binfo
;
12401 base_binfo
= TREE_CHAIN (base_binfo
))
12402 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12403 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12412 /* Copies the enum-related properties from type SRC to type DST.
12413 Used with the underlying type of an enum and the enum itself. */
12415 copy_type_enum (tree dst
, tree src
)
12418 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12420 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12421 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12422 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12423 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12424 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12425 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12426 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12427 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12428 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12432 /* Begin compiling the definition of an enumeration type.
12435 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12437 UNDERLYING_TYPE is the type that will be used as the storage for
12438 the enumeration type. This should be NULL_TREE if no storage type
12441 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12443 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12445 Returns the type object, as yet incomplete.
12446 Also records info about it so that build_enumerator
12447 may be used to declare the individual values as they are read. */
12450 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12451 bool scoped_enum_p
, bool *is_new
)
12453 tree prevtype
= NULL_TREE
;
12454 gcc_assert (identifier_p (name
));
12458 /* [C++0x dcl.enum]p5:
12460 If not explicitly specified, the underlying type of a scoped
12461 enumeration type is int. */
12462 if (!underlying_type
&& scoped_enum_p
)
12463 underlying_type
= integer_type_node
;
12465 if (underlying_type
)
12466 underlying_type
= cv_unqualified (underlying_type
);
12468 /* If this is the real definition for a previous forward reference,
12469 fill in the contents in the same object that used to be the
12470 forward reference. */
12472 enumtype
= lookup_and_check_tag (enum_type
, name
,
12473 /*tag_scope=*/ts_current
,
12474 /*template_header_p=*/false);
12476 /* In case of a template_decl, the only check that should be deferred
12477 to instantiation time is the comparison of underlying types. */
12478 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12480 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12482 error_at (input_location
, "scoped/unscoped mismatch "
12483 "in enum %q#T", enumtype
);
12484 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12485 "previous definition here");
12486 enumtype
= error_mark_node
;
12488 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12490 error_at (input_location
, "underlying type mismatch "
12491 "in enum %q#T", enumtype
);
12492 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12493 "previous definition here");
12494 enumtype
= error_mark_node
;
12496 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12497 && !dependent_type_p (underlying_type
)
12498 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12499 && !same_type_p (underlying_type
,
12500 ENUM_UNDERLYING_TYPE (enumtype
)))
12502 error_at (input_location
, "different underlying type "
12503 "in enum %q#T", enumtype
);
12504 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12505 "previous definition here");
12506 underlying_type
= NULL_TREE
;
12510 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12511 || processing_template_decl
)
12513 /* In case of error, make a dummy enum to allow parsing to
12515 if (enumtype
== error_mark_node
)
12517 name
= make_anon_name ();
12518 enumtype
= NULL_TREE
;
12521 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12522 of an opaque enum, or an opaque enum of an already defined
12523 enumeration (C++0x only).
12524 In any other case, it'll be NULL_TREE. */
12530 prevtype
= enumtype
;
12532 /* Do not push the decl more than once, unless we need to
12533 compare underlying types at instantiation time */
12535 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12536 || (underlying_type
12537 && dependent_type_p (underlying_type
))
12538 || (ENUM_UNDERLYING_TYPE (enumtype
)
12539 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12541 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12542 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12545 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12548 if (enumtype
== error_mark_node
)
12549 return error_mark_node
;
12551 /* The enum is considered opaque until the opening '{' of the
12552 enumerator list. */
12553 SET_OPAQUE_ENUM_P (enumtype
, true);
12554 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12557 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12559 if (underlying_type
)
12561 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12563 copy_type_enum (enumtype
, underlying_type
);
12564 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12566 else if (dependent_type_p (underlying_type
))
12567 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12569 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12570 underlying_type
, enumtype
);
12573 /* If into a template class, the returned enum is always the first
12574 declaration (opaque or not) seen. This way all the references to
12575 this type will be to the same declaration. The following ones are used
12576 only to check for definition errors. */
12577 if (prevtype
&& processing_template_decl
)
12583 /* After processing and defining all the values of an enumeration type,
12584 install their decls in the enumeration type.
12585 ENUMTYPE is the type object. */
12588 finish_enum_value_list (tree enumtype
)
12591 tree underlying_type
;
12594 tree minnode
, maxnode
;
12597 bool fixed_underlying_type_p
12598 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12600 /* We built up the VALUES in reverse order. */
12601 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12603 /* For an enum defined in a template, just set the type of the values;
12604 all further processing is postponed until the template is
12605 instantiated. We need to set the type so that tsubst of a CONST_DECL
12607 if (processing_template_decl
)
12609 for (values
= TYPE_VALUES (enumtype
);
12611 values
= TREE_CHAIN (values
))
12612 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12616 /* Determine the minimum and maximum values of the enumerators. */
12617 if (TYPE_VALUES (enumtype
))
12619 minnode
= maxnode
= NULL_TREE
;
12621 for (values
= TYPE_VALUES (enumtype
);
12623 values
= TREE_CHAIN (values
))
12625 decl
= TREE_VALUE (values
);
12627 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12628 each enumerator has the type of its enumeration. Prior to the
12629 closing brace, the type of each enumerator is the type of its
12630 initializing value. */
12631 TREE_TYPE (decl
) = enumtype
;
12633 /* Update the minimum and maximum values, if appropriate. */
12634 value
= DECL_INITIAL (decl
);
12635 if (value
== error_mark_node
)
12636 value
= integer_zero_node
;
12637 /* Figure out what the minimum and maximum values of the
12638 enumerators are. */
12640 minnode
= maxnode
= value
;
12641 else if (tree_int_cst_lt (maxnode
, value
))
12643 else if (tree_int_cst_lt (value
, minnode
))
12650 If the enumerator-list is empty, the underlying type is as if
12651 the enumeration had a single enumerator with value 0. */
12652 minnode
= maxnode
= integer_zero_node
;
12654 if (!fixed_underlying_type_p
)
12656 /* Compute the number of bits require to represent all values of the
12657 enumeration. We must do this before the type of MINNODE and
12658 MAXNODE are transformed, since tree_int_cst_min_precision relies
12659 on the TREE_TYPE of the value it is passed. */
12660 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
12661 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
12662 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
12663 int precision
= MAX (lowprec
, highprec
);
12665 bool use_short_enum
;
12667 /* Determine the underlying type of the enumeration.
12671 The underlying type of an enumeration is an integral type that
12672 can represent all the enumerator values defined in the
12673 enumeration. It is implementation-defined which integral type is
12674 used as the underlying type for an enumeration except that the
12675 underlying type shall not be larger than int unless the value of
12676 an enumerator cannot fit in an int or unsigned int.
12678 We use "int" or an "unsigned int" as the underlying type, even if
12679 a smaller integral type would work, unless the user has
12680 explicitly requested that we use the smallest possible type. The
12681 user can request that for all enumerations with a command line
12682 flag, or for just one enumeration with an attribute. */
12684 use_short_enum
= flag_short_enums
12685 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12687 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12691 underlying_type
= integer_types
[itk
];
12692 if (underlying_type
!= NULL_TREE
12693 && TYPE_PRECISION (underlying_type
) >= precision
12694 && TYPE_SIGN (underlying_type
) == sgn
)
12697 if (itk
== itk_none
)
12701 IF no integral type can represent all the enumerator values, the
12702 enumeration is ill-formed. */
12703 error ("no integral type can represent all of the enumerator values "
12704 "for %qT", enumtype
);
12705 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12706 underlying_type
= integer_types
[itk_unsigned_long_long
];
12711 The value of sizeof() applied to an enumeration type, an object
12712 of an enumeration type, or an enumerator, is the value of sizeof()
12713 applied to the underlying type. */
12714 copy_type_enum (enumtype
, underlying_type
);
12716 /* Compute the minimum and maximum values for the type.
12720 For an enumeration where emin is the smallest enumerator and emax
12721 is the largest, the values of the enumeration are the values of the
12722 underlying type in the range bmin to bmax, where bmin and bmax are,
12723 respectively, the smallest and largest values of the smallest bit-
12724 field that can store emin and emax. */
12726 /* The middle-end currently assumes that types with TYPE_PRECISION
12727 narrower than their underlying type are suitably zero or sign
12728 extended to fill their mode. Similarly, it assumes that the front
12729 end assures that a value of a particular type must be within
12730 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12732 We used to set these fields based on bmin and bmax, but that led
12733 to invalid assumptions like optimizing away bounds checking. So
12734 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12735 TYPE_MAX_VALUE to the values for the mode above and only restrict
12736 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12737 ENUM_UNDERLYING_TYPE (enumtype
)
12738 = build_distinct_type_copy (underlying_type
);
12739 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12740 set_min_and_max_values_for_integral_type
12741 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
12743 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12744 if (flag_strict_enums
)
12745 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
12748 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12750 /* Convert each of the enumerators to the type of the underlying
12751 type of the enumeration. */
12752 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12754 location_t saved_location
;
12756 decl
= TREE_VALUE (values
);
12757 saved_location
= input_location
;
12758 input_location
= DECL_SOURCE_LOCATION (decl
);
12759 if (fixed_underlying_type_p
)
12760 /* If the enumeration type has a fixed underlying type, we
12761 already checked all of the enumerator values. */
12762 value
= DECL_INITIAL (decl
);
12764 value
= perform_implicit_conversion (underlying_type
,
12765 DECL_INITIAL (decl
),
12766 tf_warning_or_error
);
12767 input_location
= saved_location
;
12769 /* Do not clobber shared ints. */
12770 value
= copy_node (value
);
12772 TREE_TYPE (value
) = enumtype
;
12773 DECL_INITIAL (decl
) = value
;
12776 /* Fix up all variant types of this enum type. */
12777 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12778 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12780 if (at_class_scope_p ()
12781 && COMPLETE_TYPE_P (current_class_type
)
12782 && UNSCOPED_ENUM_P (enumtype
))
12783 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
12784 current_class_type
);
12786 /* Finish debugging output for this type. */
12787 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12790 /* Finishes the enum type. This is called only the first time an
12791 enumeration is seen, be it opaque or odinary.
12792 ENUMTYPE is the type object. */
12795 finish_enum (tree enumtype
)
12797 if (processing_template_decl
)
12799 if (at_function_scope_p ())
12800 add_stmt (build_min (TAG_DEFN
, enumtype
));
12804 /* If this is a forward declaration, there should not be any variants,
12805 though we can get a variant in the middle of an enum-specifier with
12806 wacky code like 'enum E { e = sizeof(const E*) };' */
12807 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
12808 && (TYPE_VALUES (enumtype
)
12809 || !TYPE_NEXT_VARIANT (enumtype
)));
12812 /* Build and install a CONST_DECL for an enumeration constant of the
12813 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12814 LOC is the location of NAME.
12815 Assignment of sequential values by default is handled here. */
12818 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
12824 /* If the VALUE was erroneous, pretend it wasn't there; that will
12825 result in the enum being assigned the next value in sequence. */
12826 if (value
== error_mark_node
)
12829 /* Remove no-op casts from the value. */
12831 STRIP_TYPE_NOPS (value
);
12833 if (! processing_template_decl
)
12835 /* Validate and default VALUE. */
12836 if (value
!= NULL_TREE
)
12838 value
= cxx_constant_value (value
);
12840 if (TREE_CODE (value
) != INTEGER_CST
12841 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
12843 error ("enumerator value for %qD is not an integer constant",
12849 /* Default based on previous value. */
12850 if (value
== NULL_TREE
)
12852 if (TYPE_VALUES (enumtype
))
12857 /* C++03 7.2/4: If no initializer is specified for the first
12858 enumerator, the type is an unspecified integral
12859 type. Otherwise the type is the same as the type of the
12860 initializing value of the preceding enumerator unless the
12861 incremented value is not representable in that type, in
12862 which case the type is an unspecified integral type
12863 sufficient to contain the incremented value. */
12864 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12865 if (error_operand_p (prev_value
))
12866 value
= error_mark_node
;
12869 tree type
= TREE_TYPE (prev_value
);
12870 signop sgn
= TYPE_SIGN (type
);
12871 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
12875 bool pos
= !wi::neg_p (wi
, sgn
);
12876 if (!wi::fits_to_tree_p (wi
, type
))
12879 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
12881 type
= integer_types
[itk
];
12882 if (type
!= NULL_TREE
12883 && (pos
|| !TYPE_UNSIGNED (type
))
12884 && wi::fits_to_tree_p (wi
, type
))
12887 if (type
&& cxx_dialect
< cxx11
12888 && itk
> itk_unsigned_long
)
12889 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
12890 incremented enumerator value is too large for %<unsigned long%>" : "\
12891 incremented enumerator value is too large for %<long%>");
12893 if (type
== NULL_TREE
)
12896 value
= wide_int_to_tree (type
, wi
);
12901 error ("overflow in enumeration values at %qD", name
);
12902 value
= error_mark_node
;
12907 value
= integer_zero_node
;
12910 /* Remove no-op casts from the value. */
12911 STRIP_TYPE_NOPS (value
);
12913 /* If the underlying type of the enum is fixed, check whether
12914 the enumerator values fits in the underlying type. If it
12915 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12916 if (ENUM_UNDERLYING_TYPE (enumtype
)
12918 && TREE_CODE (value
) == INTEGER_CST
)
12920 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
12921 error ("enumerator value %E is outside the range of underlying "
12922 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
12924 /* Convert the value to the appropriate type. */
12925 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
12929 /* C++ associates enums with global, function, or class declarations. */
12930 context
= current_scope ();
12932 /* Build the actual enumeration constant. Note that the enumeration
12933 constants have the underlying type of the enum (if it is fixed)
12934 or the type of their initializer (if the underlying type of the
12935 enum is not fixed):
12939 If the underlying type is fixed, the type of each enumerator
12940 prior to the closing brace is the underlying type; if the
12941 initializing value of an enumerator cannot be represented by
12942 the underlying type, the program is ill-formed. If the
12943 underlying type is not fixed, the type of each enumerator is
12944 the type of its initializing value.
12946 If the underlying type is not fixed, it will be computed by
12947 finish_enum and we will reset the type of this enumerator. Of
12948 course, if we're processing a template, there may be no value. */
12949 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12951 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
12953 DECL_CONTEXT (decl
) = enumtype
;
12954 TREE_CONSTANT (decl
) = 1;
12955 TREE_READONLY (decl
) = 1;
12956 DECL_INITIAL (decl
) = value
;
12958 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
12959 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12960 on the TYPE_FIELDS list for `S'. (That's so that you can say
12961 things like `S::i' later.) */
12962 finish_member_declaration (decl
);
12966 /* Add this enumeration constant to the list for this type. */
12967 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12970 /* Look for an enumerator with the given NAME within the enumeration
12971 type ENUMTYPE. This routine is used primarily for qualified name
12972 lookup into an enumerator in C++0x, e.g.,
12974 enum class Color { Red, Green, Blue };
12976 Color color = Color::Red;
12978 Returns the value corresponding to the enumerator, or
12979 NULL_TREE if no such enumerator was found. */
12981 lookup_enumerator (tree enumtype
, tree name
)
12984 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
12986 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
12987 return e
? TREE_VALUE (e
) : NULL_TREE
;
12991 /* We're defining DECL. Make sure that its type is OK. */
12994 check_function_type (tree decl
, tree current_function_parms
)
12996 tree fntype
= TREE_TYPE (decl
);
12997 tree return_type
= complete_type (TREE_TYPE (fntype
));
12999 /* In a function definition, arg types must be complete. */
13000 require_complete_types_for_parms (current_function_parms
);
13002 if (dependent_type_p (return_type
)
13003 || type_uses_auto (return_type
))
13005 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13006 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13008 tree args
= TYPE_ARG_TYPES (fntype
);
13010 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13011 error ("return type %q#T is incomplete", return_type
);
13013 error ("return type has Java class type %q#T", return_type
);
13015 /* Make it return void instead. */
13016 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13017 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13019 TREE_CHAIN (args
));
13021 fntype
= build_function_type (void_type_node
, args
);
13023 = build_exception_variant (fntype
,
13024 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13025 fntype
= (cp_build_type_attribute_variant
13026 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13027 TREE_TYPE (decl
) = fntype
;
13030 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13033 /* Create the FUNCTION_DECL for a function definition.
13034 DECLSPECS and DECLARATOR are the parts of the declaration;
13035 they describe the function's name and the type it returns,
13036 but twisted together in a fashion that parallels the syntax of C.
13038 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13039 DECLARATOR is really the DECL for the function we are about to
13040 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13041 indicating that the function is an inline defined in-class.
13043 This function creates a binding context for the function body
13044 as well as setting up the FUNCTION_DECL in current_function_decl.
13046 For C++, we must first check whether that datum makes any sense.
13047 For example, "class A local_a(1,2);" means that variable local_a
13048 is an aggregate of type A, which should have a constructor
13049 applied to it with the argument list [1, 2].
13051 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13052 or may be a BLOCK if the function has been defined previously
13053 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13054 error_mark_node if the function has never been defined, or
13055 a BLOCK if the function has been defined somewhere. */
13058 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13060 tree ctype
= NULL_TREE
;
13063 int doing_friend
= 0;
13064 cp_binding_level
*bl
;
13065 tree current_function_parms
;
13066 struct c_fileinfo
*finfo
13067 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13068 bool honor_interface
;
13070 /* Sanity check. */
13071 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13072 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13074 fntype
= TREE_TYPE (decl1
);
13075 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13076 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13078 /* ISO C++ 11.4/5. A friend function defined in a class is in
13079 the (lexical) scope of the class in which it is defined. */
13080 if (!ctype
&& DECL_FRIEND_P (decl1
))
13082 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13084 /* CTYPE could be null here if we're dealing with a template;
13085 for example, `inline friend float foo()' inside a template
13086 will have no CTYPE set. */
13087 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13093 if (DECL_DECLARED_INLINE_P (decl1
)
13094 && lookup_attribute ("noinline", attrs
))
13095 warning (0, "inline function %q+D given attribute noinline", decl1
);
13097 /* Handle gnu_inline attribute. */
13098 if (GNU_INLINE_P (decl1
))
13100 DECL_EXTERNAL (decl1
) = 1;
13101 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13102 DECL_INTERFACE_KNOWN (decl1
) = 1;
13103 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13106 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13107 /* This is a constructor, we must ensure that any default args
13108 introduced by this definition are propagated to the clones
13109 now. The clones are used directly in overload resolution. */
13110 adjust_clone_args (decl1
);
13112 /* Sometimes we don't notice that a function is a static member, and
13113 build a METHOD_TYPE for it. Fix that up now. */
13114 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13115 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13117 /* Set up current_class_type, and enter the scope of the class, if
13120 push_nested_class (ctype
);
13121 else if (DECL_STATIC_FUNCTION_P (decl1
))
13122 push_nested_class (DECL_CONTEXT (decl1
));
13124 /* Now that we have entered the scope of the class, we must restore
13125 the bindings for any template parameters surrounding DECL1, if it
13126 is an inline member template. (Order is important; consider the
13127 case where a template parameter has the same name as a field of
13128 the class.) It is not until after this point that
13129 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13130 if (flags
& SF_INCLASS_INLINE
)
13131 maybe_begin_member_template_processing (decl1
);
13133 /* Effective C++ rule 15. */
13135 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13136 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13137 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13139 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13140 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13141 if (!DECL_INITIAL (decl1
))
13142 DECL_INITIAL (decl1
) = error_mark_node
;
13144 /* This function exists in static storage.
13145 (This does not mean `static' in the C sense!) */
13146 TREE_STATIC (decl1
) = 1;
13148 /* We must call push_template_decl after current_class_type is set
13149 up. (If we are processing inline definitions after exiting a
13150 class scope, current_class_type will be NULL_TREE until set above
13151 by push_nested_class.) */
13152 if (processing_template_decl
)
13154 tree newdecl1
= push_template_decl (decl1
);
13155 if (newdecl1
== error_mark_node
)
13157 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13158 pop_nested_class ();
13164 /* We are now in the scope of the function being defined. */
13165 current_function_decl
= decl1
;
13167 /* Save the parm names or decls from this function's declarator
13168 where store_parm_decls will find them. */
13169 current_function_parms
= DECL_ARGUMENTS (decl1
);
13171 /* Make sure the parameter and return types are reasonable. When
13172 you declare a function, these types can be incomplete, but they
13173 must be complete when you define the function. */
13174 check_function_type (decl1
, current_function_parms
);
13176 /* Build the return declaration for the function. */
13177 restype
= TREE_TYPE (fntype
);
13179 if (DECL_RESULT (decl1
) == NULL_TREE
)
13183 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13184 DECL_ARTIFICIAL (resdecl
) = 1;
13185 DECL_IGNORED_P (resdecl
) = 1;
13186 DECL_RESULT (decl1
) = resdecl
;
13188 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13191 /* Let the user know we're compiling this function. */
13192 announce_function (decl1
);
13194 /* Record the decl so that the function name is defined.
13195 If we already have a decl for this name, and it is a FUNCTION_DECL,
13196 use the old decl. */
13197 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13199 /* A specialization is not used to guide overload resolution. */
13200 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13201 && !(DECL_USE_TEMPLATE (decl1
) &&
13202 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13204 tree olddecl
= pushdecl (decl1
);
13206 if (olddecl
== error_mark_node
)
13207 /* If something went wrong when registering the declaration,
13208 use DECL1; we have to have a FUNCTION_DECL to use when
13209 parsing the body of the function. */
13213 /* Otherwise, OLDDECL is either a previous declaration
13214 of the same function or DECL1 itself. */
13216 if (warn_missing_declarations
13217 && olddecl
== decl1
13218 && !DECL_MAIN_P (decl1
)
13219 && TREE_PUBLIC (decl1
)
13220 && !DECL_DECLARED_INLINE_P (decl1
))
13224 /* Check whether DECL1 is in an anonymous
13226 for (context
= DECL_CONTEXT (decl1
);
13228 context
= DECL_CONTEXT (context
))
13230 if (TREE_CODE (context
) == NAMESPACE_DECL
13231 && DECL_NAME (context
) == NULL_TREE
)
13235 if (context
== NULL
)
13236 warning (OPT_Wmissing_declarations
,
13237 "no previous declaration for %q+D", decl1
);
13245 /* We need to set the DECL_CONTEXT. */
13246 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13247 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13249 fntype
= TREE_TYPE (decl1
);
13250 restype
= TREE_TYPE (fntype
);
13252 /* If #pragma weak applies, mark the decl appropriately now.
13253 The pragma only applies to global functions. Because
13254 determining whether or not the #pragma applies involves
13255 computing the mangled name for the declaration, we cannot
13256 apply the pragma until after we have merged this declaration
13257 with any previous declarations; if the original declaration
13258 has a linkage specification, that specification applies to
13259 the definition as well, and may affect the mangled name. */
13260 if (DECL_FILE_SCOPE_P (decl1
))
13261 maybe_apply_pragma_weak (decl1
);
13264 /* Reset this in case the call to pushdecl changed it. */
13265 current_function_decl
= decl1
;
13267 gcc_assert (DECL_INITIAL (decl1
));
13269 /* This function may already have been parsed, in which case just
13270 return; our caller will skip over the body without parsing. */
13271 if (DECL_INITIAL (decl1
) != error_mark_node
)
13274 /* Initialize RTL machinery. We cannot do this until
13275 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13276 even when processing a template; this is how we get
13277 CFUN set up, and our per-function variables initialized.
13278 FIXME factor out the non-RTL stuff. */
13279 bl
= current_binding_level
;
13280 allocate_struct_function (decl1
, processing_template_decl
);
13282 /* Initialize the language data structures. Whenever we start
13283 a new function, we destroy temporaries in the usual way. */
13284 cfun
->language
= ggc_alloc_cleared_language_function ();
13285 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13286 current_binding_level
= bl
;
13288 if (!processing_template_decl
&& type_uses_auto (restype
))
13290 FNDECL_USED_AUTO (decl1
) = true;
13291 current_function_auto_return_pattern
= restype
;
13294 /* Start the statement-tree, start the tree now. */
13295 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13297 /* If we are (erroneously) defining a function that we have already
13298 defined before, wipe out what we knew before. */
13299 if (!DECL_PENDING_INLINE_P (decl1
))
13300 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13302 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13304 /* We know that this was set up by `grokclassfn'. We do not
13305 wait until `store_parm_decls', since evil parse errors may
13306 never get us to that point. Here we keep the consistency
13307 between `current_class_type' and `current_class_ptr'. */
13308 tree t
= DECL_ARGUMENTS (decl1
);
13310 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13311 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13313 cp_function_chain
->x_current_class_ref
13314 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13315 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13316 cp_function_chain
->x_current_class_ptr
= t
;
13318 /* Constructors and destructors need to know whether they're "in
13319 charge" of initializing virtual base classes. */
13320 t
= DECL_CHAIN (t
);
13321 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13323 current_in_charge_parm
= t
;
13324 t
= DECL_CHAIN (t
);
13326 if (DECL_HAS_VTT_PARM_P (decl1
))
13328 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13329 current_vtt_parm
= t
;
13333 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13334 /* Implicitly-defined methods (like the
13335 destructor for a class in which no destructor
13336 is explicitly declared) must not be defined
13337 until their definition is needed. So, we
13338 ignore interface specifications for
13339 compiler-generated functions. */
13340 && !DECL_ARTIFICIAL (decl1
));
13342 if (processing_template_decl
)
13343 /* Don't mess with interface flags. */;
13344 else if (DECL_INTERFACE_KNOWN (decl1
))
13346 tree ctx
= decl_function_context (decl1
);
13348 if (DECL_NOT_REALLY_EXTERN (decl1
))
13349 DECL_EXTERNAL (decl1
) = 0;
13351 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13352 /* This is a function in a local class in an extern inline
13353 or template function. */
13354 comdat_linkage (decl1
);
13356 /* If this function belongs to an interface, it is public.
13357 If it belongs to someone else's interface, it is also external.
13358 This only affects inlines and template instantiations. */
13359 else if (!finfo
->interface_unknown
&& honor_interface
)
13361 if (DECL_DECLARED_INLINE_P (decl1
)
13362 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13364 DECL_EXTERNAL (decl1
)
13365 = (finfo
->interface_only
13366 || (DECL_DECLARED_INLINE_P (decl1
)
13367 && ! flag_implement_inlines
13368 && !DECL_VINDEX (decl1
)));
13370 /* For WIN32 we also want to put these in linkonce sections. */
13371 maybe_make_one_only (decl1
);
13374 DECL_EXTERNAL (decl1
) = 0;
13375 DECL_INTERFACE_KNOWN (decl1
) = 1;
13376 /* If this function is in an interface implemented in this file,
13377 make sure that the back end knows to emit this function
13379 if (!DECL_EXTERNAL (decl1
))
13380 mark_needed (decl1
);
13382 else if (finfo
->interface_unknown
&& finfo
->interface_only
13383 && honor_interface
)
13385 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13386 interface, we will have both finfo->interface_unknown and
13387 finfo->interface_only set. In that case, we don't want to
13388 use the normal heuristics because someone will supply a
13389 #pragma implementation elsewhere, and deducing it here would
13390 produce a conflict. */
13391 comdat_linkage (decl1
);
13392 DECL_EXTERNAL (decl1
) = 0;
13393 DECL_INTERFACE_KNOWN (decl1
) = 1;
13394 DECL_DEFER_OUTPUT (decl1
) = 1;
13398 /* This is a definition, not a reference.
13399 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13400 if (!GNU_INLINE_P (decl1
))
13401 DECL_EXTERNAL (decl1
) = 0;
13403 if ((DECL_DECLARED_INLINE_P (decl1
)
13404 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13405 && ! DECL_INTERFACE_KNOWN (decl1
))
13406 DECL_DEFER_OUTPUT (decl1
) = 1;
13408 DECL_INTERFACE_KNOWN (decl1
) = 1;
13411 /* Determine the ELF visibility attribute for the function. We must not
13412 do this before calling "pushdecl", as we must allow "duplicate_decls"
13413 to merge any attributes appropriately. We also need to wait until
13415 if (!DECL_CLONED_FUNCTION_P (decl1
))
13416 determine_visibility (decl1
);
13418 begin_scope (sk_function_parms
, decl1
);
13422 if (DECL_DESTRUCTOR_P (decl1
)
13423 || (DECL_CONSTRUCTOR_P (decl1
)
13424 && targetm
.cxx
.cdtor_returns_this ()))
13426 cdtor_label
= build_decl (input_location
,
13427 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13428 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13431 start_fname_decls ();
13433 store_parm_decls (current_function_parms
);
13439 /* Like start_preparsed_function, except that instead of a
13440 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13442 Returns true on success. If the DECLARATOR is not suitable
13443 for a function, we return false, which tells the parser to
13444 skip the entire function. */
13447 start_function (cp_decl_specifier_seq
*declspecs
,
13448 const cp_declarator
*declarator
,
13453 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13454 if (decl1
== error_mark_node
)
13456 /* If the declarator is not suitable for a function definition,
13457 cause a syntax error. */
13458 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13460 error ("invalid function declaration");
13464 if (DECL_MAIN_P (decl1
))
13465 /* main must return int. grokfndecl should have corrected it
13466 (and issued a diagnostic) if the user got it wrong. */
13467 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13468 integer_type_node
));
13470 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13473 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13477 use_eh_spec_block (tree fn
)
13479 return (flag_exceptions
&& flag_enforce_eh_specs
13480 && !processing_template_decl
13481 && !type_throw_all_p (TREE_TYPE (fn
))
13482 /* We insert the EH_SPEC_BLOCK only in the original
13483 function; then, it is copied automatically to the
13485 && !DECL_CLONED_FUNCTION_P (fn
)
13486 /* Implicitly-generated constructors and destructors have
13487 exception specifications. However, those specifications
13488 are the union of the possible exceptions specified by the
13489 constructors/destructors for bases and members, so no
13490 unallowed exception will ever reach this function. By
13491 not creating the EH_SPEC_BLOCK we save a little memory,
13492 and we avoid spurious warnings about unreachable
13494 && !DECL_DEFAULTED_FN (fn
));
13497 /* Store the parameter declarations into the current function declaration.
13498 This is called after parsing the parameter declarations, before
13499 digesting the body of the function.
13501 Also install to binding contour return value identifier, if any. */
13504 store_parm_decls (tree current_function_parms
)
13506 tree fndecl
= current_function_decl
;
13509 /* This is a chain of any other decls that came in among the parm
13510 declarations. If a parm is declared with enum {foo, bar} x;
13511 then CONST_DECLs for foo and bar are put here. */
13512 tree nonparms
= NULL_TREE
;
13514 if (current_function_parms
)
13516 /* This case is when the function was defined with an ANSI prototype.
13517 The parms already have decls, so we need not do anything here
13518 except record them as in effect
13519 and complain if any redundant old-style parm decls were written. */
13521 tree specparms
= current_function_parms
;
13524 /* Must clear this because it might contain TYPE_DECLs declared
13526 current_binding_level
->names
= NULL
;
13528 /* If we're doing semantic analysis, then we'll call pushdecl
13529 for each of these. We must do them in reverse order so that
13530 they end in the correct forward order. */
13531 specparms
= nreverse (specparms
);
13533 for (parm
= specparms
; parm
; parm
= next
)
13535 next
= DECL_CHAIN (parm
);
13536 if (TREE_CODE (parm
) == PARM_DECL
)
13538 if (DECL_NAME (parm
) == NULL_TREE
13539 || !VOID_TYPE_P (parm
))
13542 error ("parameter %qD declared void", parm
);
13546 /* If we find an enum constant or a type tag,
13547 put it aside for the moment. */
13548 TREE_CHAIN (parm
) = NULL_TREE
;
13549 nonparms
= chainon (nonparms
, parm
);
13553 /* Get the decls in their original chain order and record in the
13554 function. This is all and only the PARM_DECLs that were
13555 pushed into scope by the loop above. */
13556 DECL_ARGUMENTS (fndecl
) = getdecls ();
13559 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13561 /* Now store the final chain of decls for the arguments
13562 as the decl-chain of the current lexical scope.
13563 Put the enumerators in as well, at the front so that
13564 DECL_ARGUMENTS is not modified. */
13565 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13567 if (use_eh_spec_block (current_function_decl
))
13568 current_eh_spec_block
= begin_eh_spec_block ();
13572 /* We have finished doing semantic analysis on DECL, but have not yet
13573 generated RTL for its body. Save away our current state, so that
13574 when we want to generate RTL later we know what to do. */
13577 save_function_data (tree decl
)
13579 struct language_function
*f
;
13581 /* Save the language-specific per-function data so that we can
13582 get it back when we really expand this function. */
13583 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13586 f
= ggc_alloc_language_function ();
13587 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13588 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13590 /* Clear out the bits we don't need. */
13591 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13592 f
->bindings
= NULL
;
13593 f
->x_local_names
= NULL
;
13594 f
->base
.local_typedefs
= NULL
;
13598 /* Set the return value of the constructor (if present). */
13601 finish_constructor_body (void)
13606 if (targetm
.cxx
.cdtor_returns_this ()
13607 && (! TYPE_FOR_JAVA (current_class_type
)))
13609 /* Any return from a constructor will end up here. */
13610 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13612 val
= DECL_ARGUMENTS (current_function_decl
);
13613 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13614 DECL_RESULT (current_function_decl
), val
);
13615 /* Return the address of the object. */
13616 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13617 add_stmt (exprstmt
);
13621 /* Do all the processing for the beginning of a destructor; set up the
13622 vtable pointers and cleanups for bases and members. */
13625 begin_destructor_body (void)
13627 tree compound_stmt
;
13629 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13630 issued an error message. We still want to try to process the
13631 body of the function, but initialize_vtbl_ptrs will crash if
13632 TYPE_BINFO is NULL. */
13633 if (COMPLETE_TYPE_P (current_class_type
))
13635 compound_stmt
= begin_compound_stmt (0);
13636 /* Make all virtual function table pointers in non-virtual base
13637 classes point to CURRENT_CLASS_TYPE's virtual function
13639 initialize_vtbl_ptrs (current_class_ptr
);
13640 finish_compound_stmt (compound_stmt
);
13642 /* Insert a cleanup to let the back end know that the object is dead
13643 when we exit the destructor, either normally or via exception. */
13644 tree clobber
= build_constructor (current_class_type
, NULL
);
13645 TREE_THIS_VOLATILE (clobber
) = true;
13646 tree exprstmt
= build2 (MODIFY_EXPR
, current_class_type
,
13647 current_class_ref
, clobber
);
13648 finish_decl_cleanup (NULL_TREE
, exprstmt
);
13650 /* And insert cleanups for our bases and members so that they
13651 will be properly destroyed if we throw. */
13652 push_base_cleanups ();
13656 /* At the end of every destructor we generate code to delete the object if
13657 necessary. Do that now. */
13660 finish_destructor_body (void)
13664 /* Any return from a destructor will end up here; that way all base
13665 and member cleanups will be run when the function returns. */
13666 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13668 /* In a virtual destructor, we must call delete. */
13669 if (DECL_VIRTUAL_P (current_function_decl
))
13672 tree virtual_size
= cxx_sizeof (current_class_type
);
13676 At the point of definition of a virtual destructor (including
13677 an implicit definition), non-placement operator delete shall
13678 be looked up in the scope of the destructor's class and if
13679 found shall be accessible and unambiguous. */
13680 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13682 /*global_p=*/false,
13683 /*placement=*/NULL_TREE
,
13684 /*alloc_fn=*/NULL_TREE
,
13685 tf_warning_or_error
);
13687 if_stmt
= begin_if_stmt ();
13688 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13689 current_in_charge_parm
,
13692 finish_expr_stmt (exprstmt
);
13693 finish_then_clause (if_stmt
);
13694 finish_if_stmt (if_stmt
);
13697 if (targetm
.cxx
.cdtor_returns_this ())
13701 val
= DECL_ARGUMENTS (current_function_decl
);
13702 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13703 DECL_RESULT (current_function_decl
), val
);
13704 /* Return the address of the object. */
13705 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13706 add_stmt (exprstmt
);
13710 /* Do the necessary processing for the beginning of a function body, which
13711 in this case includes member-initializers, but not the catch clauses of
13712 a function-try-block. Currently, this means opening a binding level
13713 for the member-initializers (in a ctor), member cleanups (in a dtor),
13714 and capture proxies (in a lambda operator()). */
13717 begin_function_body (void)
13721 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13724 if (processing_template_decl
)
13725 /* Do nothing now. */;
13727 /* Always keep the BLOCK node associated with the outermost pair of
13728 curly braces of a function. These are needed for correct
13729 operation of dwarfout.c. */
13730 keep_next_level (true);
13732 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13734 if (processing_template_decl
)
13735 /* Do nothing now. */;
13736 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13737 begin_destructor_body ();
13742 /* Do the processing for the end of a function body. Currently, this means
13743 closing out the cleanups for fully-constructed bases and members, and in
13744 the case of the destructor, deleting the object if desired. Again, this
13745 is only meaningful for [cd]tors, since they are the only functions where
13746 there is a significant distinction between the main body and any
13747 function catch clauses. Handling, say, main() return semantics here
13748 would be wrong, as flowing off the end of a function catch clause for
13749 main() would also need to return 0. */
13752 finish_function_body (tree compstmt
)
13754 if (compstmt
== NULL_TREE
)
13757 /* Close the block. */
13758 finish_compound_stmt (compstmt
);
13760 if (processing_template_decl
)
13761 /* Do nothing now. */;
13762 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
13763 finish_constructor_body ();
13764 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13765 finish_destructor_body ();
13768 /* Given a function, returns the BLOCK corresponding to the outermost level
13769 of curly braces, skipping the artificial block created for constructor
13773 outer_curly_brace_block (tree fndecl
)
13775 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
13776 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13777 /* Skip the artificial function body block. */
13778 block
= BLOCK_SUBBLOCKS (block
);
13782 /* If FNDECL is a class's key method, add the class to the list of
13783 keyed classes that should be emitted. */
13786 record_key_method_defined (tree fndecl
)
13788 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
13789 && DECL_VIRTUAL_P (fndecl
)
13790 && !processing_template_decl
)
13792 tree fnclass
= DECL_CONTEXT (fndecl
);
13793 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
13794 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
13798 /* Subroutine of finish_function.
13799 Save the body of constexpr functions for possible
13800 future compile time evaluation. */
13803 maybe_save_function_definition (tree fun
)
13805 if (!processing_template_decl
13806 && DECL_DECLARED_CONSTEXPR_P (fun
)
13807 && !DECL_CLONED_FUNCTION_P (fun
))
13808 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
13811 /* Finish up a function declaration and compile that function
13812 all the way to assembler language output. The free the storage
13813 for the function definition.
13815 FLAGS is a bitwise or of the following values:
13817 We just finished processing the body of an in-class inline
13818 function definition. (This processing will have taken place
13819 after the class definition is complete.) */
13822 finish_function (int flags
)
13824 tree fndecl
= current_function_decl
;
13825 tree fntype
, ctype
= NULL_TREE
;
13826 int inclass_inline
= (flags
& 2) != 0;
13828 /* When we get some parse errors, we can end up without a
13829 current_function_decl, so cope. */
13830 if (fndecl
== NULL_TREE
)
13831 return error_mark_node
;
13833 if (c_dialect_objc ())
13834 objc_finish_function ();
13836 gcc_assert (!defer_mark_used_calls
);
13837 defer_mark_used_calls
= true;
13839 record_key_method_defined (fndecl
);
13841 fntype
= TREE_TYPE (fndecl
);
13843 /* TREE_READONLY (fndecl) = 1;
13844 This caused &foo to be of type ptr-to-const-function
13845 which then got a warning when stored in a ptr-to-function variable. */
13847 gcc_assert (building_stmt_list_p ());
13848 /* The current function is being defined, so its DECL_INITIAL should
13849 be set, and unless there's a multiple definition, it should be
13850 error_mark_node. */
13851 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
13853 /* For a cloned function, we've already got all the code we need;
13854 there's no need to add any extra bits. */
13855 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13857 /* Make it so that `main' always returns 0 by default. */
13858 if (DECL_MAIN_P (current_function_decl
))
13859 finish_return_stmt (integer_zero_node
);
13861 if (use_eh_spec_block (current_function_decl
))
13862 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13863 (TREE_TYPE (current_function_decl
)),
13864 current_eh_spec_block
);
13867 /* If we're saving up tree structure, tie off the function now. */
13868 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
13870 finish_fname_decls ();
13872 /* If this function can't throw any exceptions, remember that. */
13873 if (!processing_template_decl
13874 && !cp_function_chain
->can_throw
13875 && !flag_non_call_exceptions
13876 && !decl_replaceable_p (fndecl
))
13877 TREE_NOTHROW (fndecl
) = 1;
13879 /* This must come after expand_function_end because cleanups might
13880 have declarations (from inline functions) that need to go into
13881 this function's blocks. */
13883 /* If the current binding level isn't the outermost binding level
13884 for this function, either there is a bug, or we have experienced
13885 syntax errors and the statement tree is malformed. */
13886 if (current_binding_level
->kind
!= sk_function_parms
)
13888 /* Make sure we have already experienced errors. */
13889 gcc_assert (errorcount
);
13891 /* Throw away the broken statement tree and extra binding
13893 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
13895 while (current_binding_level
->kind
!= sk_function_parms
)
13897 if (current_binding_level
->kind
== sk_class
)
13898 pop_nested_class ();
13900 poplevel (0, 0, 0);
13903 poplevel (1, 0, 1);
13905 /* Statements should always be full-expressions at the outermost set
13906 of curly braces for a function. */
13907 gcc_assert (stmts_are_full_exprs_p ());
13909 /* If there are no return statements in a function with auto return type,
13910 the return type is void. But if the declared type is something like
13911 auto*, this is an error. */
13912 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
13913 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
13915 if (!is_auto (current_function_auto_return_pattern
)
13916 && !current_function_returns_value
&& !current_function_returns_null
)
13918 error ("no return statements in function returning %qT",
13919 current_function_auto_return_pattern
);
13920 inform (input_location
, "only plain %<auto%> return type can be "
13921 "deduced to %<void%>");
13923 apply_deduced_return_type (fndecl
, void_type_node
);
13924 fntype
= TREE_TYPE (fndecl
);
13927 /* Save constexpr function body before it gets munged by
13928 the NRV transformation. */
13929 maybe_save_function_definition (fndecl
);
13931 /* Set up the named return value optimization, if we can. Candidate
13932 variables are selected in check_return_expr. */
13933 if (current_function_return_value
)
13935 tree r
= current_function_return_value
;
13938 if (r
!= error_mark_node
13939 /* This is only worth doing for fns that return in memory--and
13940 simpler, since we don't have to worry about promoted modes. */
13941 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
13942 /* Only allow this for variables declared in the outer scope of
13943 the function so we know that their lifetime always ends with a
13944 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13945 we were to do this optimization in tree-ssa. */
13946 && (outer
= outer_curly_brace_block (fndecl
))
13947 && chain_member (r
, BLOCK_VARS (outer
)))
13948 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
13950 current_function_return_value
= NULL_TREE
;
13953 /* Remember that we were in class scope. */
13954 if (current_class_name
)
13955 ctype
= current_class_type
;
13957 /* Must mark the RESULT_DECL as being in this function. */
13958 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13960 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13961 to the FUNCTION_DECL node itself. */
13962 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13964 /* Save away current state, if appropriate. */
13965 if (!processing_template_decl
)
13966 save_function_data (fndecl
);
13968 /* Complain if there's just no return statement. */
13969 if (warn_return_type
13970 && !VOID_TYPE_P (TREE_TYPE (fntype
))
13971 && !dependent_type_p (TREE_TYPE (fntype
))
13972 && !current_function_returns_value
&& !current_function_returns_null
13973 /* Don't complain if we abort or throw. */
13974 && !current_function_returns_abnormally
13975 /* Don't complain if we are declared noreturn. */
13976 && !TREE_THIS_VOLATILE (fndecl
)
13977 && !DECL_NAME (DECL_RESULT (fndecl
))
13978 && !TREE_NO_WARNING (fndecl
)
13979 /* Structor return values (if any) are set by the compiler. */
13980 && !DECL_CONSTRUCTOR_P (fndecl
)
13981 && !DECL_DESTRUCTOR_P (fndecl
)
13982 && targetm
.warn_func_return (fndecl
))
13984 warning (OPT_Wreturn_type
,
13985 "no return statement in function returning non-void");
13986 TREE_NO_WARNING (fndecl
) = 1;
13989 /* Store the end of the function, so that we get good line number
13990 info for the epilogue. */
13991 cfun
->function_end_locus
= input_location
;
13993 /* Complain about parameters that are only set, but never otherwise used. */
13994 if (warn_unused_but_set_parameter
13995 && !processing_template_decl
13996 && errorcount
== unused_but_set_errorcount
13997 && !DECL_CLONED_FUNCTION_P (fndecl
))
14001 for (decl
= DECL_ARGUMENTS (fndecl
);
14003 decl
= DECL_CHAIN (decl
))
14004 if (TREE_USED (decl
)
14005 && TREE_CODE (decl
) == PARM_DECL
14006 && !DECL_READ_P (decl
)
14007 && DECL_NAME (decl
)
14008 && !DECL_ARTIFICIAL (decl
)
14009 && !TREE_NO_WARNING (decl
)
14010 && !DECL_IN_SYSTEM_HEADER (decl
)
14011 && TREE_TYPE (decl
) != error_mark_node
14012 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14013 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14014 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14015 warning (OPT_Wunused_but_set_parameter
,
14016 "parameter %q+D set but not used", decl
);
14017 unused_but_set_errorcount
= errorcount
;
14020 /* Complain about locally defined typedefs that are not used in this
14022 maybe_warn_unused_local_typedefs ();
14024 /* Genericize before inlining. */
14025 if (!processing_template_decl
)
14027 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14028 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14029 cp_genericize (fndecl
);
14030 /* Clear out the bits we don't need. */
14031 f
->x_current_class_ptr
= NULL
;
14032 f
->x_current_class_ref
= NULL
;
14033 f
->x_eh_spec_block
= NULL
;
14034 f
->x_in_charge_parm
= NULL
;
14035 f
->x_vtt_parm
= NULL
;
14036 f
->x_return_value
= NULL
;
14037 f
->bindings
= NULL
;
14038 f
->extern_decl_map
= NULL
;
14040 /* Clear out the bits we don't need. */
14041 local_names
= NULL
;
14043 /* We're leaving the context of this function, so zap cfun. It's still in
14044 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14046 current_function_decl
= NULL
;
14048 /* If this is an in-class inline definition, we may have to pop the
14049 bindings for the template parameters that we added in
14050 maybe_begin_member_template_processing when start_function was
14052 if (inclass_inline
)
14053 maybe_end_member_template_processing ();
14055 /* Leave the scope of the class. */
14057 pop_nested_class ();
14062 current_function_decl
= NULL_TREE
;
14064 defer_mark_used_calls
= false;
14065 if (deferred_mark_used_calls
)
14070 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14072 vec_free (deferred_mark_used_calls
);
14078 /* Create the FUNCTION_DECL for a function definition.
14079 DECLSPECS and DECLARATOR are the parts of the declaration;
14080 they describe the return type and the name of the function,
14081 but twisted together in a fashion that parallels the syntax of C.
14083 This function creates a binding context for the function body
14084 as well as setting up the FUNCTION_DECL in current_function_decl.
14086 Returns a FUNCTION_DECL on success.
14088 If the DECLARATOR is not suitable for a function (it defines a datum
14089 instead), we return 0, which tells yyparse to report a parse error.
14091 May return void_type_node indicating that this method is actually
14092 a friend. See grokfield for more details.
14094 Came here with a `.pushlevel' .
14096 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14097 CHANGES TO CODE IN `grokfield'. */
14100 grokmethod (cp_decl_specifier_seq
*declspecs
,
14101 const cp_declarator
*declarator
, tree attrlist
)
14103 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14106 if (fndecl
== error_mark_node
)
14107 return error_mark_node
;
14109 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14111 error ("invalid member function declaration");
14112 return error_mark_node
;
14116 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14118 /* Pass friends other than inline friend functions back. */
14119 if (fndecl
== void_type_node
)
14122 if (DECL_IN_AGGR_P (fndecl
))
14124 if (DECL_CLASS_SCOPE_P (fndecl
))
14125 error ("%qD is already defined in class %qT", fndecl
,
14126 DECL_CONTEXT (fndecl
));
14127 return error_mark_node
;
14130 check_template_shadow (fndecl
);
14132 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14133 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14135 /* We process method specializations in finish_struct_1. */
14136 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14138 fndecl
= push_template_decl (fndecl
);
14139 if (fndecl
== error_mark_node
)
14143 if (! DECL_FRIEND_P (fndecl
))
14145 if (DECL_CHAIN (fndecl
))
14147 fndecl
= copy_node (fndecl
);
14148 TREE_CHAIN (fndecl
) = NULL_TREE
;
14152 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14154 DECL_IN_AGGR_P (fndecl
) = 1;
14159 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14160 we can lay it out later, when and if its type becomes complete.
14162 Also handle constexpr pointer to member variables where the initializer
14163 is an unlowered PTRMEM_CST because the class isn't complete yet. */
14166 maybe_register_incomplete_var (tree var
)
14168 gcc_assert (VAR_P (var
));
14170 /* Keep track of variables with incomplete types. */
14171 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14172 && DECL_EXTERNAL (var
))
14174 tree inner_type
= TREE_TYPE (var
);
14176 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14177 inner_type
= TREE_TYPE (inner_type
);
14178 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14180 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14181 /* RTTI TD entries are created while defining the type_info. */
14182 || (TYPE_LANG_SPECIFIC (inner_type
)
14183 && TYPE_BEING_DEFINED (inner_type
)))
14185 incomplete_var iv
= {var
, inner_type
};
14186 vec_safe_push (incomplete_vars
, iv
);
14188 else if (TYPE_PTRMEM_P (inner_type
)
14189 && DECL_INITIAL (var
)
14190 && TREE_CODE (DECL_INITIAL (var
)) == PTRMEM_CST
)
14192 tree context
= TYPE_PTRMEM_CLASS_TYPE (inner_type
);
14193 gcc_assert (TYPE_BEING_DEFINED (context
));
14194 incomplete_var iv
= {var
, context
};
14195 vec_safe_push (incomplete_vars
, iv
);
14200 /* Called when a class type (given by TYPE) is defined. If there are
14201 any existing VAR_DECLs whose type has been completed by this
14202 declaration, update them now. */
14205 complete_vars (tree type
)
14208 incomplete_var
*iv
;
14210 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14212 if (same_type_p (type
, iv
->incomplete_type
))
14214 tree var
= iv
->decl
;
14215 tree type
= TREE_TYPE (var
);
14217 if (TYPE_PTRMEM_P (type
))
14218 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14221 /* Complete the type of the variable. The VAR_DECL itself
14222 will be laid out in expand_expr. */
14223 complete_type (type
);
14224 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14227 /* Remove this entry from the list. */
14228 incomplete_vars
->unordered_remove (ix
);
14234 /* Check for pending declarations which may have abstract type. */
14235 complete_type_check_abstract (type
);
14238 /* If DECL is of a type which needs a cleanup, build and return an
14239 expression to perform that cleanup here. Return NULL_TREE if no
14240 cleanup need be done. */
14243 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14249 /* Assume no cleanup is required. */
14250 cleanup
= NULL_TREE
;
14252 if (error_operand_p (decl
))
14255 /* Handle "__attribute__((cleanup))". We run the cleanup function
14256 before the destructor since the destructor is what actually
14257 terminates the lifetime of the object. */
14258 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14265 /* Get the name specified by the user for the cleanup function. */
14266 id
= TREE_VALUE (TREE_VALUE (attr
));
14267 /* Look up the name to find the cleanup function to call. It is
14268 important to use lookup_name here because that is what is
14269 used in c-common.c:handle_cleanup_attribute when performing
14270 initial checks on the attribute. Note that those checks
14271 include ensuring that the function found is not an overloaded
14272 function, or an object with an overloaded call operator,
14273 etc.; we can rely on the fact that the function found is an
14274 ordinary FUNCTION_DECL. */
14275 fn
= lookup_name (id
);
14276 arg
= build_address (decl
);
14278 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14279 if (cleanup
== error_mark_node
)
14280 return error_mark_node
;
14282 /* Handle ordinary C++ destructors. */
14283 type
= TREE_TYPE (decl
);
14284 if (type_build_dtor_call (type
))
14286 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14290 if (TREE_CODE (type
) == ARRAY_TYPE
)
14293 addr
= build_address (decl
);
14295 call
= build_delete (TREE_TYPE (addr
), addr
,
14296 sfk_complete_destructor
, flags
, 0, complain
);
14297 if (call
== error_mark_node
)
14298 cleanup
= error_mark_node
;
14299 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14300 /* Discard the call. */;
14302 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14307 /* build_delete sets the location of the destructor call to the
14308 current location, even though the destructor is going to be
14309 called later, at the end of the current scope. This can lead to
14310 a "jumpy" behaviour for users of debuggers when they step around
14311 the end of the block. So let's unset the location of the
14312 destructor call instead. */
14313 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14314 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14319 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14320 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14321 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14324 static_fn_type (tree memfntype
)
14329 if (TYPE_PTRMEMFUNC_P (memfntype
))
14330 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14331 if (POINTER_TYPE_P (memfntype
)
14332 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14333 memfntype
= TREE_TYPE (memfntype
);
14334 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14336 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14337 args
= TYPE_ARG_TYPES (memfntype
);
14338 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14339 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14340 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14341 fntype
= (cp_build_type_attribute_variant
14342 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14343 fntype
= (build_exception_variant
14344 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14348 /* DECL was originally constructed as a non-static member function,
14349 but turned out to be static. Update it accordingly. */
14352 revert_static_member_fn (tree decl
)
14354 tree stype
= static_fn_type (decl
);
14355 cp_cv_quals quals
= type_memfn_quals (stype
);
14356 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14358 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14359 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14361 TREE_TYPE (decl
) = stype
;
14363 if (DECL_ARGUMENTS (decl
))
14364 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14365 DECL_STATIC_FUNCTION_P (decl
) = 1;
14368 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14369 one of the language-independent trees. */
14371 enum cp_tree_node_structure_enum
14372 cp_tree_node_structure (union lang_tree_node
* t
)
14374 switch (TREE_CODE (&t
->generic
))
14376 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14377 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14378 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14379 case OVERLOAD
: return TS_CP_OVERLOAD
;
14380 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14381 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14382 case BASELINK
: return TS_CP_BASELINK
;
14383 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14384 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14385 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14386 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14387 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14388 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14389 default: return TS_CP_GENERIC
;
14393 /* Build the void_list_node (void_type_node having been created). */
14395 build_void_list_node (void)
14397 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14402 cp_missing_noreturn_ok_p (tree decl
)
14404 /* A missing noreturn is ok for the `main' function. */
14405 return DECL_MAIN_P (decl
);
14408 /* Return the COMDAT group into which DECL should be placed. */
14411 cxx_comdat_group (tree decl
)
14415 /* Virtual tables, construction virtual tables, and virtual table
14416 tables all go in a single COMDAT group, named after the primary
14418 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14419 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
14420 /* For all other DECLs, the COMDAT group is the mangled name of the
14421 declaration itself. */
14424 while (DECL_THUNK_P (decl
))
14426 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14427 into the same section as the target function. In that case
14428 we must return target's name. */
14429 tree target
= THUNK_TARGET (decl
);
14430 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14431 && DECL_SECTION_NAME (target
) != NULL
14432 && DECL_ONE_ONLY (target
))
14437 name
= DECL_ASSEMBLER_NAME (decl
);
14443 /* Returns the return type for FN as written by the user, which may include
14444 a placeholder for a deduced return type. */
14447 fndecl_declared_return_type (tree fn
)
14449 fn
= STRIP_TEMPLATE (fn
);
14450 if (FNDECL_USED_AUTO (fn
))
14452 struct language_function
*f
= NULL
;
14453 if (DECL_STRUCT_FUNCTION (fn
))
14454 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
14456 f
= DECL_SAVED_FUNCTION_DATA (fn
);
14457 return f
->x_auto_return_pattern
;
14459 return TREE_TYPE (TREE_TYPE (fn
));
14462 /* Returns true iff DECL was declared with an auto return type and it has
14463 not yet been deduced to a real type. */
14466 undeduced_auto_decl (tree decl
)
14468 if (cxx_dialect
< cxx1y
)
14470 return type_uses_auto (TREE_TYPE (decl
));
14473 /* Complain if DECL has an undeduced return type. */
14476 require_deduced_type (tree decl
)
14478 if (undeduced_auto_decl (decl
))
14479 error ("use of %qD before deduction of %<auto%>", decl
);
14482 #include "gt-cp-decl.h"