1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2014 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
34 #include "stringpool.h"
35 #include "stor-layout.h"
41 #include "tree-iterator.h"
42 #include "tree-inline.h"
49 #include "c-family/c-common.h"
50 #include "c-family/c-objc.h"
51 #include "c-family/c-pragma.h"
52 #include "c-family/c-target.h"
53 #include "c-family/c-ubsan.h"
54 #include "diagnostic.h"
58 #include "pointer-set.h"
59 #include "splay-tree.h"
65 /* Possible cases of bad specifiers type used by bad_specifiers. */
67 BSP_VAR
, /* variable */
68 BSP_PARM
, /* parameter */
73 static tree
grokparms (tree parmlist
, tree
*);
74 static const char *redeclaration_error_message (tree
, tree
);
76 static int decl_jump_unsafe (tree
);
77 static void require_complete_types_for_parms (tree
);
78 static int ambi_op_p (enum tree_code
);
79 static int unary_op_p (enum tree_code
);
80 static void push_local_name (tree
);
81 static tree
grok_reference_init (tree
, tree
, tree
, int);
82 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
84 static int check_static_variable_definition (tree
, tree
);
85 static void record_unknown_type (tree
, const char *);
86 static tree
builtin_function_1 (tree
, tree
, bool);
87 static int member_function_or_else (tree
, tree
, enum overload_flags
);
88 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
90 static void check_for_uninitialized_const_var (tree
);
91 static hashval_t
typename_hash (const void *);
92 static int typename_compare (const void *, const void *);
93 static tree
local_variable_p_walkfn (tree
*, int *, void *);
94 static tree
record_builtin_java_type (const char *, int);
95 static const char *tag_name (enum tag_types
);
96 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
97 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
98 static void maybe_deduce_size_from_array_init (tree
, tree
);
99 static void layout_var_decl (tree
);
100 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
101 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
102 static void save_function_data (tree
);
103 static void copy_type_enum (tree
, tree
);
104 static void check_function_type (tree
, tree
);
105 static void finish_constructor_body (void);
106 static void begin_destructor_body (void);
107 static void finish_destructor_body (void);
108 static void record_key_method_defined (tree
);
109 static tree
create_array_type_for_decl (tree
, tree
, tree
);
110 static tree
get_atexit_node (void);
111 static tree
get_dso_handle_node (void);
112 static tree
start_cleanup_fn (void);
113 static void end_cleanup_fn (void);
114 static tree
cp_make_fname_decl (location_t
, tree
, int);
115 static void initialize_predefined_identifiers (void);
116 static tree check_special_function_return_type
117 (special_function_kind
, tree
, tree
);
118 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
119 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
120 static void store_parm_decls (tree
);
121 static void initialize_local_var (tree
, tree
);
122 static void expand_static_init (tree
, tree
);
124 /* The following symbols are subsumed in the cp_global_trees array, and
125 listed here individually for documentation purposes.
128 tree wchar_decl_node;
130 tree vtable_entry_type;
131 tree delta_type_node;
132 tree __t_desc_type_node;
134 tree class_type_node;
135 tree unknown_type_node;
137 Array type `vtable_entry_type[]'
140 tree vtbl_ptr_type_node;
147 A FUNCTION_DECL which can call `abort'. Not necessarily the
148 one that the user will declare, but sufficient to be called
149 by routines that want to abort the program.
153 The FUNCTION_DECL for the default `::operator delete'.
155 tree global_delete_fndecl;
158 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
159 tree tinfo_var_id; */
161 tree cp_global_trees
[CPTI_MAX
];
163 /* Indicates that there is a type value in some namespace, although
164 that is not necessarily in scope at the moment. */
166 tree global_type_node
;
168 /* The node that holds the "name" of the global scope. */
169 tree global_scope_name
;
171 #define local_names cp_function_chain->x_local_names
173 /* A list of objects which have constructors or destructors
174 which reside in the global scope. The decl is stored in
175 the TREE_VALUE slot and the initializer is stored
176 in the TREE_PURPOSE slot. */
177 tree static_aggregates
;
179 /* Like static_aggregates, but for thread_local variables. */
184 /* A node for the integer constant 2. */
186 tree integer_two_node
;
188 /* Used only for jumps to as-yet undefined labels, since jumps to
189 defined labels can have their validity checked immediately. */
191 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
192 struct named_label_use_entry
*next
;
193 /* The binding level to which this entry is *currently* attached.
194 This is initially the binding level in which the goto appeared,
195 but is modified as scopes are closed. */
196 cp_binding_level
*binding_level
;
197 /* The head of the names list that was current when the goto appeared,
198 or the inner scope popped. These are the decls that will *not* be
199 skipped when jumping to the label. */
201 /* The location of the goto, for error reporting. */
202 location_t o_goto_locus
;
203 /* True if an OpenMP structured block scope has been closed since
204 the goto appeared. This means that the branch from the label will
205 illegally exit an OpenMP scope. */
209 /* A list of all LABEL_DECLs in the function that have names. Here so
210 we can clear out their names' definitions at the end of the
211 function, and so we can check the validity of jumps to these labels. */
213 struct GTY(()) named_label_entry
{
214 /* The decl itself. */
217 /* The binding level to which the label is *currently* attached.
218 This is initially set to the binding level in which the label
219 is defined, but is modified as scopes are closed. */
220 cp_binding_level
*binding_level
;
221 /* The head of the names list that was current when the label was
222 defined, or the inner scope popped. These are the decls that will
223 be skipped when jumping to the label. */
225 /* A vector of all decls from all binding levels that would be
226 crossed by a backward branch to the label. */
227 vec
<tree
, va_gc
> *bad_decls
;
229 /* A list of uses of the label, before the label is defined. */
230 struct named_label_use_entry
*uses
;
232 /* The following bits are set after the label is defined, and are
233 updated as scopes are popped. They indicate that a backward jump
234 to the label will illegally enter a scope of the given flavor. */
240 #define named_labels cp_function_chain->x_named_labels
242 /* The number of function bodies which we are currently processing.
243 (Zero if we are at namespace scope, one inside the body of a
244 function, two inside the body of a function in a local class, etc.) */
247 /* To avoid unwanted recursion, finish_function defers all mark_used calls
248 encountered during its execution until it finishes. */
249 bool defer_mark_used_calls
;
250 vec
<tree
, va_gc
> *deferred_mark_used_calls
;
252 /* States indicating how grokdeclarator() should handle declspecs marked
253 with __attribute__((deprecated)). An object declared as
254 __attribute__((deprecated)) suppresses warnings of uses of other
256 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
259 /* A list of VAR_DECLs whose type was incomplete at the time the
260 variable was declared. */
262 typedef struct GTY(()) incomplete_var_d
{
264 tree incomplete_type
;
268 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
270 /* Returns the kind of template specialization we are currently
271 processing, given that it's declaration contained N_CLASS_SCOPES
272 explicit scope qualifications. */
275 current_tmpl_spec_kind (int n_class_scopes
)
277 int n_template_parm_scopes
= 0;
278 int seen_specialization_p
= 0;
279 int innermost_specialization_p
= 0;
282 /* Scan through the template parameter scopes. */
283 for (b
= current_binding_level
;
284 b
->kind
== sk_template_parms
;
287 /* If we see a specialization scope inside a parameter scope,
288 then something is wrong. That corresponds to a declaration
291 template <class T> template <> ...
293 which is always invalid since [temp.expl.spec] forbids the
294 specialization of a class member template if the enclosing
295 class templates are not explicitly specialized as well. */
296 if (b
->explicit_spec_p
)
298 if (n_template_parm_scopes
== 0)
299 innermost_specialization_p
= 1;
301 seen_specialization_p
= 1;
303 else if (seen_specialization_p
== 1)
304 return tsk_invalid_member_spec
;
306 ++n_template_parm_scopes
;
309 /* Handle explicit instantiations. */
310 if (processing_explicit_instantiation
)
312 if (n_template_parm_scopes
!= 0)
313 /* We've seen a template parameter list during an explicit
314 instantiation. For example:
316 template <class T> template void f(int);
318 This is erroneous. */
319 return tsk_invalid_expl_inst
;
321 return tsk_expl_inst
;
324 if (n_template_parm_scopes
< n_class_scopes
)
325 /* We've not seen enough template headers to match all the
326 specialized classes present. For example:
328 template <class T> void R<T>::S<T>::f(int);
330 This is invalid; there needs to be one set of template
331 parameters for each class. */
332 return tsk_insufficient_parms
;
333 else if (n_template_parm_scopes
== n_class_scopes
)
334 /* We're processing a non-template declaration (even though it may
335 be a member of a template class.) For example:
337 template <class T> void S<T>::f(int);
339 The `class T' matches the `S<T>', leaving no template headers
340 corresponding to the `f'. */
342 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
343 /* We've got too many template headers. For example:
345 template <> template <class T> void f (T);
347 There need to be more enclosing classes. */
348 return tsk_excessive_parms
;
350 /* This must be a template. It's of the form:
352 template <class T> template <class U> void S<T>::f(U);
354 This is a specialization if the innermost level was a
355 specialization; otherwise it's just a definition of the
357 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
360 /* Exit the current scope. */
368 /* When a label goes out of scope, check to see if that label was used
369 in a valid manner, and issue any appropriate warnings or errors. */
372 pop_label (tree label
, tree old_value
)
374 if (!processing_template_decl
)
376 if (DECL_INITIAL (label
) == NULL_TREE
)
380 error ("label %q+D used but not defined", label
);
381 location
= input_location
;
382 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
383 /* Avoid crashing later. */
384 define_label (location
, DECL_NAME (label
));
387 warn_for_unused_label (label
);
390 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
393 /* At the end of a function, all labels declared within the function
394 go out of scope. BLOCK is the top-level block for the
398 pop_labels_1 (void **slot
, void *data
)
400 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
401 tree block
= (tree
) data
;
403 pop_label (ent
->label_decl
, NULL_TREE
);
405 /* Put the labels into the "variables" of the top-level block,
406 so debugger can see them. */
407 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
408 BLOCK_VARS (block
) = ent
->label_decl
;
410 htab_clear_slot (named_labels
, slot
);
416 pop_labels (tree block
)
420 htab_traverse (named_labels
, pop_labels_1
, block
);
425 /* At the end of a block with local labels, restore the outer definition. */
428 pop_local_label (tree label
, tree old_value
)
430 struct named_label_entry dummy
;
433 pop_label (label
, old_value
);
435 dummy
.label_decl
= label
;
436 slot
= htab_find_slot (named_labels
, &dummy
, NO_INSERT
);
437 htab_clear_slot (named_labels
, slot
);
440 /* The following two routines are used to interface to Objective-C++.
441 The binding level is purposely treated as an opaque type. */
444 objc_get_current_scope (void)
446 return current_binding_level
;
449 /* The following routine is used by the NeXT-style SJLJ exceptions;
450 variables get marked 'volatile' so as to not be clobbered by
451 _setjmp()/_longjmp() calls. All variables in the current scope,
452 as well as parent scopes up to (but not including) ENCLOSING_BLK
453 shall be thusly marked. */
456 objc_mark_locals_volatile (void *enclosing_blk
)
458 cp_binding_level
*scope
;
460 for (scope
= current_binding_level
;
461 scope
&& scope
!= enclosing_blk
;
462 scope
= scope
->level_chain
)
466 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
467 objc_volatilize_decl (decl
);
469 /* Do not climb up past the current function. */
470 if (scope
->kind
== sk_function_parms
)
475 /* Update data for defined and undefined labels when leaving a scope. */
478 poplevel_named_label_1 (void **slot
, void *data
)
480 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
481 cp_binding_level
*bl
= (cp_binding_level
*) data
;
482 cp_binding_level
*obl
= bl
->level_chain
;
484 if (ent
->binding_level
== bl
)
488 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
489 TREE_LISTs representing OVERLOADs, so be careful. */
490 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
492 : TREE_CHAIN (decl
)))
493 if (decl_jump_unsafe (decl
))
494 vec_safe_push (ent
->bad_decls
, decl
);
496 ent
->binding_level
= obl
;
497 ent
->names_in_scope
= obl
->names
;
501 ent
->in_try_scope
= true;
504 ent
->in_catch_scope
= true;
507 ent
->in_omp_scope
= true;
515 struct named_label_use_entry
*use
;
517 for (use
= ent
->uses
; use
; use
= use
->next
)
518 if (use
->binding_level
== bl
)
520 use
->binding_level
= obl
;
521 use
->names_in_scope
= obl
->names
;
522 if (bl
->kind
== sk_omp
)
523 use
->in_omp_scope
= true;
530 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
531 when errors were reported, except for -Werror-unused-but-set-*. */
532 static int unused_but_set_errorcount
;
534 /* Exit a binding level.
535 Pop the level off, and restore the state of the identifier-decl mappings
536 that were in effect when this level was entered.
538 If KEEP == 1, this level had explicit declarations, so
539 and create a "block" (a BLOCK node) for the level
540 to record its declarations and subblocks for symbol table output.
542 If FUNCTIONBODY is nonzero, this level is the body of a function,
543 so create a block as if KEEP were set and also clear out all
546 If REVERSE is nonzero, reverse the order of decls before putting
547 them into the BLOCK. */
550 poplevel (int keep
, int reverse
, int functionbody
)
553 /* The chain of decls was accumulated in reverse order.
554 Put it into forward order, just for cleanliness. */
559 int leaving_for_scope
;
562 cp_label_binding
*label_bind
;
564 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
569 gcc_assert (current_binding_level
->kind
!= sk_class
);
571 if (current_binding_level
->kind
== sk_cleanup
)
573 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
575 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
577 /* We used to use KEEP == 2 to indicate that the new block should go
578 at the beginning of the list of blocks at this binding level,
579 rather than the end. This hack is no longer used. */
580 gcc_assert (keep
== 0 || keep
== 1);
582 if (current_binding_level
->keep
)
585 /* Any uses of undefined labels, and any defined labels, now operate
586 under constraints of next binding contour. */
587 if (cfun
&& !functionbody
&& named_labels
)
588 htab_traverse (named_labels
, poplevel_named_label_1
,
589 current_binding_level
);
591 /* Get the decls in the order they were written.
592 Usually current_binding_level->names is in reverse order.
593 But parameter decls were previously put in forward order. */
596 current_binding_level
->names
597 = decls
= nreverse (current_binding_level
->names
);
599 decls
= current_binding_level
->names
;
601 /* If there were any declarations or structure tags in that level,
602 or if this level is a function body,
603 create a BLOCK to record them for the life of this function. */
605 if (keep
== 1 || functionbody
)
606 block
= make_node (BLOCK
);
607 if (block
!= NULL_TREE
)
609 BLOCK_VARS (block
) = decls
;
610 BLOCK_SUBBLOCKS (block
) = subblocks
;
613 /* In each subblock, record that this is its superior. */
615 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
616 BLOCK_SUPERCONTEXT (link
) = block
;
618 /* We still support the old for-scope rules, whereby the variables
619 in a for-init statement were in scope after the for-statement
620 ended. We only use the new rules if flag_new_for_scope is
623 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
625 /* Before we remove the declarations first check for unused variables. */
626 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
627 && !processing_template_decl
)
628 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
630 /* There are cases where D itself is a TREE_LIST. See in
631 push_local_binding where the list of decls returned by
632 getdecls is built. */
633 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
634 // See through references for improved -Wunused-variable (PR 38958).
635 tree type
= non_reference (TREE_TYPE (decl
));
637 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
638 && ! DECL_IN_SYSTEM_HEADER (decl
)
639 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
640 && type
!= error_mark_node
641 && (!CLASS_TYPE_P (type
)
642 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
643 || lookup_attribute ("warn_unused",
644 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
646 if (! TREE_USED (decl
))
647 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
648 else if (DECL_CONTEXT (decl
) == current_function_decl
649 // For -Wunused-but-set-variable leave references alone.
650 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
651 && errorcount
== unused_but_set_errorcount
)
653 warning (OPT_Wunused_but_set_variable
,
654 "variable %q+D set but not used", decl
);
655 unused_but_set_errorcount
= errorcount
;
660 /* Remove declarations for all the DECLs in this level. */
661 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
663 if (leaving_for_scope
&& VAR_P (link
)
664 /* It's hard to make this ARM compatibility hack play nicely with
665 lambdas, and it really isn't necessary in C++11 mode. */
666 && cxx_dialect
< cxx11
669 tree name
= DECL_NAME (link
);
673 ob
= outer_binding (name
,
674 IDENTIFIER_BINDING (name
),
677 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
679 ns_binding
= NULL_TREE
;
681 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
682 /* We have something like:
687 and we are leaving the `for' scope. There's no reason to
688 keep the binding of the inner `i' in this case. */
689 pop_binding (name
, link
);
690 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
691 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
692 /* Here, we have something like:
700 We must pop the for-scope binding so we know what's a
701 type and what isn't. */
702 pop_binding (name
, link
);
705 /* Mark this VAR_DECL as dead so that we can tell we left it
706 there only for backward compatibility. */
707 DECL_DEAD_FOR_LOCAL (link
) = 1;
709 /* Keep track of what should have happened when we
710 popped the binding. */
713 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
714 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
717 /* Add it to the list of dead variables in the next
718 outermost binding to that we can remove these when we
719 leave that binding. */
721 current_binding_level
->level_chain
->dead_vars_from_for
,
724 /* Although we don't pop the cxx_binding, we do clear
725 its SCOPE since the scope is going away now. */
726 IDENTIFIER_BINDING (name
)->scope
727 = current_binding_level
->level_chain
;
734 /* Remove the binding. */
737 if (TREE_CODE (decl
) == TREE_LIST
)
738 decl
= TREE_VALUE (decl
);
741 if (TREE_CODE (name
) == OVERLOAD
)
742 name
= OVL_FUNCTION (name
);
744 gcc_assert (DECL_P (name
));
745 pop_binding (DECL_NAME (name
), decl
);
749 /* Remove declarations for any `for' variables from inner scopes
750 that we kept around. */
751 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
753 pop_binding (DECL_NAME (decl
), decl
);
755 /* Restore the IDENTIFIER_TYPE_VALUEs. */
756 for (link
= current_binding_level
->type_shadowed
;
757 link
; link
= TREE_CHAIN (link
))
758 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
760 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
761 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
763 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
765 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
766 list if a `using' declaration put them there. The debugging
767 back ends won't understand OVERLOAD, so we remove them here.
768 Because the BLOCK_VARS are (temporarily) shared with
769 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
770 popped all the bindings. */
775 for (d
= &BLOCK_VARS (block
); *d
; )
777 if (TREE_CODE (*d
) == TREE_LIST
)
778 *d
= TREE_CHAIN (*d
);
780 d
= &DECL_CHAIN (*d
);
784 /* If the level being exited is the top level of a function,
785 check over all the labels. */
788 /* Since this is the top level block of a function, the vars are
789 the function's parameters. Don't leave them in the BLOCK
790 because they are found in the FUNCTION_DECL instead. */
791 BLOCK_VARS (block
) = 0;
795 kind
= current_binding_level
->kind
;
796 if (kind
== sk_cleanup
)
800 /* If this is a temporary binding created for a cleanup, then we'll
801 have pushed a statement list level. Pop that, create a new
802 BIND_EXPR for the block, and insert it into the stream. */
803 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
804 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
811 /* The current function is being defined, so its DECL_INITIAL
812 should be error_mark_node. */
813 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
814 DECL_INITIAL (current_function_decl
) = block
;
817 current_binding_level
->blocks
818 = block_chainon (current_binding_level
->blocks
, block
);
820 /* If we did not make a block for the level just exited,
821 any blocks made for inner levels
822 (since they cannot be recorded as subblocks in that level)
823 must be carried forward so they will later become subblocks
824 of something else. */
826 current_binding_level
->blocks
827 = block_chainon (current_binding_level
->blocks
, subblocks
);
829 /* Each and every BLOCK node created here in `poplevel' is important
830 (e.g. for proper debugging information) so if we created one
831 earlier, mark it as "used". */
833 TREE_USED (block
) = 1;
835 /* All temporary bindings created for cleanups are popped silently. */
836 if (kind
== sk_cleanup
)
839 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
843 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
844 itself, calling F for each. The DATA is passed to F as well. */
847 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
850 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
852 result
|= (*f
) (name_space
, data
);
854 for (; current
; current
= DECL_CHAIN (current
))
855 result
|= walk_namespaces_r (current
, f
, data
);
860 /* Walk all the namespaces, calling F for each. The DATA is passed to
864 walk_namespaces (walk_namespaces_fn f
, void* data
)
866 return walk_namespaces_r (global_namespace
, f
, data
);
869 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
870 DATA is non-NULL, this is the last time we will call
871 wrapup_global_declarations for this NAMESPACE. */
874 wrapup_globals_for_namespace (tree name_space
, void* data
)
876 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
877 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
878 tree
*vec
= statics
->address ();
879 int len
= statics
->length ();
880 int last_time
= (data
!= 0);
884 check_global_declarations (vec
, len
);
885 emit_debug_global_declarations (vec
, len
);
889 /* Write out any globals that need to be output. */
890 return wrapup_global_declarations (vec
, len
);
894 /* In C++, you don't have to write `struct S' to refer to `S'; you
895 can just use `S'. We accomplish this by creating a TYPE_DECL as
896 if the user had written `typedef struct S S'. Create and return
897 the TYPE_DECL for TYPE. */
900 create_implicit_typedef (tree name
, tree type
)
904 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
905 DECL_ARTIFICIAL (decl
) = 1;
906 /* There are other implicit type declarations, like the one *within*
907 a class that allows you to write `S::S'. We must distinguish
909 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
910 TYPE_NAME (type
) = decl
;
911 TYPE_STUB_DECL (type
) = decl
;
916 /* Remember a local name for name-mangling purposes. */
919 push_local_name (tree decl
)
924 timevar_start (TV_NAME_LOOKUP
);
926 name
= DECL_NAME (decl
);
928 nelts
= vec_safe_length (local_names
);
929 for (i
= 0; i
< nelts
; i
++)
931 t
= (*local_names
)[i
];
932 if (DECL_NAME (t
) == name
)
934 if (!DECL_LANG_SPECIFIC (decl
))
935 retrofit_lang_decl (decl
);
936 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
937 if (DECL_DISCRIMINATOR_SET_P (t
))
938 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
940 DECL_DISCRIMINATOR (decl
) = 1;
942 (*local_names
)[i
] = decl
;
943 timevar_stop (TV_NAME_LOOKUP
);
948 vec_safe_push (local_names
, decl
);
949 timevar_stop (TV_NAME_LOOKUP
);
952 /* Subroutine of duplicate_decls: return truthvalue of whether
953 or not types of these decls match.
955 For C++, we must compare the parameter list so that `int' can match
956 `int&' in a parameter position, but `int&' is not confused with
960 decls_match (tree newdecl
, tree olddecl
)
964 if (newdecl
== olddecl
)
967 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
968 /* If the two DECLs are not even the same kind of thing, we're not
969 interested in their types. */
972 gcc_assert (DECL_P (newdecl
));
974 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
976 tree f1
= TREE_TYPE (newdecl
);
977 tree f2
= TREE_TYPE (olddecl
);
978 tree p1
= TYPE_ARG_TYPES (f1
);
979 tree p2
= TYPE_ARG_TYPES (f2
);
982 /* Specializations of different templates are different functions
983 even if they have the same type. */
984 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
985 ? DECL_TI_TEMPLATE (newdecl
)
987 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
988 ? DECL_TI_TEMPLATE (olddecl
)
993 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
994 && ! (DECL_EXTERN_C_P (newdecl
)
995 && DECL_EXTERN_C_P (olddecl
)))
998 /* A new declaration doesn't match a built-in one unless it
999 is also extern "C". */
1000 if (DECL_IS_BUILTIN (olddecl
)
1001 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1004 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1007 /* A declaration with deduced return type should use its pre-deduction
1008 type for declaration matching. */
1009 r2
= fndecl_declared_return_type (olddecl
);
1011 if (same_type_p (TREE_TYPE (f1
), r2
))
1013 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1014 && (DECL_BUILT_IN (olddecl
)
1015 #ifndef NO_IMPLICIT_EXTERN_C
1016 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1017 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1021 types_match
= self_promoting_args_p (p1
);
1022 if (p1
== void_list_node
)
1023 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1025 #ifndef NO_IMPLICIT_EXTERN_C
1026 else if (!prototype_p (f1
)
1027 && (DECL_EXTERN_C_P (olddecl
)
1028 && DECL_IN_SYSTEM_HEADER (olddecl
)
1029 && !DECL_CLASS_SCOPE_P (olddecl
))
1030 && (DECL_EXTERN_C_P (newdecl
)
1031 && DECL_IN_SYSTEM_HEADER (newdecl
)
1032 && !DECL_CLASS_SCOPE_P (newdecl
)))
1034 types_match
= self_promoting_args_p (p2
);
1035 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1041 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1042 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1043 || comp_type_attributes (TREE_TYPE (newdecl
),
1044 TREE_TYPE (olddecl
)) != 0);
1049 /* The decls dont match if they correspond to two different versions
1050 of the same function. Disallow extern "C" functions to be
1051 versions for now. */
1053 && !DECL_EXTERN_C_P (newdecl
)
1054 && !DECL_EXTERN_C_P (olddecl
)
1055 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1057 /* Mark functions as versions if necessary. Modify the mangled decl
1058 name if necessary. */
1059 if (DECL_FUNCTION_VERSIONED (newdecl
)
1060 && DECL_FUNCTION_VERSIONED (olddecl
))
1062 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1064 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1065 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1066 mangle_decl (newdecl
);
1068 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1070 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1071 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1072 mangle_decl (olddecl
);
1074 record_function_versions (olddecl
, newdecl
);
1078 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1080 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1081 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1084 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1085 DECL_TEMPLATE_PARMS (olddecl
)))
1088 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1089 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1090 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1092 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1093 DECL_TEMPLATE_RESULT (newdecl
));
1097 /* Need to check scope for variable declaration (VAR_DECL).
1098 For typedef (TYPE_DECL), scope is ignored. */
1100 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1102 Two declarations for an object with C language linkage
1103 with the same name (ignoring the namespace that qualify
1104 it) that appear in different namespace scopes refer to
1106 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1109 if (TREE_TYPE (newdecl
) == error_mark_node
)
1110 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1111 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1112 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1113 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1116 types_match
= comptypes (TREE_TYPE (newdecl
),
1117 TREE_TYPE (olddecl
),
1118 COMPARE_REDECLARATION
);
1124 /* If NEWDECL is `static' and an `extern' was seen previously,
1125 warn about it. OLDDECL is the previous declaration.
1127 Note that this does not apply to the C++ case of declaring
1128 a variable `extern const' and then later `const'.
1130 Don't complain about built-in functions, since they are beyond
1131 the user's control. */
1134 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1136 if (TREE_CODE (newdecl
) == TYPE_DECL
1137 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1138 || TREE_CODE (newdecl
) == CONST_DECL
1139 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1142 /* Don't get confused by static member functions; that's a different
1144 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1145 && DECL_STATIC_FUNCTION_P (newdecl
))
1148 /* If the old declaration was `static', or the new one isn't, then
1149 everything is OK. */
1150 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1153 /* It's OK to declare a builtin function as `static'. */
1154 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1155 && DECL_ARTIFICIAL (olddecl
))
1158 if (permerror (input_location
,
1159 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1160 inform (input_location
, "previous declaration of %q+D", olddecl
);
1163 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1164 function templates. If their exception specifications do not
1165 match, issue a diagnostic. */
1168 check_redeclaration_exception_specification (tree new_decl
,
1171 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1172 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1174 /* Two default specs are equivalent, don't force evaluation. */
1175 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1176 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1179 maybe_instantiate_noexcept (new_decl
);
1180 maybe_instantiate_noexcept (old_decl
);
1181 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1182 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1186 If any declaration of a function has an exception-specification,
1187 all declarations, including the definition and an explicit
1188 specialization, of that function shall have an
1189 exception-specification with the same set of type-ids. */
1190 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1191 && ! DECL_IS_BUILTIN (old_decl
)
1193 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1195 error ("declaration of %qF has a different exception specifier",
1197 error ("from previous declaration %q+F", old_decl
);
1201 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1202 Otherwise issue diagnostics. */
1205 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1207 old_decl
= STRIP_TEMPLATE (old_decl
);
1208 new_decl
= STRIP_TEMPLATE (new_decl
);
1209 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1210 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1212 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1213 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1215 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1217 if (DECL_BUILT_IN (old_decl
))
1219 /* Hide a built-in declaration. */
1220 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1221 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1224 /* 7.1.5 [dcl.constexpr]
1225 Note: An explicit specialization can differ from the template
1226 declaration with respect to the constexpr specifier. */
1227 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1228 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1231 error ("redeclaration %qD differs in %<constexpr%>", new_decl
);
1232 error ("from previous declaration %q+D", old_decl
);
1238 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1239 && lookup_attribute ("gnu_inline", \
1240 DECL_ATTRIBUTES (fn)))
1242 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1243 If the redeclaration is invalid, a diagnostic is issued, and the
1244 error_mark_node is returned. Otherwise, OLDDECL is returned.
1246 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1249 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1252 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1254 unsigned olddecl_uid
= DECL_UID (olddecl
);
1255 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1256 int new_defines_function
= 0;
1257 tree new_template_info
;
1259 if (newdecl
== olddecl
)
1262 types_match
= decls_match (newdecl
, olddecl
);
1264 /* If either the type of the new decl or the type of the old decl is an
1265 error_mark_node, then that implies that we have already issued an
1266 error (earlier) for some bogus type specification, and in that case,
1267 it is rather pointless to harass the user with yet more error message
1268 about the same declaration, so just pretend the types match here. */
1269 if (TREE_TYPE (newdecl
) == error_mark_node
1270 || TREE_TYPE (olddecl
) == error_mark_node
)
1271 return error_mark_node
;
1273 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1274 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1276 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1277 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1278 && check_raw_literal_operator (olddecl
))
1279 error ("literal operator template %q+D conflicts with"
1280 " raw literal operator %qD", newdecl
, olddecl
);
1281 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1282 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1283 && check_raw_literal_operator (newdecl
))
1284 error ("raw literal operator %q+D conflicts with"
1285 " literal operator template %qD", newdecl
, olddecl
);
1288 if (DECL_P (olddecl
)
1289 && TREE_CODE (newdecl
) == FUNCTION_DECL
1290 && TREE_CODE (olddecl
) == FUNCTION_DECL
1291 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1293 if (DECL_DECLARED_INLINE_P (newdecl
)
1294 && DECL_UNINLINABLE (newdecl
)
1295 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1296 /* Already warned elsewhere. */;
1297 else if (DECL_DECLARED_INLINE_P (olddecl
)
1298 && DECL_UNINLINABLE (olddecl
)
1299 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1300 /* Already warned. */;
1301 else if (DECL_DECLARED_INLINE_P (newdecl
)
1302 && DECL_UNINLINABLE (olddecl
)
1303 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1305 if (warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1307 inform (DECL_SOURCE_LOCATION (olddecl
),
1308 "previous declaration of %qD with attribute noinline",
1311 else if (DECL_DECLARED_INLINE_P (olddecl
)
1312 && DECL_UNINLINABLE (newdecl
)
1313 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1315 if (warning (OPT_Wattributes
, "function %q+D redeclared with "
1316 "attribute noinline", newdecl
))
1317 inform (DECL_SOURCE_LOCATION (olddecl
),
1318 "previous declaration of %qD was inline",
1323 /* Check for redeclaration and other discrepancies. */
1324 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1325 && DECL_ARTIFICIAL (olddecl
))
1327 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1328 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1330 /* Avoid warnings redeclaring built-ins which have not been
1331 explicitly declared. */
1332 if (DECL_ANTICIPATED (olddecl
))
1335 /* If you declare a built-in or predefined function name as static,
1336 the old definition is overridden, but optionally warn this was a
1337 bad choice of name. */
1338 if (! TREE_PUBLIC (newdecl
))
1340 warning (OPT_Wshadow
,
1341 DECL_BUILT_IN (olddecl
)
1342 ? G_("shadowing built-in function %q#D")
1343 : G_("shadowing library function %q#D"), olddecl
);
1344 /* Discard the old built-in function. */
1347 /* If the built-in is not ansi, then programs can override
1348 it even globally without an error. */
1349 else if (! DECL_BUILT_IN (olddecl
))
1350 warning (0, "library function %q#D redeclared as non-function %q#D",
1353 error ("declaration of %q#D conflicts with built-in "
1354 "declaration %q#D", newdecl
, olddecl
);
1357 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1359 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1360 error_at (DECL_SOURCE_LOCATION (newdecl
),
1361 "redeclaration of %<pragma omp declare reduction%>");
1362 inform (DECL_SOURCE_LOCATION (olddecl
),
1363 "previous %<pragma omp declare reduction%> declaration");
1364 return error_mark_node
;
1366 else if (!types_match
)
1368 /* Avoid warnings redeclaring built-ins which have not been
1369 explicitly declared. */
1370 if (DECL_ANTICIPATED (olddecl
))
1372 /* Deal with fileptr_type_node. FILE type is not known
1373 at the time we create the builtins. */
1376 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1377 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1379 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1382 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1384 tree t
= TREE_VALUE (t1
);
1387 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1388 == get_identifier ("FILE")
1389 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1391 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1393 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1394 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1395 types_match
= decls_match (newdecl
, olddecl
);
1397 return duplicate_decls (newdecl
, olddecl
,
1399 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1402 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1405 else if ((DECL_EXTERN_C_P (newdecl
)
1406 && DECL_EXTERN_C_P (olddecl
))
1407 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1408 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1410 /* A near match; override the builtin. */
1412 if (TREE_PUBLIC (newdecl
))
1413 warning (0, "new declaration %q#D ambiguates built-in "
1414 "declaration %q#D", newdecl
, olddecl
);
1416 warning (OPT_Wshadow
,
1417 DECL_BUILT_IN (olddecl
)
1418 ? G_("shadowing built-in function %q#D")
1419 : G_("shadowing library function %q#D"), olddecl
);
1422 /* Discard the old built-in function. */
1425 /* Replace the old RTL to avoid problems with inlining. */
1426 COPY_DECL_RTL (newdecl
, olddecl
);
1428 /* Even if the types match, prefer the new declarations type for
1429 built-ins which have not been explicitly declared, for
1430 exception lists, etc... */
1431 else if (DECL_IS_BUILTIN (olddecl
))
1433 tree type
= TREE_TYPE (newdecl
);
1434 tree attribs
= (*targetm
.merge_type_attributes
)
1435 (TREE_TYPE (olddecl
), type
);
1437 type
= cp_build_type_attribute_variant (type
, attribs
);
1438 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1441 /* If a function is explicitly declared "throw ()", propagate that to
1442 the corresponding builtin. */
1443 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1444 && DECL_ANTICIPATED (olddecl
)
1445 && TREE_NOTHROW (newdecl
)
1446 && !TREE_NOTHROW (olddecl
))
1448 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1449 tree tmpdecl
= builtin_decl_explicit (fncode
);
1450 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1451 TREE_NOTHROW (tmpdecl
) = 1;
1454 /* Whether or not the builtin can throw exceptions has no
1455 bearing on this declarator. */
1456 TREE_NOTHROW (olddecl
) = 0;
1458 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1460 /* If a builtin function is redeclared as `static', merge
1461 the declarations, but make the original one static. */
1462 DECL_THIS_STATIC (olddecl
) = 1;
1463 TREE_PUBLIC (olddecl
) = 0;
1465 /* Make the old declaration consistent with the new one so
1466 that all remnants of the builtin-ness of this function
1467 will be banished. */
1468 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1469 COPY_DECL_RTL (newdecl
, olddecl
);
1472 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1474 /* C++ Standard, 3.3, clause 4:
1475 "[Note: a namespace name or a class template name must be unique
1476 in its declarative region (7.3.2, clause 14). ]" */
1477 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1478 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1479 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1480 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1481 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1482 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1484 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1485 && TREE_CODE (newdecl
) != TYPE_DECL
)
1486 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1487 && TREE_CODE (olddecl
) != TYPE_DECL
))
1489 /* We do nothing special here, because C++ does such nasty
1490 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1491 get shadowed, and know that if we need to find a TYPE_DECL
1492 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1493 slot of the identifier. */
1497 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1498 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1499 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1500 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1504 error ("%q#D redeclared as different kind of symbol", newdecl
);
1505 if (TREE_CODE (olddecl
) == TREE_LIST
)
1506 olddecl
= TREE_VALUE (olddecl
);
1507 inform (DECL_SOURCE_LOCATION (olddecl
),
1508 "previous declaration %q#D", olddecl
);
1510 return error_mark_node
;
1512 else if (!types_match
)
1514 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1515 /* These are certainly not duplicate declarations; they're
1516 from different scopes. */
1519 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1521 /* The name of a class template may not be declared to refer to
1522 any other template, class, function, object, namespace, value,
1523 or type in the same scope. */
1524 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1525 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1527 error ("conflicting declaration of template %q#D", newdecl
);
1528 inform (DECL_SOURCE_LOCATION (olddecl
),
1529 "previous declaration %q#D", olddecl
);
1530 return error_mark_node
;
1532 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1533 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1534 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1535 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1536 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1537 DECL_TEMPLATE_PARMS (olddecl
))
1538 /* Template functions can be disambiguated by
1540 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1541 TREE_TYPE (TREE_TYPE (olddecl
))))
1543 error ("ambiguating new declaration %q#D", newdecl
);
1544 inform (DECL_SOURCE_LOCATION (olddecl
),
1545 "old declaration %q#D", olddecl
);
1549 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1551 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1553 error ("conflicting declaration of C function %q#D",
1555 inform (DECL_SOURCE_LOCATION (olddecl
),
1556 "previous declaration %q#D", olddecl
);
1559 /* For function versions, params and types match, but they
1560 are not ambiguous. */
1561 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1562 && !DECL_FUNCTION_VERSIONED (olddecl
))
1563 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1564 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1566 error ("ambiguating new declaration of %q#D", newdecl
);
1567 inform (DECL_SOURCE_LOCATION (olddecl
),
1568 "old declaration %q#D", olddecl
);
1569 return error_mark_node
;
1576 error ("conflicting declaration %q#D", newdecl
);
1577 inform (DECL_SOURCE_LOCATION (olddecl
),
1578 "previous declaration as %q#D", olddecl
);
1579 return error_mark_node
;
1582 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1583 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1584 && (!DECL_TEMPLATE_INFO (newdecl
)
1585 || (DECL_TI_TEMPLATE (newdecl
)
1586 != DECL_TI_TEMPLATE (olddecl
))))
1587 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1588 && (!DECL_TEMPLATE_INFO (olddecl
)
1589 || (DECL_TI_TEMPLATE (olddecl
)
1590 != DECL_TI_TEMPLATE (newdecl
))))))
1591 /* It's OK to have a template specialization and a non-template
1592 with the same type, or to have specializations of two
1593 different templates with the same type. Note that if one is a
1594 specialization, and the other is an instantiation of the same
1595 template, that we do not exit at this point. That situation
1596 can occur if we instantiate a template class, and then
1597 specialize one of its methods. This situation is valid, but
1598 the declarations must be merged in the usual way. */
1600 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1601 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1602 && !DECL_USE_TEMPLATE (newdecl
))
1603 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1604 && !DECL_USE_TEMPLATE (olddecl
))))
1605 /* One of the declarations is a template instantiation, and the
1606 other is not a template at all. That's OK. */
1608 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1610 /* In [namespace.alias] we have:
1612 In a declarative region, a namespace-alias-definition can be
1613 used to redefine a namespace-alias declared in that declarative
1614 region to refer only to the namespace to which it already
1617 Therefore, if we encounter a second alias directive for the same
1618 alias, we can just ignore the second directive. */
1619 if (DECL_NAMESPACE_ALIAS (newdecl
)
1620 && (DECL_NAMESPACE_ALIAS (newdecl
)
1621 == DECL_NAMESPACE_ALIAS (olddecl
)))
1623 /* [namespace.alias]
1625 A namespace-name or namespace-alias shall not be declared as
1626 the name of any other entity in the same declarative region.
1627 A namespace-name defined at global scope shall not be
1628 declared as the name of any other entity in any global scope
1630 error ("conflicting declaration of namespace %qD", newdecl
);
1631 inform (DECL_SOURCE_LOCATION (olddecl
),
1632 "previous declaration of namespace %qD here", olddecl
);
1633 return error_mark_node
;
1637 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1640 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1641 if (DECL_NAME (olddecl
) != NULL_TREE
)
1642 inform (input_location
,
1643 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1644 ? G_("%q+#D previously defined here")
1645 : G_("%q+#D previously declared here"), olddecl
);
1646 return error_mark_node
;
1648 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1649 && DECL_INITIAL (olddecl
) != NULL_TREE
1650 && !prototype_p (TREE_TYPE (olddecl
))
1651 && prototype_p (TREE_TYPE (newdecl
)))
1653 /* Prototype decl follows defn w/o prototype. */
1654 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1655 "prototype specified for %q#D", newdecl
))
1656 inform (DECL_SOURCE_LOCATION (olddecl
),
1657 "previous non-prototype definition here");
1659 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1660 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1663 If two declarations of the same function or object
1664 specify different linkage-specifications ..., the program
1665 is ill-formed.... Except for functions with C++ linkage,
1666 a function declaration without a linkage specification
1667 shall not precede the first linkage specification for
1668 that function. A function can be declared without a
1669 linkage specification after an explicit linkage
1670 specification has been seen; the linkage explicitly
1671 specified in the earlier declaration is not affected by
1672 such a function declaration.
1674 DR 563 raises the question why the restrictions on
1675 functions should not also apply to objects. Older
1676 versions of G++ silently ignore the linkage-specification
1684 which is clearly wrong. Therefore, we now treat objects
1686 if (current_lang_depth () == 0)
1688 /* There is no explicit linkage-specification, so we use
1689 the linkage from the previous declaration. */
1690 if (!DECL_LANG_SPECIFIC (newdecl
))
1691 retrofit_lang_decl (newdecl
);
1692 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1696 error ("conflicting declaration of %q#D with %qL linkage",
1697 newdecl
, DECL_LANGUAGE (newdecl
));
1698 inform (DECL_SOURCE_LOCATION (olddecl
),
1699 "previous declaration with %qL linkage",
1700 DECL_LANGUAGE (olddecl
));
1704 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1706 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1708 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1709 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1712 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1713 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1715 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
1716 && CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (newdecl
)))
1719 Default arguments for a member function of a class template
1720 shall be specified on the initial declaration of the member
1721 function within the class template. */
1722 for (; t2
&& t2
!= void_list_node
; t2
= TREE_CHAIN (t2
))
1723 if (TREE_PURPOSE (t2
))
1725 permerror (input_location
,
1726 "redeclaration of %q#D may not have default "
1727 "arguments", newdecl
);
1733 for (; t1
&& t1
!= void_list_node
;
1734 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1735 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1737 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1740 if (permerror (input_location
,
1741 "default argument given for parameter "
1742 "%d of %q#D", i
, newdecl
))
1743 inform (DECL_SOURCE_LOCATION (olddecl
),
1744 "previous specification in %q#D here",
1749 error ("default argument given for parameter %d "
1750 "of %q#D", i
, newdecl
);
1751 inform (DECL_SOURCE_LOCATION (olddecl
),
1752 "previous specification in %q#D here",
1760 /* Do not merge an implicit typedef with an explicit one. In:
1764 typedef class A A __attribute__ ((foo));
1766 the attribute should apply only to the typedef. */
1767 if (TREE_CODE (olddecl
) == TYPE_DECL
1768 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1769 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1772 /* If new decl is `static' and an `extern' was seen previously,
1774 warn_extern_redeclared_static (newdecl
, olddecl
);
1776 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1777 return error_mark_node
;
1779 /* We have committed to returning 1 at this point. */
1780 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1782 /* Now that functions must hold information normally held
1783 by field decls, there is extra work to do so that
1784 declaration information does not get destroyed during
1786 if (DECL_VINDEX (olddecl
))
1787 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1788 if (DECL_CONTEXT (olddecl
))
1789 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1790 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1791 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1792 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1793 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1794 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1795 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1796 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1797 SET_OVERLOADED_OPERATOR_CODE
1798 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1799 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1801 /* Optionally warn about more than one declaration for the same
1802 name, but don't warn about a function declaration followed by a
1804 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1805 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1806 /* Don't warn about extern decl followed by definition. */
1807 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1808 /* Don't warn about friends, let add_friend take care of it. */
1809 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1810 /* Don't warn about declaration followed by specialization. */
1811 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1812 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1814 if (warning (OPT_Wredundant_decls
,
1815 "redundant redeclaration of %qD in same scope",
1817 inform (DECL_SOURCE_LOCATION (olddecl
),
1818 "previous declaration of %qD", olddecl
);
1821 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1822 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1824 if (DECL_DELETED_FN (newdecl
))
1826 error ("deleted definition of %qD", newdecl
);
1827 inform (DECL_SOURCE_LOCATION (olddecl
),
1828 "previous declaration of %qD", olddecl
);
1830 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1834 /* Deal with C++: must preserve virtual function table size. */
1835 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1837 tree newtype
= TREE_TYPE (newdecl
);
1838 tree oldtype
= TREE_TYPE (olddecl
);
1840 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1841 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1842 CLASSTYPE_FRIEND_CLASSES (newtype
)
1843 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1845 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1848 /* Copy all the DECL_... slots specified in the new decl
1849 except for any that we copy here from the old type. */
1850 DECL_ATTRIBUTES (newdecl
)
1851 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1853 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1857 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1858 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1859 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1860 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1861 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1862 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1864 DECL_ATTRIBUTES (old_result
)
1865 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1867 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1869 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1870 && DECL_INITIAL (new_result
))
1872 if (DECL_INITIAL (old_result
))
1873 DECL_UNINLINABLE (old_result
) = 1;
1875 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1876 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1877 DECL_NOT_REALLY_EXTERN (old_result
)
1878 = DECL_NOT_REALLY_EXTERN (new_result
);
1879 DECL_INTERFACE_KNOWN (old_result
)
1880 = DECL_INTERFACE_KNOWN (new_result
);
1881 DECL_DECLARED_INLINE_P (old_result
)
1882 = DECL_DECLARED_INLINE_P (new_result
);
1883 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1884 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1889 DECL_DECLARED_INLINE_P (old_result
)
1890 |= DECL_DECLARED_INLINE_P (new_result
);
1891 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1892 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1893 check_redeclaration_exception_specification (newdecl
, olddecl
);
1897 /* If the new declaration is a definition, update the file and
1898 line information on the declaration, and also make
1899 the old declaration the same definition. */
1900 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1902 DECL_SOURCE_LOCATION (olddecl
)
1903 = DECL_SOURCE_LOCATION (old_result
)
1904 = DECL_SOURCE_LOCATION (newdecl
);
1905 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1906 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1909 DECL_ARGUMENTS (old_result
)
1910 = DECL_ARGUMENTS (new_result
);
1911 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1912 parm
= DECL_CHAIN (parm
))
1913 DECL_CONTEXT (parm
) = old_result
;
1922 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1923 check_redeclaration_exception_specification (newdecl
, olddecl
);
1925 /* Automatically handles default parameters. */
1926 tree oldtype
= TREE_TYPE (olddecl
);
1929 /* For typedefs use the old type, as the new type's DECL_NAME points
1930 at newdecl, which will be ggc_freed. */
1931 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1934 /* Merge the data types specified in the two decls. */
1935 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1937 if (VAR_P (newdecl
))
1939 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1940 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1941 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1942 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1943 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1944 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1946 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1947 if (DECL_LANG_SPECIFIC (olddecl
)
1948 && CP_DECL_THREADPRIVATE_P (olddecl
))
1950 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1951 if (!DECL_LANG_SPECIFIC (newdecl
))
1952 retrofit_lang_decl (newdecl
);
1954 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1955 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1959 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1961 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1962 check_default_args (newdecl
);
1964 /* Lay the type out, unless already done. */
1965 if (! same_type_p (newtype
, oldtype
)
1966 && TREE_TYPE (newdecl
) != error_mark_node
1967 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1968 layout_type (TREE_TYPE (newdecl
));
1970 if ((VAR_P (newdecl
)
1971 || TREE_CODE (newdecl
) == PARM_DECL
1972 || TREE_CODE (newdecl
) == RESULT_DECL
1973 || TREE_CODE (newdecl
) == FIELD_DECL
1974 || TREE_CODE (newdecl
) == TYPE_DECL
)
1975 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1976 layout_decl (newdecl
, 0);
1978 /* Merge the type qualifiers. */
1979 if (TREE_READONLY (newdecl
))
1980 TREE_READONLY (olddecl
) = 1;
1981 if (TREE_THIS_VOLATILE (newdecl
))
1982 TREE_THIS_VOLATILE (olddecl
) = 1;
1983 if (TREE_NOTHROW (newdecl
))
1984 TREE_NOTHROW (olddecl
) = 1;
1986 /* Merge deprecatedness. */
1987 if (TREE_DEPRECATED (newdecl
))
1988 TREE_DEPRECATED (olddecl
) = 1;
1990 /* Preserve function specific target and optimization options */
1991 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1993 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
1994 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
1995 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
1996 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
1998 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
1999 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2000 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2001 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2004 /* Merge the initialization information. */
2005 if (DECL_INITIAL (newdecl
) == NULL_TREE
2006 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2008 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2009 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2010 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2012 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2013 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2017 /* Merge the section attribute.
2018 We want to issue an error if the sections conflict but that must be
2019 done later in decl_attributes since we are called before attributes
2021 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
2022 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
2024 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2026 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2027 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2028 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2029 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2030 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2031 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2032 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2033 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2034 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2035 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2036 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2037 /* Keep the old RTL. */
2038 COPY_DECL_RTL (olddecl
, newdecl
);
2040 else if (VAR_P (newdecl
)
2041 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2043 /* Keep the old RTL. We cannot keep the old RTL if the old
2044 declaration was for an incomplete object and the new
2045 declaration is not since many attributes of the RTL will
2047 COPY_DECL_RTL (olddecl
, newdecl
);
2050 /* If cannot merge, then use the new type and qualifiers,
2051 and don't preserve the old rtl. */
2054 /* Clean out any memory we had of the old declaration. */
2055 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2057 TREE_VALUE (oldstatic
) = error_mark_node
;
2059 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2060 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2061 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2062 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2065 /* Merge the storage class information. */
2066 merge_weak (newdecl
, olddecl
);
2068 if (DECL_ONE_ONLY (olddecl
))
2069 DECL_COMDAT_GROUP (newdecl
) = DECL_COMDAT_GROUP (olddecl
);
2071 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2072 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2073 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2074 if (! DECL_EXTERNAL (olddecl
))
2075 DECL_EXTERNAL (newdecl
) = 0;
2077 new_template_info
= NULL_TREE
;
2078 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2080 bool new_redefines_gnu_inline
= false;
2082 if (new_defines_function
2083 && ((DECL_INTERFACE_KNOWN (olddecl
)
2084 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2085 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2086 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2087 == FUNCTION_DECL
))))
2091 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2092 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2094 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2097 if (!new_redefines_gnu_inline
)
2099 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2100 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2101 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2103 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2104 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2105 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2107 /* If the OLDDECL is an instantiation and/or specialization,
2108 then the NEWDECL must be too. But, it may not yet be marked
2109 as such if the caller has created NEWDECL, but has not yet
2110 figured out that it is a redeclaration. */
2111 if (!DECL_USE_TEMPLATE (newdecl
))
2112 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2114 /* Don't really know how much of the language-specific
2115 values we should copy from old to new. */
2116 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2117 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2118 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2119 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2121 if (LANG_DECL_HAS_MIN (newdecl
))
2123 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2124 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2125 if (DECL_TEMPLATE_INFO (newdecl
))
2126 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2127 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2129 /* Only functions have these fields. */
2130 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2132 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2133 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2134 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2135 && DECL_HIDDEN_FRIEND_P (olddecl
)
2136 && newdecl_is_friend
);
2137 DECL_BEFRIENDING_CLASSES (newdecl
)
2138 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2139 DECL_BEFRIENDING_CLASSES (olddecl
));
2140 /* DECL_THUNKS is only valid for virtual functions,
2141 otherwise it is a DECL_FRIEND_CONTEXT. */
2142 if (DECL_VIRTUAL_P (newdecl
))
2143 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2145 /* Only variables have this field. */
2146 else if (VAR_P (newdecl
)
2147 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2148 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2151 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2155 /* Merge parameter attributes. */
2156 tree oldarg
, newarg
;
2157 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2158 newarg
= DECL_ARGUMENTS(newdecl
);
2160 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2161 DECL_ATTRIBUTES (newarg
)
2162 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2163 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2166 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2167 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2169 /* If newdecl is not a specialization, then it is not a
2170 template-related function at all. And that means that we
2171 should have exited above, returning 0. */
2172 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2174 if (DECL_ODR_USED (olddecl
))
2175 /* From [temp.expl.spec]:
2177 If a template, a member template or the member of a class
2178 template is explicitly specialized then that
2179 specialization shall be declared before the first use of
2180 that specialization that would cause an implicit
2181 instantiation to take place, in every translation unit in
2182 which such a use occurs. */
2183 error ("explicit specialization of %qD after first use",
2186 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2188 /* Don't propagate visibility from the template to the
2189 specialization here. We'll do that in determine_visibility if
2191 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2193 /* [temp.expl.spec/14] We don't inline explicit specialization
2194 just because the primary template says so. */
2196 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2197 the always_inline attribute. */
2198 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2199 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2201 if (DECL_DECLARED_INLINE_P (newdecl
))
2202 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2204 DECL_ATTRIBUTES (newdecl
)
2205 = remove_attribute ("always_inline",
2206 DECL_ATTRIBUTES (newdecl
));
2209 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2211 /* Never inline re-defined extern inline functions.
2212 FIXME: this could be better handled by keeping both
2213 function as separate declarations. */
2214 DECL_UNINLINABLE (newdecl
) = 1;
2218 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2219 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2221 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2223 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2224 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2226 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2227 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2228 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2229 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2232 /* Preserve abstractness on cloned [cd]tors. */
2233 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
2235 /* Update newdecl's parms to point at olddecl. */
2236 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2237 parm
= DECL_CHAIN (parm
))
2238 DECL_CONTEXT (parm
) = olddecl
;
2242 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2243 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2244 COPY_DECL_RTL (newdecl
, olddecl
);
2246 if (! types_match
|| new_defines_function
)
2248 /* These need to be copied so that the names are available.
2249 Note that if the types do match, we'll preserve inline
2250 info and other bits, but if not, we won't. */
2251 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2252 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2254 /* If redeclaring a builtin function, it stays built in
2255 if newdecl is a gnu_inline definition, or if newdecl is just
2257 if (DECL_BUILT_IN (olddecl
)
2258 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2260 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2261 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2262 /* If we're keeping the built-in definition, keep the rtl,
2263 regardless of declaration matches. */
2264 COPY_DECL_RTL (olddecl
, newdecl
);
2265 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2267 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2270 /* If a compatible prototype of these builtin functions
2271 is seen, assume the runtime implements it with the
2272 expected semantics. */
2273 case BUILT_IN_STPCPY
:
2274 if (builtin_decl_explicit_p (fncode
))
2275 set_builtin_decl_implicit_p (fncode
, true);
2282 if (new_defines_function
)
2283 /* If defining a function declared with other language
2284 linkage, use the previously declared language linkage. */
2285 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2286 else if (types_match
)
2288 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2289 /* Don't clear out the arguments if we're just redeclaring a
2291 if (DECL_ARGUMENTS (olddecl
))
2292 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2295 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2296 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2298 /* Now preserve various other info from the definition. */
2299 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2300 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2301 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2302 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2304 /* Warn about conflicting visibility specifications. */
2305 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2306 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2307 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2309 warning_at (input_location
, OPT_Wattributes
,
2310 "%q+D: visibility attribute ignored because it", newdecl
);
2311 warning_at (DECL_SOURCE_LOCATION (olddecl
), OPT_Wattributes
,
2312 "conflicts with previous declaration here");
2314 /* Choose the declaration which specified visibility. */
2315 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2317 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2318 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2320 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2321 so keep this behavior. */
2322 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2324 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2325 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2327 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2328 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2330 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2331 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2333 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2334 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2335 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2337 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2338 with that from NEWDECL below. */
2339 if (DECL_LANG_SPECIFIC (olddecl
))
2341 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2342 != DECL_LANG_SPECIFIC (newdecl
));
2343 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2346 /* Merge the USED information. */
2347 if (TREE_USED (olddecl
))
2348 TREE_USED (newdecl
) = 1;
2349 else if (TREE_USED (newdecl
))
2350 TREE_USED (olddecl
) = 1;
2351 if (VAR_P (newdecl
))
2353 if (DECL_READ_P (olddecl
))
2354 DECL_READ_P (newdecl
) = 1;
2355 else if (DECL_READ_P (newdecl
))
2356 DECL_READ_P (olddecl
) = 1;
2358 if (DECL_PRESERVE_P (olddecl
))
2359 DECL_PRESERVE_P (newdecl
) = 1;
2360 else if (DECL_PRESERVE_P (newdecl
))
2361 DECL_PRESERVE_P (olddecl
) = 1;
2363 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2364 to olddecl and deleted. */
2365 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2366 && DECL_FUNCTION_VERSIONED (olddecl
))
2368 /* Set the flag for newdecl so that it gets copied to olddecl. */
2369 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2370 /* newdecl will be purged after copying to olddecl and is no longer
2372 delete_function_version (newdecl
);
2375 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2379 function_size
= sizeof (struct tree_decl_common
);
2381 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2382 (char *) newdecl
+ sizeof (struct tree_common
),
2383 function_size
- sizeof (struct tree_common
));
2385 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2386 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2387 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2388 if (new_template_info
)
2389 /* If newdecl is a template instantiation, it is possible that
2390 the following sequence of events has occurred:
2392 o A friend function was declared in a class template. The
2393 class template was instantiated.
2395 o The instantiation of the friend declaration was
2396 recorded on the instantiation list, and is newdecl.
2398 o Later, however, instantiate_class_template called pushdecl
2399 on the newdecl to perform name injection. But, pushdecl in
2400 turn called duplicate_decls when it discovered that another
2401 declaration of a global function with the same name already
2404 o Here, in duplicate_decls, we decided to clobber newdecl.
2406 If we're going to do that, we'd better make sure that
2407 olddecl, and not newdecl, is on the list of
2408 instantiations so that if we try to do the instantiation
2409 again we won't get the clobbered declaration. */
2410 reregister_specialization (newdecl
,
2416 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2417 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2418 (char *) newdecl
+ sizeof (struct tree_common
),
2419 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2420 switch (TREE_CODE (olddecl
))
2430 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2431 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2432 size
- sizeof (struct tree_decl_common
)
2433 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2437 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2438 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2439 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2440 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2444 DECL_UID (olddecl
) = olddecl_uid
;
2446 DECL_FRIEND_P (olddecl
) = 1;
2449 DECL_ANTICIPATED (olddecl
) = 1;
2450 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2453 /* NEWDECL contains the merged attribute lists.
2454 Update OLDDECL to be the same. */
2455 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2457 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2458 so that encode_section_info has a chance to look at the new decl
2459 flags and attributes. */
2460 if (DECL_RTL_SET_P (olddecl
)
2461 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2463 && TREE_STATIC (olddecl
))))
2464 make_decl_rtl (olddecl
);
2466 /* The NEWDECL will no longer be needed. Because every out-of-class
2467 declaration of a member results in a call to duplicate_decls,
2468 freeing these nodes represents in a significant savings. */
2474 /* Return zero if the declaration NEWDECL is valid
2475 when the declaration OLDDECL (assumed to be for the same name)
2476 has already been seen.
2477 Otherwise return an error message format string with a %s
2478 where the identifier should go. */
2481 redeclaration_error_message (tree newdecl
, tree olddecl
)
2483 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2485 /* Because C++ can put things into name space for free,
2486 constructs like "typedef struct foo { ... } foo"
2487 would look like an erroneous redeclaration. */
2488 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2491 return G_("redefinition of %q#D");
2493 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2495 /* If this is a pure function, its olddecl will actually be
2496 the original initialization to `0' (which we force to call
2497 abort()). Don't complain about redefinition in this case. */
2498 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2499 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2502 /* If both functions come from different namespaces, this is not
2503 a redeclaration - this is a conflict with a used function. */
2504 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2505 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2506 && ! decls_match (olddecl
, newdecl
))
2507 return G_("%qD conflicts with used function");
2509 /* We'll complain about linkage mismatches in
2510 warn_extern_redeclared_static. */
2512 /* Defining the same name twice is no good. */
2513 if (DECL_INITIAL (olddecl
) != NULL_TREE
2514 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2516 if (DECL_NAME (olddecl
) == NULL_TREE
)
2517 return G_("%q#D not declared in class");
2518 else if (!GNU_INLINE_P (olddecl
)
2519 || GNU_INLINE_P (newdecl
))
2520 return G_("redefinition of %q#D");
2523 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2525 bool olda
= GNU_INLINE_P (olddecl
);
2526 bool newa
= GNU_INLINE_P (newdecl
);
2531 return G_("%q+D redeclared inline with "
2532 "%<gnu_inline%> attribute");
2534 return G_("%q+D redeclared inline without "
2535 "%<gnu_inline%> attribute");
2539 check_abi_tag_redeclaration
2540 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2541 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2545 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2549 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2551 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2552 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2553 return G_("redefinition of %q#D");
2557 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2558 || (DECL_TEMPLATE_RESULT (newdecl
)
2559 == DECL_TEMPLATE_RESULT (olddecl
)))
2562 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2563 if (DECL_TEMPLATE_INFO (nt
))
2564 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2565 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2566 if (DECL_TEMPLATE_INFO (ot
))
2567 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2568 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2569 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2570 return G_("redefinition of %q#D");
2572 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2574 bool olda
= GNU_INLINE_P (ot
);
2575 bool newa
= GNU_INLINE_P (nt
);
2580 return G_("%q+D redeclared inline with "
2581 "%<gnu_inline%> attribute");
2583 return G_("%q+D redeclared inline without "
2584 "%<gnu_inline%> attribute");
2588 /* Core issue #226 (C++0x):
2590 If a friend function template declaration specifies a
2591 default template-argument, that declaration shall be a
2592 definition and shall be the only declaration of the
2593 function template in the translation unit. */
2594 if ((cxx_dialect
!= cxx98
)
2595 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2596 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2597 /*is_primary=*/true,
2598 /*is_partial=*/false,
2599 /*is_friend_decl=*/2))
2600 return G_("redeclaration of friend %q#D "
2601 "may not have default template arguments");
2605 else if (VAR_P (newdecl
)
2606 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2607 && (! DECL_LANG_SPECIFIC (olddecl
)
2608 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2609 || DECL_THREAD_LOCAL_P (newdecl
)))
2611 /* Only variables can be thread-local, and all declarations must
2612 agree on this property. */
2613 if (DECL_THREAD_LOCAL_P (newdecl
))
2614 return G_("thread-local declaration of %q#D follows "
2615 "non-thread-local declaration");
2617 return G_("non-thread-local declaration of %q#D follows "
2618 "thread-local declaration");
2620 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2622 /* The objects have been declared at namespace scope. If either
2623 is a member of an anonymous union, then this is an invalid
2624 redeclaration. For example:
2630 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2631 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2632 return G_("redeclaration of %q#D");
2633 /* If at least one declaration is a reference, there is no
2634 conflict. For example:
2640 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2642 /* Reject two definitions. */
2643 return G_("redefinition of %q#D");
2647 /* Objects declared with block scope: */
2648 /* Reject two definitions, and reject a definition
2649 together with an external reference. */
2650 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2651 return G_("redeclaration of %q#D");
2656 /* Hash and equality functions for the named_label table. */
2659 named_label_entry_hash (const void *data
)
2661 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2662 return DECL_UID (ent
->label_decl
);
2666 named_label_entry_eq (const void *a
, const void *b
)
2668 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2669 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2670 return ent_a
->label_decl
== ent_b
->label_decl
;
2673 /* Create a new label, named ID. */
2676 make_label_decl (tree id
, int local_p
)
2678 struct named_label_entry
*ent
;
2682 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2684 DECL_CONTEXT (decl
) = current_function_decl
;
2685 DECL_MODE (decl
) = VOIDmode
;
2686 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2688 /* Say where one reference is to the label, for the sake of the
2689 error if it is not defined. */
2690 DECL_SOURCE_LOCATION (decl
) = input_location
;
2692 /* Record the fact that this identifier is bound to this label. */
2693 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2695 /* Create the label htab for the function on demand. */
2697 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2698 named_label_entry_eq
, NULL
);
2700 /* Record this label on the list of labels used in this function.
2701 We do this before calling make_label_decl so that we get the
2702 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2703 ent
= ggc_cleared_alloc
<named_label_entry
> ();
2704 ent
->label_decl
= decl
;
2706 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2707 gcc_assert (*slot
== NULL
);
2713 /* Look for a label named ID in the current function. If one cannot
2714 be found, create one. (We keep track of used, but undefined,
2715 labels, and complain about them at the end of a function.) */
2718 lookup_label_1 (tree id
)
2722 /* You can't use labels at global scope. */
2723 if (current_function_decl
== NULL_TREE
)
2725 error ("label %qE referenced outside of any function", id
);
2729 /* See if we've already got this label. */
2730 decl
= IDENTIFIER_LABEL_VALUE (id
);
2731 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2734 decl
= make_label_decl (id
, /*local_p=*/0);
2738 /* Wrapper for lookup_label_1. */
2741 lookup_label (tree id
)
2744 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2745 ret
= lookup_label_1 (id
);
2746 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2750 /* Declare a local label named ID. */
2753 declare_local_label (tree id
)
2756 cp_label_binding bind
;
2758 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2759 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2760 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2762 decl
= make_label_decl (id
, /*local_p=*/1);
2764 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2769 /* Returns nonzero if it is ill-formed to jump past the declaration of
2770 DECL. Returns 2 if it's also a real problem. */
2773 decl_jump_unsafe (tree decl
)
2775 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2776 with automatic storage duration is not in scope to a point where it is
2777 in scope is ill-formed unless the variable has scalar type, class type
2778 with a trivial default constructor and a trivial destructor, a
2779 cv-qualified version of one of these types, or an array of one of the
2780 preceding types and is declared without an initializer (8.5). */
2781 tree type
= TREE_TYPE (decl
);
2783 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2784 || type
== error_mark_node
)
2787 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
2788 || variably_modified_type_p (type
, NULL_TREE
))
2791 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2797 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2800 identify_goto (tree decl
, const location_t
*locus
)
2803 permerror (input_location
, "jump to label %qD", decl
);
2805 permerror (input_location
, "jump to case label");
2807 permerror (*locus
, " from here");
2810 /* Check that a single previously seen jump to a newly defined label
2811 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2812 the jump context; NAMES are the names in scope in LEVEL at the jump
2813 context; LOCUS is the source position of the jump or 0. Returns
2814 true if all is well. */
2817 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2818 bool exited_omp
, const location_t
*locus
)
2820 cp_binding_level
*b
;
2821 bool identified
= false, saw_eh
= false, saw_omp
= false;
2825 identify_goto (decl
, locus
);
2826 error (" exits OpenMP structured block");
2827 identified
= saw_omp
= true;
2830 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2832 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2834 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2835 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2836 : TREE_CHAIN (new_decls
)))
2838 int problem
= decl_jump_unsafe (new_decls
);
2844 identify_goto (decl
, locus
);
2848 error (" crosses initialization of %q+#D", new_decls
);
2850 permerror (input_location
, " enters scope of %q+#D which has "
2851 "non-trivial destructor", new_decls
);
2856 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2860 identify_goto (decl
, locus
);
2863 if (b
->kind
== sk_try
)
2864 error (" enters try block");
2866 error (" enters catch block");
2869 if (b
->kind
== sk_omp
&& !saw_omp
)
2873 identify_goto (decl
, locus
);
2876 error (" enters OpenMP structured block");
2885 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2887 check_previous_goto_1 (decl
, use
->binding_level
,
2888 use
->names_in_scope
, use
->in_omp_scope
,
2889 &use
->o_goto_locus
);
2893 check_switch_goto (cp_binding_level
* level
)
2895 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2898 /* Check that a new jump to a label DECL is OK. Called by
2899 finish_goto_stmt. */
2902 check_goto (tree decl
)
2904 struct named_label_entry
*ent
, dummy
;
2905 bool saw_catch
= false, identified
= false;
2909 /* We can't know where a computed goto is jumping.
2910 So we assume that it's OK. */
2911 if (TREE_CODE (decl
) != LABEL_DECL
)
2914 /* We didn't record any information about this label when we created it,
2915 and there's not much point since it's trivial to analyze as a return. */
2916 if (decl
== cdtor_label
)
2919 dummy
.label_decl
= decl
;
2920 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2921 gcc_assert (ent
!= NULL
);
2923 /* If the label hasn't been defined yet, defer checking. */
2924 if (! DECL_INITIAL (decl
))
2926 struct named_label_use_entry
*new_use
;
2928 /* Don't bother creating another use if the last goto had the
2929 same data, and will therefore create the same set of errors. */
2931 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2934 new_use
= ggc_alloc
<named_label_use_entry
> ();
2935 new_use
->binding_level
= current_binding_level
;
2936 new_use
->names_in_scope
= current_binding_level
->names
;
2937 new_use
->o_goto_locus
= input_location
;
2938 new_use
->in_omp_scope
= false;
2940 new_use
->next
= ent
->uses
;
2941 ent
->uses
= new_use
;
2945 if (ent
->in_try_scope
|| ent
->in_catch_scope
2946 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
2948 permerror (input_location
, "jump to label %q+D", decl
);
2949 permerror (input_location
, " from here");
2953 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
2955 int u
= decl_jump_unsafe (bad
);
2957 if (u
> 1 && DECL_ARTIFICIAL (bad
))
2959 /* Can't skip init of __exception_info. */
2960 error_at (DECL_SOURCE_LOCATION (bad
), " enters catch block");
2964 error (" skips initialization of %q+#D", bad
);
2966 permerror (input_location
, " enters scope of %q+#D which has "
2967 "non-trivial destructor", bad
);
2970 if (ent
->in_try_scope
)
2971 error (" enters try block");
2972 else if (ent
->in_catch_scope
&& !saw_catch
)
2973 error (" enters catch block");
2975 if (ent
->in_omp_scope
)
2976 error (" enters OpenMP structured block");
2977 else if (flag_openmp
)
2979 cp_binding_level
*b
;
2980 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2982 if (b
== ent
->binding_level
)
2984 if (b
->kind
== sk_omp
)
2988 permerror (input_location
, "jump to label %q+D", decl
);
2989 permerror (input_location
, " from here");
2992 error (" exits OpenMP structured block");
2999 /* Check that a return is ok wrt OpenMP structured blocks.
3000 Called by finish_return_stmt. Returns true if all is well. */
3003 check_omp_return (void)
3005 cp_binding_level
*b
;
3006 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3007 if (b
->kind
== sk_omp
)
3009 error ("invalid exit from OpenMP structured block");
3012 else if (b
->kind
== sk_function_parms
)
3017 /* Define a label, specifying the location in the source file.
3018 Return the LABEL_DECL node for the label. */
3021 define_label_1 (location_t location
, tree name
)
3023 struct named_label_entry
*ent
, dummy
;
3024 cp_binding_level
*p
;
3027 decl
= lookup_label (name
);
3029 dummy
.label_decl
= decl
;
3030 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
3031 gcc_assert (ent
!= NULL
);
3033 /* After labels, make any new cleanups in the function go into their
3034 own new (temporary) binding contour. */
3035 for (p
= current_binding_level
;
3036 p
->kind
!= sk_function_parms
;
3038 p
->more_cleanups_ok
= 0;
3040 if (name
== get_identifier ("wchar_t"))
3041 permerror (input_location
, "label named wchar_t");
3043 if (DECL_INITIAL (decl
) != NULL_TREE
)
3045 error ("duplicate label %qD", decl
);
3046 return error_mark_node
;
3050 struct named_label_use_entry
*use
;
3052 /* Mark label as having been defined. */
3053 DECL_INITIAL (decl
) = error_mark_node
;
3054 /* Say where in the source. */
3055 DECL_SOURCE_LOCATION (decl
) = location
;
3057 ent
->binding_level
= current_binding_level
;
3058 ent
->names_in_scope
= current_binding_level
->names
;
3060 for (use
= ent
->uses
; use
; use
= use
->next
)
3061 check_previous_goto (decl
, use
);
3068 /* Wrapper for define_label_1. */
3071 define_label (location_t location
, tree name
)
3074 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3075 ret
= define_label_1 (location
, name
);
3076 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3083 cp_binding_level
*level
;
3084 struct cp_switch
*next
;
3085 /* The SWITCH_STMT being built. */
3087 /* A splay-tree mapping the low element of a case range to the high
3088 element, or NULL_TREE if there is no high element. Used to
3089 determine whether or not a new case label duplicates an old case
3090 label. We need a tree, rather than simply a hash table, because
3091 of the GNU case range extension. */
3095 /* A stack of the currently active switch statements. The innermost
3096 switch statement is on the top of the stack. There is no need to
3097 mark the stack for garbage collection because it is only active
3098 during the processing of the body of a function, and we never
3099 collect at that point. */
3101 static struct cp_switch
*switch_stack
;
3103 /* Called right after a switch-statement condition is parsed.
3104 SWITCH_STMT is the switch statement being parsed. */
3107 push_switch (tree switch_stmt
)
3109 struct cp_switch
*p
= XNEW (struct cp_switch
);
3110 p
->level
= current_binding_level
;
3111 p
->next
= switch_stack
;
3112 p
->switch_stmt
= switch_stmt
;
3113 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3120 struct cp_switch
*cs
= switch_stack
;
3121 location_t switch_location
;
3123 /* Emit warnings as needed. */
3124 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3125 if (!processing_template_decl
)
3126 c_do_switch_warnings (cs
->cases
, switch_location
,
3127 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3128 SWITCH_STMT_COND (cs
->switch_stmt
));
3130 splay_tree_delete (cs
->cases
);
3131 switch_stack
= switch_stack
->next
;
3135 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3136 condition. Note that if TYPE and VALUE are already integral we don't
3137 really do the conversion because the language-independent
3138 warning/optimization code will work better that way. */
3141 case_conversion (tree type
, tree value
)
3143 if (value
== NULL_TREE
)
3146 if (cxx_dialect
>= cxx11
3147 && (SCOPED_ENUM_P (type
)
3148 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3150 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3151 type
= type_promotes_to (type
);
3152 value
= (perform_implicit_conversion_flags
3153 (type
, value
, tf_warning_or_error
,
3154 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3156 return cxx_constant_value (value
);
3159 /* Note that we've seen a definition of a case label, and complain if this
3160 is a bad place for one. */
3163 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3166 cp_binding_level
*p
;
3169 if (processing_template_decl
)
3173 /* For templates, just add the case label; we'll do semantic
3174 analysis at instantiation-time. */
3175 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3176 return add_stmt (build_case_label (low_value
, high_value
, label
));
3179 /* Find the condition on which this switch statement depends. */
3180 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3181 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3182 cond
= TREE_VALUE (cond
);
3184 if (!check_switch_goto (switch_stack
->level
))
3185 return error_mark_node
;
3187 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3189 low_value
= case_conversion (type
, low_value
);
3190 high_value
= case_conversion (type
, high_value
);
3192 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3193 low_value
, high_value
);
3195 /* After labels, make any new cleanups in the function go into their
3196 own new (temporary) binding contour. */
3197 for (p
= current_binding_level
;
3198 p
->kind
!= sk_function_parms
;
3200 p
->more_cleanups_ok
= 0;
3205 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3208 typename_hash (const void* k
)
3211 const_tree
const t
= (const_tree
) k
;
3213 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3214 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3219 typedef struct typename_info
{
3227 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3228 really of type `typename_info*' */
3231 typename_compare (const void * k1
, const void * k2
)
3233 const_tree
const t1
= (const_tree
) k1
;
3234 const typename_info
*const t2
= (const typename_info
*) k2
;
3236 return (TYPE_IDENTIFIER (t1
) == t2
->name
3237 && TYPE_CONTEXT (t1
) == t2
->scope
3238 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3239 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3240 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3243 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3244 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3246 Returns the new TYPENAME_TYPE. */
3248 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
3251 build_typename_type (tree context
, tree name
, tree fullname
,
3252 enum tag_types tag_type
)
3260 if (typename_htab
== NULL
)
3261 typename_htab
= htab_create_ggc (61, &typename_hash
,
3262 &typename_compare
, NULL
);
3264 ti
.scope
= FROB_CONTEXT (context
);
3266 ti
.template_id
= fullname
;
3267 ti
.enum_p
= tag_type
== enum_type
;
3268 ti
.class_p
= (tag_type
== class_type
3269 || tag_type
== record_type
3270 || tag_type
== union_type
);
3271 hash
= (htab_hash_pointer (ti
.scope
)
3272 ^ htab_hash_pointer (ti
.name
));
3274 /* See if we already have this type. */
3275 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
3280 /* Build the TYPENAME_TYPE. */
3281 t
= cxx_make_type (TYPENAME_TYPE
);
3282 TYPE_CONTEXT (t
) = ti
.scope
;
3283 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3284 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3285 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3287 /* Build the corresponding TYPE_DECL. */
3288 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3289 TYPE_NAME (TREE_TYPE (d
)) = d
;
3290 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3291 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3292 DECL_ARTIFICIAL (d
) = 1;
3294 /* Store it in the hash table. */
3297 /* TYPENAME_TYPEs must always be compared structurally, because
3298 they may or may not resolve down to another type depending on
3299 the currently open classes. */
3300 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3306 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3307 provided to name the type. Returns an appropriate type, unless an
3308 error occurs, in which case error_mark_node is returned. If we
3309 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3310 return that, rather than the _TYPE it corresponds to, in other
3311 cases we look through the type decl. If TF_ERROR is set, complain
3312 about errors, otherwise be quiet. */
3315 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3316 tsubst_flags_t complain
)
3322 if (name
== error_mark_node
3323 || context
== NULL_TREE
3324 || context
== error_mark_node
)
3325 return error_mark_node
;
3329 if (!(TYPE_LANG_SPECIFIC (name
)
3330 && (CLASSTYPE_IS_TEMPLATE (name
)
3331 || CLASSTYPE_USE_TEMPLATE (name
))))
3332 name
= TYPE_IDENTIFIER (name
);
3334 /* Create a TEMPLATE_ID_EXPR for the type. */
3335 name
= build_nt (TEMPLATE_ID_EXPR
,
3336 CLASSTYPE_TI_TEMPLATE (name
),
3337 CLASSTYPE_TI_ARGS (name
));
3339 else if (TREE_CODE (name
) == TYPE_DECL
)
3340 name
= DECL_NAME (name
);
3344 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3346 name
= TREE_OPERAND (name
, 0);
3347 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3348 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3349 else if (TREE_CODE (name
) == OVERLOAD
)
3351 if (complain
& tf_error
)
3352 error ("%qD is not a type", name
);
3353 return error_mark_node
;
3356 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3358 if (complain
& tf_error
)
3359 error ("%qD used without template parameters", name
);
3360 return error_mark_node
;
3362 gcc_assert (identifier_p (name
));
3363 gcc_assert (TYPE_P (context
));
3365 if (!MAYBE_CLASS_TYPE_P (context
))
3367 if (complain
& tf_error
)
3368 error ("%q#T is not a class", context
);
3369 return error_mark_node
;
3372 /* When the CONTEXT is a dependent type, NAME could refer to a
3373 dependent base class of CONTEXT. But look inside it anyway
3374 if CONTEXT is a currently open scope, in case it refers to a
3375 member of the current instantiation or a non-dependent base;
3376 lookup will stop when we hit a dependent base. */
3377 if (!dependent_scope_p (context
))
3378 /* We should only set WANT_TYPE when we're a nested typename type.
3379 Then we can give better diagnostics if we find a non-type. */
3380 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3384 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3385 return build_typename_type (context
, name
, fullname
, tag_type
);
3387 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3391 if (complain
& tf_error
)
3392 error (want_template
? G_("no class template named %q#T in %q#T")
3393 : G_("no type named %q#T in %q#T"), name
, context
);
3394 return error_mark_node
;
3397 /* Pull out the template from an injected-class-name (or multiple). */
3399 t
= maybe_get_template_decl_from_type_decl (t
);
3401 if (TREE_CODE (t
) == TREE_LIST
)
3403 if (complain
& tf_error
)
3405 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3406 print_candidates (t
);
3408 return error_mark_node
;
3411 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3413 if (complain
& tf_error
)
3414 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3416 return error_mark_node
;
3418 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3420 if (complain
& tf_error
)
3421 error ("%<typename %T::%D%> names %q#T, which is not a type",
3423 return error_mark_node
;
3426 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3427 return error_mark_node
;
3429 /* If we are currently parsing a template and if T is a typedef accessed
3430 through CONTEXT then we need to remember and check access of T at
3431 template instantiation time. */
3432 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3435 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3437 /*entering_scope=*/0,
3438 tf_warning_or_error
| tf_user
);
3440 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3443 maybe_record_typedef_use (t
);
3448 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3449 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3450 in which case error_mark_node is returned.
3452 If PARM_LIST is non-NULL, also make sure that the template parameter
3453 list of TEMPLATE_DECL matches.
3455 If COMPLAIN zero, don't complain about any errors that occur. */
3458 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3459 tsubst_flags_t complain
)
3465 name
= TYPE_IDENTIFIER (name
);
3466 else if (DECL_P (name
))
3467 name
= DECL_NAME (name
);
3468 gcc_assert (identifier_p (name
));
3470 if (!dependent_type_p (context
)
3471 || currently_open_class (context
))
3473 tree tmpl
= NULL_TREE
;
3475 if (MAYBE_CLASS_TYPE_P (context
))
3476 tmpl
= lookup_field (context
, name
, 0, false);
3478 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3479 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3481 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3483 if (complain
& tf_error
)
3484 error ("no class template named %q#T in %q#T", name
, context
);
3485 return error_mark_node
;
3489 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3491 if (complain
& tf_error
)
3493 error ("template parameters do not match template %qD", tmpl
);
3494 inform (DECL_SOURCE_LOCATION (tmpl
),
3495 "%qD declared here", tmpl
);
3497 return error_mark_node
;
3500 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3502 return error_mark_node
;
3507 /* Build the UNBOUND_CLASS_TEMPLATE. */
3508 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3509 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3510 TREE_TYPE (t
) = NULL_TREE
;
3511 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3513 /* Build the corresponding TEMPLATE_DECL. */
3514 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3515 TYPE_NAME (TREE_TYPE (d
)) = d
;
3516 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3517 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3518 DECL_ARTIFICIAL (d
) = 1;
3519 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3526 /* Push the declarations of builtin types into the namespace.
3527 RID_INDEX is the index of the builtin type in the array
3528 RID_POINTERS. NAME is the name used when looking up the builtin
3529 type. TYPE is the _TYPE node for the builtin type. */
3532 record_builtin_type (enum rid rid_index
,
3536 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3537 tree tdecl
= NULL_TREE
;
3539 if ((int) rid_index
< (int) RID_MAX
)
3540 rname
= ridpointers
[(int) rid_index
];
3542 tname
= get_identifier (name
);
3544 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3545 eliminated. Built-in types should not be looked up name; their
3546 names are keywords that the parser can recognize. However, there
3547 is code in c-common.c that uses identifier_global_value to look
3548 up built-in types by name. */
3551 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3552 DECL_ARTIFICIAL (tdecl
) = 1;
3553 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3559 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3560 DECL_ARTIFICIAL (tdecl
) = 1;
3562 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3565 if (!TYPE_NAME (type
))
3566 TYPE_NAME (type
) = tdecl
;
3569 debug_hooks
->type_decl (tdecl
, 0);
3572 /* Record one of the standard Java types.
3573 * Declare it as having the given NAME.
3574 * If SIZE > 0, it is the size of one of the integral types;
3575 * otherwise it is the negative of the size of one of the other types. */
3578 record_builtin_java_type (const char* name
, int size
)
3583 type
= build_nonstandard_integer_type (size
, 0);
3584 type
= build_distinct_type_copy (type
);
3586 else if (size
> -32)
3589 /* "__java_char" or ""__java_boolean". */
3590 type
= build_nonstandard_integer_type (-size
, 1);
3591 type
= build_distinct_type_copy (type
);
3592 /* Get the signed type cached and attached to the unsigned type,
3593 so it doesn't get garbage-collected at "random" times,
3594 causing potential codegen differences out of different UIDs
3595 and different alias set numbers. */
3596 stype
= build_nonstandard_integer_type (-size
, 0);
3597 stype
= build_distinct_type_copy (stype
);
3598 TREE_CHAIN (type
) = stype
;
3599 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3602 { /* "__java_float" or ""__java_double". */
3603 type
= make_node (REAL_TYPE
);
3604 TYPE_PRECISION (type
) = - size
;
3607 record_builtin_type (RID_MAX
, name
, type
);
3608 decl
= TYPE_NAME (type
);
3610 /* Suppress generate debug symbol entries for these types,
3611 since for normal C++ they are just clutter.
3612 However, push_lang_context undoes this if extern "Java" is seen. */
3613 DECL_IGNORED_P (decl
) = 1;
3615 TYPE_FOR_JAVA (type
) = 1;
3619 /* Push a type into the namespace so that the back ends ignore it. */
3622 record_unknown_type (tree type
, const char* name
)
3624 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3625 TYPE_DECL
, get_identifier (name
), type
));
3626 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3627 DECL_IGNORED_P (decl
) = 1;
3628 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3629 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3630 TYPE_ALIGN (type
) = 1;
3631 TYPE_USER_ALIGN (type
) = 0;
3632 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3635 /* A string for which we should create an IDENTIFIER_NODE at
3638 typedef struct predefined_identifier
3640 /* The name of the identifier. */
3641 const char *const name
;
3642 /* The place where the IDENTIFIER_NODE should be stored. */
3644 /* Nonzero if this is the name of a constructor or destructor. */
3645 const int ctor_or_dtor_p
;
3646 } predefined_identifier
;
3648 /* Create all the predefined identifiers. */
3651 initialize_predefined_identifiers (void)
3653 const predefined_identifier
*pid
;
3655 /* A table of identifiers to create at startup. */
3656 static const predefined_identifier predefined_identifiers
[] = {
3657 { "C++", &lang_name_cplusplus
, 0 },
3658 { "C", &lang_name_c
, 0 },
3659 { "Java", &lang_name_java
, 0 },
3660 /* Some of these names have a trailing space so that it is
3661 impossible for them to conflict with names written by users. */
3662 { "__ct ", &ctor_identifier
, 1 },
3663 { "__base_ctor ", &base_ctor_identifier
, 1 },
3664 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3665 { "__dt ", &dtor_identifier
, 1 },
3666 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3667 { "__base_dtor ", &base_dtor_identifier
, 1 },
3668 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3669 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3670 { "nelts", &nelts_identifier
, 0 },
3671 { THIS_NAME
, &this_identifier
, 0 },
3672 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3673 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3674 { "_vptr", &vptr_identifier
, 0 },
3675 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3676 { "::", &global_scope_name
, 0 },
3677 { "std", &std_identifier
, 0 },
3681 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3683 *pid
->node
= get_identifier (pid
->name
);
3684 if (pid
->ctor_or_dtor_p
)
3685 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3689 /* Create the predefined scalar types of C,
3690 and some nodes representing standard constants (0, 1, (void *)0).
3691 Initialize the global binding level.
3692 Make definitions for built-in primitive functions. */
3695 cxx_init_decl_processing (void)
3698 tree void_ftype_ptr
;
3700 /* Create all the identifiers we need. */
3701 initialize_predefined_identifiers ();
3703 /* Create the global variables. */
3704 push_to_top_level ();
3706 current_function_decl
= NULL_TREE
;
3707 current_binding_level
= NULL
;
3708 /* Enter the global namespace. */
3709 gcc_assert (global_namespace
== NULL_TREE
);
3710 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3712 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3713 TREE_PUBLIC (global_namespace
) = 1;
3714 begin_scope (sk_namespace
, global_namespace
);
3716 if (flag_visibility_ms_compat
)
3717 default_visibility
= VISIBILITY_HIDDEN
;
3720 current_lang_name
= lang_name_c
;
3722 /* Create the `std' namespace. */
3723 push_namespace (std_identifier
);
3724 std_node
= current_namespace
;
3727 c_common_nodes_and_builtins ();
3729 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3730 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3731 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3732 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3733 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3734 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3735 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3736 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3738 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3740 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3741 truthvalue_type_node
= boolean_type_node
;
3742 truthvalue_false_node
= boolean_false_node
;
3743 truthvalue_true_node
= boolean_true_node
;
3745 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3746 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3747 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3750 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3753 delta_type_node
= ptrdiff_type_node
;
3754 vtable_index_type
= ptrdiff_type_node
;
3756 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3757 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3758 void_ftype_ptr
= build_function_type_list (void_type_node
,
3759 ptr_type_node
, NULL_TREE
);
3761 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3763 /* C++ extensions */
3765 unknown_type_node
= make_node (LANG_TYPE
);
3766 record_unknown_type (unknown_type_node
, "unknown type");
3768 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3769 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3771 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3773 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3774 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3776 init_list_type_node
= make_node (LANG_TYPE
);
3777 record_unknown_type (init_list_type_node
, "init list");
3780 /* Make sure we get a unique function type, so we can give
3781 its pointer type a name. (This wins for gdb.) */
3782 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3783 TREE_TYPE (vfunc_type
) = integer_type_node
;
3784 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3785 layout_type (vfunc_type
);
3787 vtable_entry_type
= build_pointer_type (vfunc_type
);
3789 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3792 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3793 layout_type (vtbl_type_node
);
3794 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3795 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3796 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3797 layout_type (vtbl_ptr_type_node
);
3798 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3800 push_namespace (get_identifier ("__cxxabiv1"));
3801 abi_node
= current_namespace
;
3804 global_type_node
= make_node (LANG_TYPE
);
3805 record_unknown_type (global_type_node
, "global type");
3808 current_lang_name
= lang_name_cplusplus
;
3811 tree newattrs
, extvisattr
;
3812 tree newtype
, deltype
;
3813 tree ptr_ftype_sizetype
;
3817 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3818 if (cxx_dialect
== cxx98
)
3821 tree bad_alloc_type_node
;
3822 tree bad_alloc_decl
;
3824 push_namespace (std_identifier
);
3825 bad_alloc_id
= get_identifier ("bad_alloc");
3826 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3827 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3829 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3830 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3834 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3837 new_eh_spec
= noexcept_false_spec
;
3839 /* Ensure attribs.c is initialized. */
3841 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3843 newattrs
= tree_cons (get_identifier ("alloc_size"),
3844 build_tree_list (NULL_TREE
, integer_one_node
),
3846 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3847 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3848 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3849 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3850 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
3851 DECL_IS_MALLOC (opnew
) = 1;
3852 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3853 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
3854 DECL_IS_MALLOC (opnew
) = 1;
3855 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3856 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3857 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3859 nullptr_type_node
= make_node (NULLPTR_TYPE
);
3860 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
3861 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
3862 TYPE_UNSIGNED (nullptr_type_node
) = 1;
3863 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
3864 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
3865 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
3866 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
3870 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
3871 ECF_NORETURN
| ECF_NOTHROW
);
3873 /* Perform other language dependent initializations. */
3874 init_class_processing ();
3875 init_rtti_processing ();
3876 init_template_processing ();
3878 if (flag_exceptions
)
3879 init_exception_processing ();
3881 if (! supports_one_only ())
3884 make_fname_decl
= cp_make_fname_decl
;
3885 start_fname_decls ();
3887 /* Show we use EH for cleanups. */
3888 if (flag_exceptions
)
3889 using_eh_for_cleanups ();
3892 /* Generate an initializer for a function naming variable from
3893 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3894 filled in with the type of the init. */
3897 cp_fname_init (const char* name
, tree
*type_p
)
3899 tree domain
= NULL_TREE
;
3901 tree init
= NULL_TREE
;
3906 length
= strlen (name
);
3907 domain
= build_index_type (size_int (length
));
3908 init
= build_string (length
+ 1, name
);
3911 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3912 type
= build_cplus_array_type (type
, domain
);
3917 TREE_TYPE (init
) = type
;
3919 init
= error_mark_node
;
3924 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3925 the decl, LOC is the location to give the decl, NAME is the
3926 initialization string and TYPE_DEP indicates whether NAME depended
3927 on the type of the function. We make use of that to detect
3928 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3929 at the point of first use, so we mustn't push the decl now. */
3932 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3934 const char *const name
= (type_dep
&& processing_template_decl
3935 ? NULL
: fname_as_string (type_dep
));
3937 tree init
= cp_fname_init (name
, &type
);
3938 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3941 free (CONST_CAST (char *, name
));
3943 /* As we're using pushdecl_with_scope, we must set the context. */
3944 DECL_CONTEXT (decl
) = current_function_decl
;
3946 TREE_STATIC (decl
) = 1;
3947 TREE_READONLY (decl
) = 1;
3948 DECL_ARTIFICIAL (decl
) = 1;
3950 TREE_USED (decl
) = 1;
3952 if (current_function_decl
)
3954 cp_binding_level
*b
= current_binding_level
;
3955 if (b
->kind
== sk_function_parms
)
3956 return error_mark_node
;
3957 while (b
->level_chain
->kind
!= sk_function_parms
)
3959 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3960 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3961 LOOKUP_ONLYCONVERTING
);
3965 DECL_THIS_STATIC (decl
) = true;
3966 pushdecl_top_level_and_finish (decl
, init
);
3973 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3975 tree id
= DECL_NAME (decl
);
3976 const char *name
= IDENTIFIER_POINTER (id
);
3978 retrofit_lang_decl (decl
);
3980 DECL_ARTIFICIAL (decl
) = 1;
3981 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3982 SET_DECL_LANGUAGE (decl
, lang_c
);
3983 /* Runtime library routines are, by definition, available in an
3984 external shared object. */
3985 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3986 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3988 DECL_CONTEXT (decl
) = context
;
3991 pushdecl_top_level (decl
);
3995 /* A function in the user's namespace should have an explicit
3996 declaration before it is used. Mark the built-in function as
3997 anticipated but not actually declared. */
3998 if (name
[0] != '_' || name
[1] != '_')
3999 DECL_ANTICIPATED (decl
) = 1;
4000 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4002 size_t len
= strlen (name
);
4004 /* Treat __*_chk fortification functions as anticipated as well,
4005 unless they are __builtin_*. */
4006 if (len
> strlen ("___chk")
4007 && memcmp (name
+ len
- strlen ("_chk"),
4008 "_chk", strlen ("_chk") + 1) == 0)
4009 DECL_ANTICIPATED (decl
) = 1;
4016 cxx_builtin_function (tree decl
)
4018 tree id
= DECL_NAME (decl
);
4019 const char *name
= IDENTIFIER_POINTER (id
);
4020 /* All builtins that don't begin with an '_' should additionally
4021 go in the 'std' namespace. */
4024 tree decl2
= copy_node(decl
);
4025 push_namespace (std_identifier
);
4026 builtin_function_1 (decl2
, std_node
, false);
4030 return builtin_function_1 (decl
, NULL_TREE
, false);
4033 /* Like cxx_builtin_function, but guarantee the function is added to the global
4034 scope. This is to allow function specific options to add new machine
4035 dependent builtins when the target ISA changes via attribute((target(...)))
4036 which saves space on program startup if the program does not use non-generic
4040 cxx_builtin_function_ext_scope (tree decl
)
4043 tree id
= DECL_NAME (decl
);
4044 const char *name
= IDENTIFIER_POINTER (id
);
4045 /* All builtins that don't begin with an '_' should additionally
4046 go in the 'std' namespace. */
4049 tree decl2
= copy_node(decl
);
4050 push_namespace (std_identifier
);
4051 builtin_function_1 (decl2
, std_node
, true);
4055 return builtin_function_1 (decl
, NULL_TREE
, true);
4058 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4059 function. Not called directly. */
4062 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4065 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4066 DECL_EXTERNAL (fn
) = 1;
4067 TREE_PUBLIC (fn
) = 1;
4068 DECL_ARTIFICIAL (fn
) = 1;
4069 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4070 SET_DECL_LANGUAGE (fn
, lang_c
);
4071 /* Runtime library routines are, by definition, available in an
4072 external shared object. */
4073 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4074 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4075 set_call_expr_flags (fn
, ecf_flags
);
4079 /* Returns the _DECL for a library function with C++ linkage. */
4082 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4085 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4086 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4087 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4091 /* Like build_library_fn, but takes a C string instead of an
4095 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4097 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4100 /* Like build_cp_library_fn, but takes a C string instead of an
4104 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4106 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4110 /* Like build_library_fn, but also pushes the function so that we will
4111 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4112 may throw exceptions listed in RAISES. */
4115 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4120 type
= build_exception_variant (type
, raises
);
4122 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4123 pushdecl_top_level (fn
);
4127 /* Like build_cp_library_fn, but also pushes the function so that it
4128 will be found by normal lookup. */
4131 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4134 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4139 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4143 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4147 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4149 tree type
= build_function_type (void_type_node
, parmtypes
);
4150 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4153 /* Like push_library_fn, but also note that this function throws
4154 and does not return. Used for __throw_foo and the like. */
4157 push_throw_library_fn (tree name
, tree type
)
4159 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4163 /* When we call finish_struct for an anonymous union, we create
4164 default copy constructors and such. But, an anonymous union
4165 shouldn't have such things; this function undoes the damage to the
4166 anonymous union type T.
4168 (The reason that we create the synthesized methods is that we don't
4169 distinguish `union { int i; }' from `typedef union { int i; } U'.
4170 The first is an anonymous union; the second is just an ordinary
4174 fixup_anonymous_aggr (tree t
)
4178 /* Wipe out memory of synthesized methods. */
4179 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4180 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4181 TYPE_HAS_COPY_CTOR (t
) = 0;
4182 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4183 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4184 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4186 /* Splice the implicitly generated functions out of the TYPE_METHODS
4188 q
= &TYPE_METHODS (t
);
4191 if (DECL_ARTIFICIAL (*q
))
4192 *q
= TREE_CHAIN (*q
);
4194 q
= &DECL_CHAIN (*q
);
4197 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4198 if (TYPE_METHODS (t
))
4200 tree decl
= TYPE_MAIN_DECL (t
);
4202 if (TREE_CODE (t
) != UNION_TYPE
)
4203 error_at (DECL_SOURCE_LOCATION (decl
),
4204 "an anonymous struct cannot have function members");
4206 error_at (DECL_SOURCE_LOCATION (decl
),
4207 "an anonymous union cannot have function members");
4210 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4211 assignment operators (because they cannot have these methods themselves).
4212 For anonymous unions this is already checked because they are not allowed
4213 in any union, otherwise we have to check it. */
4214 if (TREE_CODE (t
) != UNION_TYPE
)
4218 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4219 if (TREE_CODE (field
) == FIELD_DECL
)
4221 type
= TREE_TYPE (field
);
4222 if (CLASS_TYPE_P (type
))
4224 if (TYPE_NEEDS_CONSTRUCTING (type
))
4225 error ("member %q+#D with constructor not allowed "
4226 "in anonymous aggregate", field
);
4227 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4228 error ("member %q+#D with destructor not allowed "
4229 "in anonymous aggregate", field
);
4230 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4231 error ("member %q+#D with copy assignment operator "
4232 "not allowed in anonymous aggregate", field
);
4238 /* Warn for an attribute located at LOCATION that appertains to the
4239 class type CLASS_TYPE that has not been properly placed after its
4240 class-key, in it class-specifier. */
4243 warn_misplaced_attr_for_class_type (source_location location
,
4246 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4248 if (warning_at (location
, OPT_Wattributes
,
4249 "attribute ignored in declaration "
4250 "of %q#T", class_type
))
4252 "attribute for %q#T must follow the %qs keyword",
4253 class_type
, class_key_or_enum_as_string (class_type
));
4256 /* Make sure that a declaration with no declarator is well-formed, i.e.
4257 just declares a tagged type or anonymous union.
4259 Returns the type declared; or NULL_TREE if none. */
4262 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4263 bool explicit_type_instantiation_p
)
4265 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4266 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4267 /* If a class, struct, or enum type is declared by the DECLSPECS
4268 (i.e, if a class-specifier, enum-specifier, or non-typename
4269 elaborated-type-specifier appears in the DECLSPECS),
4270 DECLARED_TYPE is set to the corresponding type. */
4271 tree declared_type
= NULL_TREE
;
4272 bool error_p
= false;
4274 if (declspecs
->multiple_types_p
)
4275 error ("multiple types in one declaration");
4276 else if (declspecs
->redefined_builtin_type
)
4278 if (!in_system_header_at (input_location
))
4279 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4280 "redeclaration of C++ built-in type %qT",
4281 declspecs
->redefined_builtin_type
);
4286 && TYPE_P (declspecs
->type
)
4287 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4288 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4289 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4290 declared_type
= declspecs
->type
;
4291 else if (declspecs
->type
== error_mark_node
)
4293 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4294 permerror (input_location
, "declaration does not declare anything");
4295 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4297 error ("%<auto%> can only be specified for variables "
4298 "or function declarations");
4299 return error_mark_node
;
4301 /* Check for an anonymous union. */
4302 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4303 && TYPE_ANONYMOUS_P (declared_type
))
4305 /* 7/3 In a simple-declaration, the optional init-declarator-list
4306 can be omitted only when declaring a class (clause 9) or
4307 enumeration (7.2), that is, when the decl-specifier-seq contains
4308 either a class-specifier, an elaborated-type-specifier with
4309 a class-key (9.1), or an enum-specifier. In these cases and
4310 whenever a class-specifier or enum-specifier is present in the
4311 decl-specifier-seq, the identifiers in these specifiers are among
4312 the names being declared by the declaration (as class-name,
4313 enum-names, or enumerators, depending on the syntax). In such
4314 cases, and except for the declaration of an unnamed bit-field (9.6),
4315 the decl-specifier-seq shall introduce one or more names into the
4316 program, or shall redeclare a name introduced by a previous
4317 declaration. [Example:
4318 enum { }; // ill-formed
4319 typedef class { }; // ill-formed
4323 error ("missing type-name in typedef-declaration");
4326 /* Anonymous unions are objects, so they can have specifiers. */;
4327 SET_ANON_AGGR_TYPE_P (declared_type
);
4329 if (TREE_CODE (declared_type
) != UNION_TYPE
4330 && !in_system_header_at (input_location
))
4331 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4336 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4337 || decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4338 error ("%qs can only be specified for functions",
4339 decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4340 ? "inline" : "virtual");
4342 && (!current_class_type
4343 || current_scope () != current_class_type
))
4344 error ("%<friend%> can only be specified inside a class");
4345 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4346 error ("%<explicit%> can only be specified for constructors");
4347 else if (declspecs
->storage_class
)
4348 error ("a storage class can only be specified for objects "
4350 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
)
4351 || decl_spec_seq_has_spec_p (declspecs
, ds_volatile
)
4352 || decl_spec_seq_has_spec_p (declspecs
, ds_restrict
)
4353 || decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4354 error ("qualifiers can only be specified for objects "
4356 else if (saw_typedef
)
4357 warning (0, "%<typedef%> was ignored in this declaration");
4358 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4359 error ("%<constexpr%> cannot be used for type declarations");
4362 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4365 if (!CLASS_TYPE_P (declared_type
)
4366 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4367 /* For a non-template class, use the name location. */
4368 loc
= location_of (declared_type
);
4370 /* For a template class (an explicit instantiation), use the
4371 current location. */
4372 loc
= input_location
;
4374 if (explicit_type_instantiation_p
)
4375 /* [dcl.attr.grammar]/4:
4377 No attribute-specifier-seq shall appertain to an explicit
4380 if (warning_at (loc
, OPT_Wattributes
,
4381 "attribute ignored in explicit instantiation %q#T",
4384 "no attribute can be applied to "
4385 "an explicit instantiation");
4388 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4391 return declared_type
;
4394 /* Called when a declaration is seen that contains no names to declare.
4395 If its type is a reference to a structure, union or enum inherited
4396 from a containing scope, shadow that tag name for the current scope
4397 with a forward reference.
4398 If its type defines a new named structure or union
4399 or defines an enum, it is valid but we need not do anything here.
4400 Otherwise, it is an error.
4402 C++: may have to grok the declspecs to learn about static,
4403 complain for anonymous unions.
4405 Returns the TYPE declared -- or NULL_TREE if none. */
4408 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4410 tree t
= check_tag_decl (declspecs
,
4411 /*explicit_type_instantiation_p=*/false);
4416 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4419 /* This is where the variables in an anonymous union are
4420 declared. An anonymous union declaration looks like:
4422 because there is no declarator after the union, the parser
4423 sends that declaration here. */
4424 if (ANON_AGGR_TYPE_P (t
))
4426 fixup_anonymous_aggr (t
);
4428 if (TYPE_FIELDS (t
))
4430 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4431 declspecs
, NORMAL
, 0, NULL
);
4432 finish_anon_union (decl
);
4439 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4442 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4443 const cp_declarator
*declarator
,
4444 bool is_template_arg
)
4448 enum decl_context context
4449 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4450 attrs
= type_specifiers
->attributes
;
4451 type_specifiers
->attributes
= NULL_TREE
;
4452 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4453 if (attrs
&& type
!= error_mark_node
)
4455 if (CLASS_TYPE_P (type
))
4456 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4457 "outside of definition", type
);
4458 else if (MAYBE_CLASS_TYPE_P (type
))
4459 /* A template type parameter or other dependent type. */
4460 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4461 "type %qT without an associated declaration", type
);
4463 cplus_decl_attributes (&type
, attrs
, 0);
4468 /* Process a DECLARATOR for a function-scope variable declaration,
4469 namespace-scope variable declaration, or function declaration.
4470 (Function definitions go through start_function; class member
4471 declarations appearing in the body of the class go through
4472 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4473 If an error occurs, the error_mark_node is returned instead.
4475 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4476 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4477 for an explicitly defaulted function, or SD_DELETED for an explicitly
4478 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4479 implicitly initialized via a default constructor. ATTRIBUTES and
4480 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4482 The scope represented by the context of the returned DECL is pushed
4483 (if it is not the global namespace) and is assigned to
4484 *PUSHED_SCOPE_P. The caller is then responsible for calling
4485 pop_scope on *PUSHED_SCOPE_P if it is set. */
4488 start_decl (const cp_declarator
*declarator
,
4489 cp_decl_specifier_seq
*declspecs
,
4492 tree prefix_attributes
,
4493 tree
*pushed_scope_p
)
4501 *pushed_scope_p
= NULL_TREE
;
4503 /* An object declared as __attribute__((deprecated)) suppresses
4504 warnings of uses of other deprecated items. */
4505 if (lookup_attribute ("deprecated", attributes
))
4506 deprecated_state
= DEPRECATED_SUPPRESS
;
4508 attributes
= chainon (attributes
, prefix_attributes
);
4510 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4513 deprecated_state
= DEPRECATED_NORMAL
;
4515 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4516 || decl
== error_mark_node
)
4517 return error_mark_node
;
4519 context
= CP_DECL_CONTEXT (decl
);
4520 if (context
!= global_namespace
)
4521 *pushed_scope_p
= push_scope (context
);
4524 /* Is it valid for this decl to have an initializer at all?
4525 If not, set INITIALIZED to zero, which will indirectly
4526 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4527 switch (TREE_CODE (decl
))
4530 error ("typedef %qD is initialized (use decltype instead)", decl
);
4531 return error_mark_node
;
4534 if (initialized
== SD_DELETED
)
4535 /* We'll handle the rest of the semantics later, but we need to
4536 set this now so it's visible to duplicate_decls. */
4537 DECL_DELETED_FN (decl
) = 1;
4546 if (! toplevel_bindings_p ()
4547 && DECL_EXTERNAL (decl
))
4548 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4550 DECL_EXTERNAL (decl
) = 0;
4551 if (toplevel_bindings_p ())
4552 TREE_STATIC (decl
) = 1;
4554 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4556 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4557 record_key_method_defined (decl
);
4559 /* If this is a typedef that names the class for linkage purposes
4560 (7.1.3p8), apply any attributes directly to the type. */
4561 if (TREE_CODE (decl
) == TYPE_DECL
4562 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4563 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4564 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4568 /* Set attributes here so if duplicate decl, will have proper attributes. */
4569 cplus_decl_attributes (&decl
, attributes
, flags
);
4571 /* Dllimported symbols cannot be defined. Static data members (which
4572 can be initialized in-class and dllimported) go through grokfield,
4573 not here, so we don't need to exclude those decls when checking for
4575 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4577 error ("definition of %q#D is marked %<dllimport%>", decl
);
4578 DECL_DLLIMPORT_P (decl
) = 0;
4581 /* If #pragma weak was used, mark the decl weak now. */
4582 if (!processing_template_decl
)
4583 maybe_apply_pragma_weak (decl
);
4585 if (TREE_CODE (decl
) == FUNCTION_DECL
4586 && DECL_DECLARED_INLINE_P (decl
)
4587 && DECL_UNINLINABLE (decl
)
4588 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4589 warning (0, "inline function %q+D given attribute noinline", decl
);
4591 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4595 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4596 if (field
== NULL_TREE
|| !VAR_P (field
))
4597 error ("%q#D is not a static member of %q#T", decl
, context
);
4600 if (DECL_CONTEXT (field
) != context
)
4602 if (!same_type_p (DECL_CONTEXT (field
), context
))
4603 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4604 "to be defined as %<%T::%D%>",
4605 DECL_CONTEXT (field
), DECL_NAME (decl
),
4606 context
, DECL_NAME (decl
));
4607 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4609 /* Static data member are tricky; an in-class initialization
4610 still doesn't provide a definition, so the in-class
4611 declaration will have DECL_EXTERNAL set, but will have an
4612 initialization. Thus, duplicate_decls won't warn
4613 about this situation, and so we check here. */
4614 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4615 error ("duplicate initialization of %qD", decl
);
4616 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4618 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4619 && !DECL_DECLARED_CONSTEXPR_P (field
))
4620 error ("%qD declared %<constexpr%> outside its class", field
);
4625 tree field
= check_classfn (context
, decl
,
4626 (processing_template_decl
4627 > template_class_depth (context
))
4628 ? current_template_parms
4630 if (field
&& field
!= error_mark_node
4631 && duplicate_decls (decl
, field
,
4632 /*newdecl_is_friend=*/false))
4636 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4637 DECL_IN_AGGR_P (decl
) = 0;
4638 /* Do not mark DECL as an explicit specialization if it was not
4639 already marked as an instantiation; a declaration should
4640 never be marked as a specialization unless we know what
4641 template is being specialized. */
4642 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4644 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4646 /* [temp.expl.spec] An explicit specialization of a static data
4647 member of a template is a definition if the declaration
4648 includes an initializer; otherwise, it is a declaration.
4650 We check for processing_specialization so this only applies
4651 to the new specialization syntax. */
4652 if (!initialized
&& processing_specialization
)
4653 DECL_EXTERNAL (decl
) = 1;
4656 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4657 /* Aliases are definitions. */
4659 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4663 was_public
= TREE_PUBLIC (decl
);
4665 /* Enter this declaration into the symbol table. */
4666 decl
= maybe_push_decl (decl
);
4668 if (processing_template_decl
)
4669 decl
= push_template_decl (decl
);
4670 if (decl
== error_mark_node
)
4671 return error_mark_node
;
4674 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4675 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4677 /* This is a const variable with implicit 'static'. Set
4678 DECL_THIS_STATIC so we can tell it from variables that are
4679 !TREE_PUBLIC because of the anonymous namespace. */
4680 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4681 DECL_THIS_STATIC (decl
) = 1;
4684 if (!processing_template_decl
&& VAR_P (decl
))
4685 start_decl_1 (decl
, initialized
);
4690 /* Process the declaration of a variable DECL. INITIALIZED is true
4691 iff DECL is explicitly initialized. (INITIALIZED is false if the
4692 variable is initialized via an implicitly-called constructor.)
4693 This function must be called for ordinary variables (including, for
4694 example, implicit instantiations of templates), but must not be
4695 called for template declarations. */
4698 start_decl_1 (tree decl
, bool initialized
)
4702 bool aggregate_definition_p
;
4704 gcc_assert (!processing_template_decl
);
4706 if (error_operand_p (decl
))
4709 gcc_assert (VAR_P (decl
));
4711 type
= TREE_TYPE (decl
);
4712 complete_p
= COMPLETE_TYPE_P (type
);
4713 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4715 /* If an explicit initializer is present, or if this is a definition
4716 of an aggregate, then we need a complete type at this point.
4717 (Scalars are always complete types, so there is nothing to
4718 check.) This code just sets COMPLETE_P; errors (if necessary)
4719 are issued below. */
4720 if ((initialized
|| aggregate_definition_p
)
4722 && COMPLETE_TYPE_P (complete_type (type
)))
4725 /* We will not yet have set TREE_READONLY on DECL if the type
4726 was "const", but incomplete, before this point. But, now, we
4727 have a complete type, so we can try again. */
4728 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4732 /* Is it valid for this decl to have an initializer at all? */
4734 /* Don't allow initializations for incomplete types except for
4735 arrays which might be completed by the initialization. */
4737 ; /* A complete type is ok. */
4738 else if (type_uses_auto (type
))
4739 ; /* An auto type is ok. */
4740 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4742 error ("variable %q#D has initializer but incomplete type", decl
);
4743 type
= TREE_TYPE (decl
) = error_mark_node
;
4745 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4747 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4748 error ("elements of array %q#D have incomplete type", decl
);
4749 /* else we already gave an error in start_decl. */
4752 else if (aggregate_definition_p
&& !complete_p
)
4754 if (type_uses_auto (type
))
4755 error ("declaration of %q#D has no initializer", decl
);
4757 error ("aggregate %q#D has incomplete type and cannot be defined",
4759 /* Change the type so that assemble_variable will give
4760 DECL an rtl we can live with: (mem (const_int 0)). */
4761 type
= TREE_TYPE (decl
) = error_mark_node
;
4764 /* Create a new scope to hold this declaration if necessary.
4765 Whether or not a new scope is necessary cannot be determined
4766 until after the type has been completed; if the type is a
4767 specialization of a class template it is not until after
4768 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4769 will be set correctly. */
4770 maybe_push_cleanup_level (type
);
4773 /* Handle initialization of references. DECL, TYPE, and INIT have the
4774 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4775 but will be set to a new CLEANUP_STMT if a temporary is created
4776 that must be destroyed subsequently.
4778 Returns an initializer expression to use to initialize DECL, or
4779 NULL if the initialization can be performed statically.
4781 Quotes on semantics can be found in ARM 8.4.3. */
4784 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4786 if (init
== NULL_TREE
)
4788 if ((DECL_LANG_SPECIFIC (decl
) == 0
4789 || DECL_IN_AGGR_P (decl
) == 0)
4790 && ! DECL_THIS_EXTERN (decl
))
4791 error ("%qD declared as reference but not initialized", decl
);
4795 if (TREE_CODE (init
) == TREE_LIST
)
4796 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4797 tf_warning_or_error
);
4799 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4800 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4801 /* Note: default conversion is only called in very special cases. */
4802 init
= decay_conversion (init
, tf_warning_or_error
);
4804 /* Convert INIT to the reference type TYPE. This may involve the
4805 creation of a temporary, whose lifetime must be the same as that
4806 of the reference. If so, a DECL_EXPR for the temporary will be
4807 added just after the DECL_EXPR for DECL. That's why we don't set
4808 DECL_INITIAL for local references (instead assigning to them
4809 explicitly); we need to allow the temporary to be initialized
4811 return initialize_reference (type
, init
, flags
,
4812 tf_warning_or_error
);
4815 /* Designated initializers in arrays are not supported in GNU C++.
4816 The parser cannot detect this error since it does not know whether
4817 a given brace-enclosed initializer is for a class type or for an
4818 array. This function checks that CE does not use a designated
4819 initializer. If it does, an error is issued. Returns true if CE
4820 is valid, i.e., does not have a designated initializer. */
4823 check_array_designated_initializer (constructor_elt
*ce
,
4824 unsigned HOST_WIDE_INT index
)
4826 /* Designated initializers for array elements are not supported. */
4829 /* The parser only allows identifiers as designated
4831 if (ce
->index
== error_mark_node
)
4833 error ("name used in a GNU-style designated "
4834 "initializer for an array");
4837 else if (identifier_p (ce
->index
))
4839 error ("name %qD used in a GNU-style designated "
4840 "initializer for an array", ce
->index
);
4844 ce
->index
= cxx_constant_value (ce
->index
);
4846 if (TREE_CODE (ce
->index
) == INTEGER_CST
)
4848 /* A C99 designator is OK if it matches the current index. */
4849 if (wi::eq_p (ce
->index
, index
))
4852 sorry ("non-trivial designated initializers not supported");
4863 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4864 array until we finish parsing the initializer. If that's the
4865 situation we're in, update DECL accordingly. */
4868 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4870 tree type
= TREE_TYPE (decl
);
4872 if (TREE_CODE (type
) == ARRAY_TYPE
4873 && TYPE_DOMAIN (type
) == NULL_TREE
4874 && TREE_CODE (decl
) != TYPE_DECL
)
4876 /* do_default is really a C-ism to deal with tentative definitions.
4877 But let's leave it here to ease the eventual merge. */
4878 int do_default
= !DECL_EXTERNAL (decl
);
4879 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4882 /* Check that there are no designated initializers in INIT, as
4883 those are not supported in GNU C++, and as the middle-end
4884 will crash if presented with a non-numeric designated
4886 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
4888 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
4889 constructor_elt
*ce
;
4891 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
4892 if (!check_array_designated_initializer (ce
, i
))
4898 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4902 error ("initializer fails to determine size of %qD", decl
);
4904 else if (failure
== 2)
4908 error ("array size missing in %qD", decl
);
4910 /* If a `static' var's size isn't known, make it extern as
4911 well as static, so it does not get allocated. If it's not
4912 `static', then don't mark it extern; finish_incomplete_decl
4913 will give it a default size and it will get allocated. */
4914 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4915 DECL_EXTERNAL (decl
) = 1;
4917 else if (failure
== 3)
4919 error ("zero-size array %qD", decl
);
4923 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4925 relayout_decl (decl
);
4929 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4930 any appropriate error messages regarding the layout. */
4933 layout_var_decl (tree decl
)
4937 type
= TREE_TYPE (decl
);
4938 if (type
== error_mark_node
)
4941 /* If we haven't already laid out this declaration, do so now.
4942 Note that we must not call complete type for an external object
4943 because it's type might involve templates that we are not
4944 supposed to instantiate yet. (And it's perfectly valid to say
4945 `extern X x' for some incomplete type `X'.) */
4946 if (!DECL_EXTERNAL (decl
))
4947 complete_type (type
);
4948 if (!DECL_SIZE (decl
)
4949 && TREE_TYPE (decl
) != error_mark_node
4950 && (COMPLETE_TYPE_P (type
)
4951 || (TREE_CODE (type
) == ARRAY_TYPE
4952 && !TYPE_DOMAIN (type
)
4953 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4954 layout_decl (decl
, 0);
4956 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4958 /* An automatic variable with an incomplete type: that is an error.
4959 Don't talk about array types here, since we took care of that
4960 message in grokdeclarator. */
4961 error ("storage size of %qD isn%'t known", decl
);
4962 TREE_TYPE (decl
) = error_mark_node
;
4965 /* Keep this code around in case we later want to control debug info
4966 based on whether a type is "used". (jason 1999-11-11) */
4968 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4969 /* Let debugger know it should output info for this type. */
4970 note_debug_info_needed (ttype
);
4972 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4973 note_debug_info_needed (DECL_CONTEXT (decl
));
4976 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4977 && DECL_SIZE (decl
) != NULL_TREE
4978 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4980 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4981 constant_expression_warning (DECL_SIZE (decl
));
4984 error ("storage size of %qD isn%'t constant", decl
);
4985 TREE_TYPE (decl
) = error_mark_node
;
4990 /* If a local static variable is declared in an inline function, or if
4991 we have a weak definition, we must endeavor to create only one
4992 instance of the variable at link-time. */
4995 maybe_commonize_var (tree decl
)
4997 /* Static data in a function with comdat linkage also has comdat
4999 if (TREE_STATIC (decl
)
5000 /* Don't mess with __FUNCTION__. */
5001 && ! DECL_ARTIFICIAL (decl
)
5002 && DECL_FUNCTION_SCOPE_P (decl
)
5003 && vague_linkage_p (DECL_CONTEXT (decl
)))
5007 /* With weak symbols, we simply make the variable COMDAT;
5008 that will cause copies in multiple translations units to
5010 comdat_linkage (decl
);
5014 if (DECL_INITIAL (decl
) == NULL_TREE
5015 || DECL_INITIAL (decl
) == error_mark_node
)
5017 /* Without weak symbols, we can use COMMON to merge
5018 uninitialized variables. */
5019 TREE_PUBLIC (decl
) = 1;
5020 DECL_COMMON (decl
) = 1;
5024 /* While for initialized variables, we must use internal
5025 linkage -- which means that multiple copies will not
5027 TREE_PUBLIC (decl
) = 0;
5028 DECL_COMMON (decl
) = 0;
5029 warning_at (input_location
, 0,
5030 "sorry: semantics of inline function static "
5031 "data %q+#D are wrong (you%'ll wind up "
5032 "with multiple copies)", decl
);
5033 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5034 " you can work around this by removing "
5039 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
5040 /* Set it up again; we might have set DECL_INITIAL since the last
5042 comdat_linkage (decl
);
5045 /* Issue an error message if DECL is an uninitialized const variable. */
5048 check_for_uninitialized_const_var (tree decl
)
5050 tree type
= strip_array_types (TREE_TYPE (decl
));
5052 /* ``Unless explicitly declared extern, a const object does not have
5053 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5056 && TREE_CODE (type
) != REFERENCE_TYPE
5057 && CP_TYPE_CONST_P (type
)
5058 && !DECL_INITIAL (decl
))
5060 tree field
= default_init_uninitialized_part (type
);
5064 permerror (DECL_SOURCE_LOCATION (decl
),
5065 "uninitialized const %qD", decl
);
5067 if (CLASS_TYPE_P (type
))
5069 tree defaulted_ctor
;
5071 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5072 "%q#T has no user-provided default constructor", type
);
5073 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5075 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5076 "constructor is not user-provided because it is "
5077 "explicitly defaulted in the class body");
5078 inform (0, "and the implicitly-defined constructor does not "
5079 "initialize %q+#D", field
);
5084 /* Structure holding the current initializer being processed by reshape_init.
5085 CUR is a pointer to the current element being processed, END is a pointer
5086 after the last element present in the initializer. */
5087 typedef struct reshape_iterator_t
5089 constructor_elt
*cur
;
5090 constructor_elt
*end
;
5093 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5095 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5096 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5097 initialized. If there are no more such fields, the return value
5101 next_initializable_field (tree field
)
5104 && (TREE_CODE (field
) != FIELD_DECL
5105 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5106 || DECL_ARTIFICIAL (field
)))
5107 field
= DECL_CHAIN (field
);
5112 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5113 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5114 INTEGER_CST representing the size of the array minus one (the maximum index),
5115 or NULL_TREE if the array was declared without specifying the size. D is
5116 the iterator within the constructor. */
5119 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5120 tsubst_flags_t complain
)
5123 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5124 unsigned HOST_WIDE_INT max_index_cst
= 0;
5125 unsigned HOST_WIDE_INT index
;
5127 /* The initializer for an array is always a CONSTRUCTOR. */
5128 new_init
= build_constructor (init_list_type_node
, NULL
);
5132 /* Minus 1 is used for zero sized arrays. */
5133 if (integer_all_onesp (max_index
))
5136 if (tree_fits_uhwi_p (max_index
))
5137 max_index_cst
= tree_to_uhwi (max_index
);
5138 /* sizetype is sign extended, not zero extended. */
5140 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5143 /* Loop until there are no more initializers. */
5145 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5149 constructor_elt
*old_cur
= d
->cur
;
5151 check_array_designated_initializer (d
->cur
, index
);
5152 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5154 if (elt_init
== error_mark_node
)
5155 return error_mark_node
;
5156 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5157 size_int (index
), elt_init
);
5158 if (!TREE_CONSTANT (elt_init
))
5159 TREE_CONSTANT (new_init
) = false;
5161 /* This can happen with an invalid initializer (c++/54501). */
5162 if (d
->cur
== old_cur
&& !sized_array_p
)
5169 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5170 Parameters are the same of reshape_init_r. */
5173 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5175 tree max_index
= NULL_TREE
;
5177 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5179 if (TYPE_DOMAIN (type
))
5180 max_index
= array_type_nelts (type
);
5182 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5185 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5186 Parameters are the same of reshape_init_r. */
5189 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5191 tree max_index
= NULL_TREE
;
5193 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
5195 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5197 tree value
= d
->cur
->value
;
5198 if (!same_type_p (TREE_TYPE (value
), type
))
5200 if (complain
& tf_error
)
5201 error ("invalid type %qT as initializer for a vector of type %qT",
5202 TREE_TYPE (d
->cur
->value
), type
);
5203 value
= error_mark_node
;
5209 /* For a vector, we initialize it as an array of the appropriate size. */
5210 if (TREE_CODE (type
) == VECTOR_TYPE
)
5211 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5213 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5216 /* Subroutine of reshape_init_r, processes the initializers for classes
5217 or union. Parameters are the same of reshape_init_r. */
5220 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5221 tsubst_flags_t complain
)
5226 gcc_assert (CLASS_TYPE_P (type
));
5228 /* The initializer for a class is always a CONSTRUCTOR. */
5229 new_init
= build_constructor (init_list_type_node
, NULL
);
5230 field
= next_initializable_field (TYPE_FIELDS (type
));
5236 An initializer for an aggregate member that is an
5237 empty class shall have the form of an empty
5238 initializer-list {}. */
5239 if (!first_initializer_p
)
5241 if (complain
& tf_error
)
5242 error ("initializer for %qT must be brace-enclosed", type
);
5243 return error_mark_node
;
5248 /* Loop through the initializable fields, gathering initializers. */
5249 while (d
->cur
!= d
->end
)
5252 constructor_elt
*old_cur
= d
->cur
;
5254 /* Handle designated initializers, as an extension. */
5257 if (d
->cur
->index
== error_mark_node
)
5258 return error_mark_node
;
5260 if (TREE_CODE (d
->cur
->index
) == INTEGER_CST
)
5262 if (complain
& tf_error
)
5263 error ("%<[%E] =%> used in a GNU-style designated initializer"
5264 " for class %qT", d
->cur
->index
, type
);
5265 return error_mark_node
;
5268 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5269 /* We already reshaped this. */
5270 gcc_assert (d
->cur
->index
== field
);
5272 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5274 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5276 if (complain
& tf_error
)
5277 error ("%qT has no non-static data member named %qD", type
,
5279 return error_mark_node
;
5283 /* If we processed all the member of the class, we are done. */
5287 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5288 /*first_initializer_p=*/false, complain
);
5289 if (field_init
== error_mark_node
)
5290 return error_mark_node
;
5292 if (d
->cur
== old_cur
&& d
->cur
->index
)
5294 /* This can happen with an invalid initializer for a flexible
5295 array member (c++/54441). */
5296 if (complain
& tf_error
)
5297 error ("invalid initializer for %q#D", field
);
5298 return error_mark_node
;
5301 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5305 When a union is initialized with a brace-enclosed
5306 initializer, the braces shall only contain an
5307 initializer for the first member of the union. */
5308 if (TREE_CODE (type
) == UNION_TYPE
)
5311 field
= next_initializable_field (DECL_CHAIN (field
));
5317 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5318 designators are not valid; either complain or return true to indicate
5319 that reshape_init_r should return error_mark_node. */
5322 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5326 if (complain
& tf_error
)
5327 error ("C99 designator %qE outside aggregate initializer",
5335 /* Subroutine of reshape_init, which processes a single initializer (part of
5336 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5337 iterator within the CONSTRUCTOR which points to the initializer to process.
5338 FIRST_INITIALIZER_P is true if this is the first initializer of the
5339 outermost CONSTRUCTOR node. */
5342 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5343 tsubst_flags_t complain
)
5345 tree init
= d
->cur
->value
;
5347 if (error_operand_p (init
))
5348 return error_mark_node
;
5350 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5351 && has_designator_problem (d
, complain
))
5352 return error_mark_node
;
5354 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5356 /* A complex type can be initialized from one or two initializers,
5357 but braces are not elided. */
5359 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5361 if (CONSTRUCTOR_NELTS (init
) > 2)
5363 if (complain
& tf_error
)
5364 error ("too many initializers for %qT", type
);
5366 return error_mark_node
;
5369 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5371 vec
<constructor_elt
, va_gc
> *v
= 0;
5372 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5373 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5374 if (has_designator_problem (d
, complain
))
5375 return error_mark_node
;
5377 init
= build_constructor (init_list_type_node
, v
);
5382 /* A non-aggregate type is always initialized with a single
5384 if (!CP_AGGREGATE_TYPE_P (type
))
5386 /* It is invalid to initialize a non-aggregate type with a
5387 brace-enclosed initializer before C++0x.
5388 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5389 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5390 a CONSTRUCTOR (with a record type). */
5391 if (TREE_CODE (init
) == CONSTRUCTOR
5392 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5394 if (SCALAR_TYPE_P (type
))
5396 if (complain
& tf_error
)
5397 error ("braces around scalar initializer for type %qT", type
);
5398 init
= error_mark_node
;
5401 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5408 /* "If T is a class type and the initializer list has a single element of
5409 type cv U, where U is T or a class derived from T, the object is
5410 initialized from that element." Even if T is an aggregate. */
5411 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5412 && first_initializer_p
5413 && d
->end
- d
->cur
== 1
5414 && reference_related_p (type
, TREE_TYPE (init
)))
5422 All implicit type conversions (clause _conv_) are considered when
5423 initializing the aggregate member with an initializer from an
5424 initializer-list. If the initializer can initialize a member,
5425 the member is initialized. Otherwise, if the member is itself a
5426 non-empty subaggregate, brace elision is assumed and the
5427 initializer is considered for the initialization of the first
5428 member of the subaggregate. */
5429 if (TREE_CODE (init
) != CONSTRUCTOR
5430 /* But don't try this for the first initializer, since that would be
5431 looking through the outermost braces; A a2 = { a1 }; is not a
5432 valid aggregate initialization. */
5433 && !first_initializer_p
5434 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5435 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5442 /* [dcl.init.string]
5444 A char array (whether plain char, signed char, or unsigned char)
5445 can be initialized by a string-literal (optionally enclosed in
5446 braces); a wchar_t array can be initialized by a wide
5447 string-literal (optionally enclosed in braces). */
5448 if (TREE_CODE (type
) == ARRAY_TYPE
5449 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5451 tree str_init
= init
;
5453 /* Strip one level of braces if and only if they enclose a single
5454 element (as allowed by [dcl.init.string]). */
5455 if (!first_initializer_p
5456 && TREE_CODE (str_init
) == CONSTRUCTOR
5457 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5459 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5462 /* If it's a string literal, then it's the initializer for the array
5463 as a whole. Otherwise, continue with normal initialization for
5464 array types (one value per array element). */
5465 if (TREE_CODE (str_init
) == STRING_CST
)
5467 if (has_designator_problem (d
, complain
))
5468 return error_mark_node
;
5474 /* The following cases are about aggregates. If we are not within a full
5475 initializer already, and there is not a CONSTRUCTOR, it means that there
5476 is a missing set of braces (that is, we are processing the case for
5477 which reshape_init exists). */
5478 if (!first_initializer_p
)
5480 if (TREE_CODE (init
) == CONSTRUCTOR
)
5482 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5483 /* There is no need to reshape pointer-to-member function
5484 initializers, as they are always constructed correctly
5485 by the front end. */
5487 else if (COMPOUND_LITERAL_P (init
))
5488 /* For a nested compound literal, there is no need to reshape since
5489 brace elision is not allowed. Even if we decided to allow it,
5490 we should add a call to reshape_init in finish_compound_literal,
5491 before calling digest_init, so changing this code would still
5492 not be necessary. */
5493 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5497 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5498 return reshape_init (type
, init
, complain
);
5502 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5506 /* Dispatch to specialized routines. */
5507 if (CLASS_TYPE_P (type
))
5508 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5509 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5510 return reshape_init_array (type
, d
, complain
);
5511 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5512 return reshape_init_vector (type
, d
, complain
);
5517 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5518 brace-enclosed aggregate initializer.
5520 INIT is the CONSTRUCTOR containing the list of initializers describing
5521 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5522 It may not presently match the shape of the TYPE; for example:
5524 struct S { int a; int b; };
5525 struct S a[] = { 1, 2, 3, 4 };
5527 Here INIT will hold a vector of four elements, rather than a
5528 vector of two elements, each itself a vector of two elements. This
5529 routine transforms INIT from the former form into the latter. The
5530 revised CONSTRUCTOR node is returned. */
5533 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5535 vec
<constructor_elt
, va_gc
> *v
;
5539 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5541 v
= CONSTRUCTOR_ELTS (init
);
5543 /* An empty constructor does not need reshaping, and it is always a valid
5545 if (vec_safe_is_empty (v
))
5548 /* Recurse on this CONSTRUCTOR. */
5550 d
.end
= d
.cur
+ v
->length ();
5552 new_init
= reshape_init_r (type
, &d
, true, complain
);
5553 if (new_init
== error_mark_node
)
5554 return error_mark_node
;
5556 /* Make sure all the element of the constructor were used. Otherwise,
5557 issue an error about exceeding initializers. */
5560 if (complain
& tf_error
)
5561 error ("too many initializers for %qT", type
);
5563 return error_mark_node
;
5569 /* Verify array initializer. Returns true if errors have been reported. */
5572 check_array_initializer (tree decl
, tree type
, tree init
)
5574 tree element_type
= TREE_TYPE (type
);
5576 /* The array type itself need not be complete, because the
5577 initializer may tell us how many elements are in the array.
5578 But, the elements of the array must be complete. */
5579 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5582 error ("elements of array %q#D have incomplete type", decl
);
5584 error ("elements of array %q#T have incomplete type", type
);
5587 /* A compound literal can't have variable size. */
5589 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5590 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5592 error ("variable-sized compound literal");
5598 /* Subroutine of check_initializer; args are passed down from that function.
5599 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5602 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5605 gcc_assert (stmts_are_full_exprs_p ());
5606 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5609 /* Verify INIT (the initializer for DECL), and record the
5610 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5611 grok_reference_init.
5613 If the return value is non-NULL, it is an expression that must be
5614 evaluated dynamically to initialize DECL. */
5617 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5619 tree type
= TREE_TYPE (decl
);
5620 tree init_code
= NULL
;
5623 /* Things that are going to be initialized need to have complete
5625 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5627 if (DECL_HAS_VALUE_EXPR_P (decl
))
5629 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5630 it doesn't have storage to be initialized. */
5631 gcc_assert (init
== NULL_TREE
);
5635 if (type
== error_mark_node
)
5636 /* We will have already complained. */
5639 if (TREE_CODE (type
) == ARRAY_TYPE
)
5641 if (check_array_initializer (decl
, type
, init
))
5644 else if (!COMPLETE_TYPE_P (type
))
5646 error ("%q#D has incomplete type", decl
);
5647 TREE_TYPE (decl
) = error_mark_node
;
5651 /* There is no way to make a variable-sized class type in GNU C++. */
5652 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5654 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5656 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5657 if (SCALAR_TYPE_P (type
))
5661 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5662 init
= build_zero_init (type
, NULL_TREE
, false);
5664 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5666 error ("scalar object %qD requires one element in initializer",
5668 TREE_TYPE (decl
) = error_mark_node
;
5674 if (TREE_CODE (decl
) == CONST_DECL
)
5676 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5678 DECL_INITIAL (decl
) = init
;
5680 gcc_assert (init
!= NULL_TREE
);
5683 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5685 else if (init
|| type_build_ctor_call (type
)
5686 || TREE_CODE (type
) == REFERENCE_TYPE
)
5688 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5690 init
= grok_reference_init (decl
, type
, init
, flags
);
5691 flags
|= LOOKUP_ALREADY_DIGESTED
;
5694 check_for_uninitialized_const_var (decl
);
5695 /* Do not reshape constructors of vectors (they don't need to be
5697 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5699 if (is_std_init_list (type
))
5701 init
= perform_implicit_conversion (type
, init
,
5702 tf_warning_or_error
);
5703 flags
|= LOOKUP_ALREADY_DIGESTED
;
5705 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5707 /* Don't reshape if the class has constructors. */
5708 if (cxx_dialect
== cxx98
)
5709 error ("in C++98 %qD must be initialized by constructor, "
5713 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5715 error ("opaque vector types cannot be initialized");
5716 init
= error_mark_node
;
5720 init
= reshape_init (type
, init
, tf_warning_or_error
);
5721 if (SCALAR_TYPE_P (type
))
5722 check_narrowing (type
, init
);
5726 /* If DECL has an array type without a specific bound, deduce the
5727 array size from the initializer. */
5728 maybe_deduce_size_from_array_init (decl
, init
);
5729 type
= TREE_TYPE (decl
);
5730 if (type
== error_mark_node
)
5733 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5734 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5735 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5736 && CP_AGGREGATE_TYPE_P (type
)
5737 && (CLASS_TYPE_P (type
)
5738 || !TYPE_NEEDS_CONSTRUCTING (type
)
5739 || type_has_extended_temps (type
))))
5741 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5743 /* A constructor call is a non-trivial initializer even if
5744 it isn't explicitly written. */
5745 if (TREE_SIDE_EFFECTS (init_code
))
5746 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5748 /* If this is a constexpr initializer, expand_default_init will
5749 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5750 case, pull the initializer back out and pass it down into
5751 store_init_value. */
5752 while (TREE_CODE (init_code
) == EXPR_STMT
5753 || TREE_CODE (init_code
) == CONVERT_EXPR
)
5754 init_code
= TREE_OPERAND (init_code
, 0);
5755 if (TREE_CODE (init_code
) == INIT_EXPR
)
5757 init
= TREE_OPERAND (init_code
, 1);
5758 init_code
= NULL_TREE
;
5759 /* Don't call digest_init; it's unnecessary and will complain
5760 about aggregate initialization of non-aggregate classes. */
5761 flags
|= LOOKUP_ALREADY_DIGESTED
;
5763 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
5765 /* Declared constexpr, but no suitable initializer; massage
5766 init appropriately so we can pass it into store_init_value
5768 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5769 init
= finish_compound_literal (type
, init
,
5770 tf_warning_or_error
);
5771 else if (CLASS_TYPE_P (type
)
5772 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
5774 init
= build_functional_cast (type
, init
, tf_none
);
5775 if (TREE_CODE (init
) == TARGET_EXPR
)
5776 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
5778 init_code
= NULL_TREE
;
5784 if (init
&& TREE_CODE (init
) != TREE_VEC
)
5786 /* In aggregate initialization of a variable, each element
5787 initialization is a full-expression because there is no
5788 enclosing expression. */
5789 gcc_assert (stmts_are_full_exprs_p ());
5791 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
5793 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5794 && DECL_INITIAL (decl
)
5795 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5796 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5797 warning (0, "array %qD initialized by parenthesized string literal %qE",
5798 decl
, DECL_INITIAL (decl
));
5804 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
5805 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
5806 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
5807 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
5810 check_for_uninitialized_const_var (decl
);
5813 if (init
&& init
!= error_mark_node
)
5814 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5816 if (init_code
&& DECL_IN_AGGR_P (decl
))
5818 static int explained
= 0;
5820 if (cxx_dialect
< cxx11
)
5821 error ("initializer invalid for static member with constructor");
5823 error ("non-constant in-class initialization invalid for static "
5824 "member %qD", decl
);
5827 inform (input_location
,
5828 "(an out of class initialization is required)");
5837 /* If DECL is not a local variable, give it RTL. */
5840 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5842 int toplev
= toplevel_bindings_p ();
5844 const char *filename
;
5846 /* Set the DECL_ASSEMBLER_NAME for the object. */
5849 /* The `register' keyword, when used together with an
5850 asm-specification, indicates that the variable should be
5851 placed in a particular register. */
5852 if (VAR_P (decl
) && DECL_REGISTER (decl
))
5854 set_user_assembler_name (decl
, asmspec
);
5855 DECL_HARD_REGISTER (decl
) = 1;
5859 if (TREE_CODE (decl
) == FUNCTION_DECL
5860 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5861 set_builtin_user_assembler_name (decl
, asmspec
);
5862 set_user_assembler_name (decl
, asmspec
);
5866 /* Handle non-variables up front. */
5869 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5873 /* If we see a class member here, it should be a static data
5875 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5877 gcc_assert (TREE_STATIC (decl
));
5878 /* An in-class declaration of a static data member should be
5879 external; it is only a declaration, and not a definition. */
5880 if (init
== NULL_TREE
)
5881 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5884 /* We don't create any RTL for local variables. */
5885 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5888 /* We defer emission of local statics until the corresponding
5889 DECL_EXPR is expanded. */
5890 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5892 /* We try to defer namespace-scope static constants so that they are
5893 not emitted into the object file unnecessarily. */
5894 filename
= LOCATION_FILE (input_location
);
5895 if (!DECL_VIRTUAL_P (decl
)
5896 && TREE_READONLY (decl
)
5897 && DECL_INITIAL (decl
) != NULL_TREE
5898 && DECL_INITIAL (decl
) != error_mark_node
5900 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5902 && !TREE_PUBLIC (decl
))
5904 /* Fool with the linkage of static consts according to #pragma
5906 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5907 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5909 TREE_PUBLIC (decl
) = 1;
5910 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5915 /* Likewise for template instantiations. */
5916 else if (DECL_LANG_SPECIFIC (decl
)
5917 && DECL_IMPLICIT_INSTANTIATION (decl
))
5920 /* If we're not deferring, go ahead and assemble the variable. */
5922 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5925 /* walk_tree helper for wrap_temporary_cleanups, below. */
5928 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5930 /* Stop at types or full-expression boundaries. */
5931 if (TYPE_P (*stmt_p
)
5932 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
5938 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5940 tree guard
= (tree
)data
;
5941 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5943 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5944 /* Tell honor_protect_cleanup_actions to handle this as a separate
5946 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5948 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5954 /* We're initializing a local variable which has a cleanup GUARD. If there
5955 are any temporaries used in the initializer INIT of this variable, we
5956 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5957 variable will be cleaned up properly if one of them throws.
5959 Unfortunately, there's no way to express this properly in terms of
5960 nesting, as the regions for the temporaries overlap the region for the
5961 variable itself; if there are two temporaries, the variable needs to be
5962 the first thing destroyed if either of them throws. However, we only
5963 want to run the variable's cleanup if it actually got constructed. So
5964 we need to guard the temporary cleanups with the variable's cleanup if
5965 they are run on the normal path, but not if they are run on the
5966 exceptional path. We implement this by telling
5967 honor_protect_cleanup_actions to strip the variable cleanup from the
5968 exceptional path. */
5971 wrap_temporary_cleanups (tree init
, tree guard
)
5973 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5976 /* Generate code to initialize DECL (a local variable). */
5979 initialize_local_var (tree decl
, tree init
)
5981 tree type
= TREE_TYPE (decl
);
5985 gcc_assert (VAR_P (decl
)
5986 || TREE_CODE (decl
) == RESULT_DECL
);
5987 gcc_assert (!TREE_STATIC (decl
));
5989 if (DECL_SIZE (decl
) == NULL_TREE
)
5991 /* If we used it already as memory, it must stay in memory. */
5992 DECL_INITIAL (decl
) = NULL_TREE
;
5993 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5997 if (type
== error_mark_node
)
6000 /* Compute and store the initial value. */
6001 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6002 if (TREE_USED (type
))
6003 DECL_READ_P (decl
) = 1;
6005 /* Generate a cleanup, if necessary. */
6006 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6008 /* Perform the initialization. */
6011 if (TREE_CODE (init
) == INIT_EXPR
6012 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init
, 1)))
6014 /* Stick simple initializers in DECL_INITIAL so that
6015 -Wno-init-self works (c++/34772). */
6016 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6017 DECL_INITIAL (decl
) = TREE_OPERAND (init
, 1);
6021 int saved_stmts_are_full_exprs_p
;
6023 /* If we're only initializing a single object, guard the
6024 destructors of any temporaries used in its initializer with
6025 its destructor. This isn't right for arrays because each
6026 element initialization is a full-expression. */
6027 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6028 wrap_temporary_cleanups (init
, cleanup
);
6030 gcc_assert (building_stmt_list_p ());
6031 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6032 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6033 finish_expr_stmt (init
);
6034 current_stmt_tree ()->stmts_are_full_exprs_p
=
6035 saved_stmts_are_full_exprs_p
;
6039 /* Set this to 0 so we can tell whether an aggregate which was
6040 initialized was ever used. Don't do this if it has a
6041 destructor, so we don't complain about the 'resource
6042 allocation is initialization' idiom. Now set
6043 attribute((unused)) on types so decls of that type will be
6044 marked used. (see TREE_USED, above.) */
6045 if (TYPE_NEEDS_CONSTRUCTING (type
)
6047 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6048 && DECL_NAME (decl
))
6049 TREE_USED (decl
) = 0;
6050 else if (already_used
)
6051 TREE_USED (decl
) = 1;
6054 finish_decl_cleanup (decl
, cleanup
);
6057 /* DECL is a VAR_DECL for a compiler-generated variable with static
6058 storage duration (like a virtual table) whose initializer is a
6059 compile-time constant. Initialize the variable and provide it to the
6063 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6066 gcc_assert (DECL_ARTIFICIAL (decl
));
6067 init
= build_constructor (TREE_TYPE (decl
), v
);
6068 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6069 DECL_INITIAL (decl
) = init
;
6070 DECL_INITIALIZED_P (decl
) = 1;
6071 determine_visibility (decl
);
6072 layout_var_decl (decl
);
6073 maybe_commonize_var (decl
);
6074 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6077 /* INIT is the initializer for a variable, as represented by the
6078 parser. Returns true iff INIT is type-dependent. */
6081 type_dependent_init_p (tree init
)
6083 if (TREE_CODE (init
) == TREE_LIST
)
6084 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6085 return any_type_dependent_elements_p (init
);
6086 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6087 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6089 vec
<constructor_elt
, va_gc
> *elts
;
6093 elts
= CONSTRUCTOR_ELTS (init
);
6094 nelts
= vec_safe_length (elts
);
6095 for (i
= 0; i
< nelts
; ++i
)
6096 if (type_dependent_init_p ((*elts
)[i
].value
))
6100 /* It must be a simple expression, e.g., int i = 3; */
6101 return type_dependent_expression_p (init
);
6106 /* INIT is the initializer for a variable, as represented by the
6107 parser. Returns true iff INIT is value-dependent. */
6110 value_dependent_init_p (tree init
)
6112 if (TREE_CODE (init
) == TREE_LIST
)
6113 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6114 return any_value_dependent_elements_p (init
);
6115 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6116 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6118 vec
<constructor_elt
, va_gc
> *elts
;
6122 elts
= CONSTRUCTOR_ELTS (init
);
6123 nelts
= vec_safe_length (elts
);
6124 for (i
= 0; i
< nelts
; ++i
)
6125 if (value_dependent_init_p ((*elts
)[i
].value
))
6129 /* It must be a simple expression, e.g., int i = 3; */
6130 return value_dependent_expression_p (init
);
6135 /* Finish processing of a declaration;
6136 install its line number and initial value.
6137 If the length of an array type is not known before,
6138 it must be determined now, from the initial value, or it is an error.
6140 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6141 true, then INIT is an integral constant expression.
6143 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6144 if the (init) syntax was used. */
6147 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6148 tree asmspec_tree
, int flags
)
6151 vec
<tree
, va_gc
> *cleanups
= NULL
;
6152 const char *asmspec
= NULL
;
6153 int was_readonly
= 0;
6154 bool var_definition_p
= false;
6157 if (decl
== error_mark_node
)
6162 error ("assignment (not initialization) in declaration");
6166 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6167 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6168 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6170 type
= TREE_TYPE (decl
);
6171 if (type
== error_mark_node
)
6174 /* If a name was specified, get the string. */
6175 if (at_namespace_scope_p ())
6176 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6177 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6178 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6180 if (current_class_type
6181 && CP_DECL_CONTEXT (decl
) == current_class_type
6182 && TYPE_BEING_DEFINED (current_class_type
)
6183 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6184 && (DECL_INITIAL (decl
) || init
))
6185 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6187 if (TREE_CODE (decl
) != FUNCTION_DECL
6188 && (auto_node
= type_uses_auto (type
)))
6191 if (init
== NULL_TREE
)
6193 if (DECL_LANG_SPECIFIC (decl
)
6194 && DECL_TEMPLATE_INSTANTIATION (decl
)
6195 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6197 /* init is null because we're deferring instantiating the
6198 initializer until we need it. Well, we need it now. */
6199 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6203 error ("declaration of %q#D has no initializer", decl
);
6204 TREE_TYPE (decl
) = error_mark_node
;
6208 if (TREE_CODE (d_init
) == TREE_LIST
)
6209 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6210 tf_warning_or_error
);
6211 d_init
= resolve_nondeduced_context (d_init
);
6212 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6214 if (type
== error_mark_node
)
6216 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6219 if (!ensure_literal_type_for_constexpr_object (decl
))
6220 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6223 && DECL_CLASS_SCOPE_P (decl
)
6224 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6225 check_static_variable_definition (decl
, type
);
6227 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6230 if (init
== ridpointers
[(int)RID_DELETE
])
6232 /* FIXME check this is 1st decl. */
6233 DECL_DELETED_FN (decl
) = 1;
6234 DECL_DECLARED_INLINE_P (decl
) = 1;
6235 DECL_INITIAL (decl
) = error_mark_node
;
6236 FOR_EACH_CLONE (clone
, decl
)
6238 DECL_DELETED_FN (clone
) = 1;
6239 DECL_DECLARED_INLINE_P (clone
) = 1;
6240 DECL_INITIAL (clone
) = error_mark_node
;
6244 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6246 if (defaultable_fn_check (decl
))
6247 DECL_DEFAULTED_FN (decl
) = 1;
6249 DECL_INITIAL (decl
) = NULL_TREE
;
6253 if (init
&& VAR_P (decl
))
6255 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6256 /* If DECL is a reference, then we want to know whether init is a
6257 reference constant; init_const_expr_p as passed tells us whether
6258 it's an rvalue constant. */
6259 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6260 init_const_expr_p
= potential_constant_expression (init
);
6261 if (init_const_expr_p
)
6263 /* Set these flags now for templates. We'll update the flags in
6264 store_init_value for instantiations. */
6265 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6266 if (decl_maybe_constant_var_p (decl
))
6267 TREE_CONSTANT (decl
) = 1;
6271 if (processing_template_decl
)
6273 bool type_dependent_p
;
6275 /* Add this declaration to the statement-tree. */
6276 if (at_function_scope_p ())
6277 add_decl_expr (decl
);
6279 type_dependent_p
= dependent_type_p (type
);
6281 if (check_for_bare_parameter_packs (init
))
6284 DECL_INITIAL (decl
) = NULL_TREE
;
6287 /* Generally, initializers in templates are expanded when the
6288 template is instantiated. But, if DECL is a variable constant
6289 then it can be used in future constant expressions, so its value
6290 must be available. */
6292 if (!VAR_P (decl
) || dependent_type_p (type
))
6293 /* We can't do anything if the decl has dependent type. */;
6295 && init_const_expr_p
6296 && !type_dependent_p
6297 && decl_maybe_constant_var_p (decl
)
6298 && !type_dependent_init_p (init
)
6299 && !value_dependent_init_p (init
))
6301 /* This variable seems to be a non-dependent constant, so process
6302 its initializer. If check_initializer returns non-null the
6303 initialization wasn't constant after all. */
6305 cleanups
= make_tree_vector ();
6306 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6307 if (init_code
== NULL_TREE
)
6309 release_tree_vector (cleanups
);
6311 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6313 /* Deduce array size even if the initializer is dependent. */
6314 maybe_deduce_size_from_array_init (decl
, init
);
6315 /* And complain about multiple initializers. */
6316 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6317 && !MAYBE_CLASS_TYPE_P (type
))
6318 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6319 tf_warning_or_error
);
6323 DECL_INITIAL (decl
) = init
;
6327 /* Just store non-static data member initializers for later. */
6328 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6329 DECL_INITIAL (decl
) = init
;
6331 /* Take care of TYPE_DECLs up front. */
6332 if (TREE_CODE (decl
) == TYPE_DECL
)
6334 if (type
!= error_mark_node
6335 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6337 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6338 warning (0, "shadowing previous type declaration of %q#D", decl
);
6339 set_identifier_type_value (DECL_NAME (decl
), decl
);
6342 /* If we have installed this as the canonical typedef for this
6343 type, and that type has not been defined yet, delay emitting
6344 the debug information for it, as we will emit it later. */
6345 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6346 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6347 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6349 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6354 /* A reference will be modified here, as it is initialized. */
6355 if (! DECL_EXTERNAL (decl
)
6356 && TREE_READONLY (decl
)
6357 && TREE_CODE (type
) == REFERENCE_TYPE
)
6360 TREE_READONLY (decl
) = 0;
6365 /* If this is a local variable that will need a mangled name,
6366 register it now. We must do this before processing the
6367 initializer for the variable, since the initialization might
6368 require a guard variable, and since the mangled name of the
6369 guard variable will depend on the mangled name of this
6371 if (DECL_FUNCTION_SCOPE_P (decl
)
6372 && TREE_STATIC (decl
)
6373 && !DECL_ARTIFICIAL (decl
))
6375 push_local_name (decl
);
6376 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6377 || DECL_DESTRUCTOR_P (current_function_decl
))
6378 /* Normally local_decls is populated during GIMPLE lowering,
6379 but [cd]tors are never actually compiled directly. We need
6380 to put statics on the list so we can deal with the label
6381 address extension. FIXME. */
6382 add_local_decl (cfun
, decl
);
6385 /* Convert the initializer to the type of DECL, if we have not
6386 already initialized DECL. */
6387 if (!DECL_INITIALIZED_P (decl
)
6388 /* If !DECL_EXTERNAL then DECL is being defined. In the
6389 case of a static data member initialized inside the
6390 class-specifier, there can be an initializer even if DECL
6391 is *not* defined. */
6392 && (!DECL_EXTERNAL (decl
) || init
))
6394 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6397 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6398 /* Allow libjava/prims.cc define primitive classes. */
6399 if (init
!= NULL_TREE
6400 || jclass
== NULL_TREE
6401 || TREE_CODE (jclass
) != TYPE_DECL
6402 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6403 || !same_type_ignoring_top_level_qualifiers_p
6404 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6405 error ("Java object %qD not allocated with %<new%>", decl
);
6408 cleanups
= make_tree_vector ();
6409 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6415 The memory occupied by any object of static storage
6416 duration is zero-initialized at program startup before
6417 any other initialization takes place.
6419 We cannot create an appropriate initializer until after
6420 the type of DECL is finalized. If DECL_INITIAL is set,
6421 then the DECL is statically initialized, and any
6422 necessary zero-initialization has already been performed. */
6423 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6424 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6425 /*nelts=*/NULL_TREE
,
6426 /*static_storage_p=*/true);
6427 /* Remember that the initialization for this variable has
6429 DECL_INITIALIZED_P (decl
) = 1;
6430 /* This declaration is the definition of this variable,
6431 unless we are initializing a static data member within
6432 the class specifier. */
6433 if (!DECL_EXTERNAL (decl
))
6434 var_definition_p
= true;
6436 /* If the variable has an array type, lay out the type, even if
6437 there is no initializer. It is valid to index through the
6438 array, and we must get TYPE_ALIGN set correctly on the array
6440 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6443 if (TREE_STATIC (decl
)
6444 && !at_function_scope_p ()
6445 && current_function_decl
== NULL
)
6446 /* So decl is a global variable or a static member of a
6447 non local class. Record the types it uses
6448 so that we can decide later to emit debug info for them. */
6449 record_types_used_by_current_var_decl (decl
);
6451 else if (TREE_CODE (decl
) == FIELD_DECL
6452 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6453 error ("non-static data member %qD has Java class type", decl
);
6455 /* Add this declaration to the statement-tree. This needs to happen
6456 after the call to check_initializer so that the DECL_EXPR for a
6457 reference temp is added before the DECL_EXPR for the reference itself. */
6458 if (DECL_FUNCTION_SCOPE_P (decl
))
6460 /* If we're building a variable sized type, and we might be
6461 reachable other than via the top of the current binding
6462 level, then create a new BIND_EXPR so that we deallocate
6463 the object at the right time. */
6466 && !TREE_CONSTANT (DECL_SIZE (decl
))
6467 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
6470 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6471 TREE_SIDE_EFFECTS (bind
) = 1;
6473 BIND_EXPR_BODY (bind
) = push_stmt_list ();
6475 add_decl_expr (decl
);
6478 /* Let the middle end know about variables and functions -- but not
6479 static data members in uninstantiated class templates. */
6480 if (VAR_OR_FUNCTION_DECL_P (decl
))
6484 layout_var_decl (decl
);
6485 maybe_commonize_var (decl
);
6488 /* This needs to happen after the linkage is set. */
6489 determine_visibility (decl
);
6491 if (var_definition_p
&& TREE_STATIC (decl
))
6493 /* If a TREE_READONLY variable needs initialization
6494 at runtime, it is no longer readonly and we need to
6495 avoid MEM_READONLY_P being set on RTL created for it. */
6498 if (TREE_READONLY (decl
))
6499 TREE_READONLY (decl
) = 0;
6502 else if (was_readonly
)
6503 TREE_READONLY (decl
) = 1;
6505 /* Likewise if it needs destruction. */
6506 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6507 TREE_READONLY (decl
) = 0;
6510 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6512 /* Check for abstractness of the type. Notice that there is no
6513 need to strip array types here since the check for those types
6514 is already done within create_array_type_for_decl. */
6515 abstract_virtuals_error (decl
, type
);
6517 if (TREE_TYPE (decl
) == error_mark_node
)
6518 /* No initialization required. */
6520 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6524 if (init
== ridpointers
[(int)RID_DEFAULT
])
6526 /* An out-of-class default definition is defined at
6527 the point where it is explicitly defaulted. */
6528 if (DECL_DELETED_FN (decl
))
6529 maybe_explain_implicit_delete (decl
);
6530 else if (DECL_INITIAL (decl
) == error_mark_node
)
6531 synthesize_method (decl
);
6534 error ("function %q#D is initialized like a variable", decl
);
6536 /* else no initialization required. */
6538 else if (DECL_EXTERNAL (decl
)
6539 && ! (DECL_LANG_SPECIFIC (decl
)
6540 && DECL_NOT_REALLY_EXTERN (decl
)))
6543 DECL_INITIAL (decl
) = init
;
6545 /* A variable definition. */
6546 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6547 /* Initialize the local variable. */
6548 initialize_local_var (decl
, init
);
6550 /* If a variable is defined, and then a subsequent
6551 definition with external linkage is encountered, we will
6552 get here twice for the same variable. We want to avoid
6553 calling expand_static_init more than once. For variables
6554 that are not static data members, we can call
6555 expand_static_init only when we actually process the
6556 initializer. It is not legal to redeclare a static data
6557 member, so this issue does not arise in that case. */
6558 else if (var_definition_p
&& TREE_STATIC (decl
))
6559 expand_static_init (decl
, init
);
6562 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6563 reference, insert it in the statement-tree now. */
6567 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6568 push_cleanup (decl
, t
, false);
6569 release_tree_vector (cleanups
);
6573 TREE_READONLY (decl
) = 1;
6575 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6578 /* Returns a declaration for a VAR_DECL as if:
6580 extern "C" TYPE NAME;
6582 had been seen. Used to create compiler-generated global
6586 declare_global_var (tree name
, tree type
)
6590 push_to_top_level ();
6591 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6592 TREE_PUBLIC (decl
) = 1;
6593 DECL_EXTERNAL (decl
) = 1;
6594 DECL_ARTIFICIAL (decl
) = 1;
6595 /* If the user has explicitly declared this variable (perhaps
6596 because the code we are compiling is part of a low-level runtime
6597 library), then it is possible that our declaration will be merged
6598 with theirs by pushdecl. */
6599 decl
= pushdecl (decl
);
6600 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6601 pop_from_top_level ();
6606 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6607 if "__cxa_atexit" is not being used) corresponding to the function
6608 to be called when the program exits. */
6611 get_atexit_fn_ptr_type (void)
6615 if (!atexit_fn_ptr_type_node
)
6618 if (flag_use_cxa_atexit
6619 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6620 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6621 arg_type
= ptr_type_node
;
6623 /* The parameter to "atexit" is "void (*)(void)". */
6624 arg_type
= NULL_TREE
;
6626 fn_type
= build_function_type_list (void_type_node
,
6627 arg_type
, NULL_TREE
);
6628 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6631 return atexit_fn_ptr_type_node
;
6634 /* Returns a pointer to the `atexit' function. Note that if
6635 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6636 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6639 get_atexit_node (void)
6645 bool use_aeabi_atexit
;
6650 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6652 /* The declaration for `__cxa_atexit' is:
6654 int __cxa_atexit (void (*)(void *), void *, void *)
6656 We build up the argument types and then the function type
6658 tree argtype0
, argtype1
, argtype2
;
6660 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6661 /* First, build the pointer-to-function type for the first
6663 fn_ptr_type
= get_atexit_fn_ptr_type ();
6664 /* Then, build the rest of the argument types. */
6665 argtype2
= ptr_type_node
;
6666 if (use_aeabi_atexit
)
6668 argtype1
= fn_ptr_type
;
6669 argtype0
= ptr_type_node
;
6673 argtype1
= ptr_type_node
;
6674 argtype0
= fn_ptr_type
;
6676 /* And the final __cxa_atexit type. */
6677 fn_type
= build_function_type_list (integer_type_node
,
6678 argtype0
, argtype1
, argtype2
,
6680 if (use_aeabi_atexit
)
6681 name
= "__aeabi_atexit";
6683 name
= "__cxa_atexit";
6687 /* The declaration for `atexit' is:
6689 int atexit (void (*)());
6691 We build up the argument types and then the function type
6693 fn_ptr_type
= get_atexit_fn_ptr_type ();
6694 /* Build the final atexit type. */
6695 fn_type
= build_function_type_list (integer_type_node
,
6696 fn_ptr_type
, NULL_TREE
);
6700 /* Now, build the function declaration. */
6701 push_lang_context (lang_name_c
);
6702 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
6703 mark_used (atexit_fndecl
);
6704 pop_lang_context ();
6705 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6710 /* Like get_atexit_node, but for thread-local cleanups. */
6713 get_thread_atexit_node (void)
6715 /* The declaration for `__cxa_thread_atexit' is:
6717 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6718 tree fn_type
= build_function_type_list (integer_type_node
,
6719 get_atexit_fn_ptr_type (),
6720 ptr_type_node
, ptr_type_node
,
6723 /* Now, build the function declaration. */
6724 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
6725 ECF_LEAF
| ECF_NOTHROW
);
6726 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6729 /* Returns the __dso_handle VAR_DECL. */
6732 get_dso_handle_node (void)
6734 if (dso_handle_node
)
6735 return dso_handle_node
;
6737 /* Declare the variable. */
6738 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6741 #ifdef HAVE_GAS_HIDDEN
6742 if (dso_handle_node
!= error_mark_node
)
6744 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6745 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6749 return dso_handle_node
;
6752 /* Begin a new function with internal linkage whose job will be simply
6753 to destroy some particular variable. */
6755 static GTY(()) int start_cleanup_cnt
;
6758 start_cleanup_fn (void)
6763 bool use_cxa_atexit
= flag_use_cxa_atexit
6764 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6766 push_to_top_level ();
6768 /* No need to mangle this. */
6769 push_lang_context (lang_name_c
);
6771 /* Build the name of the function. */
6772 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6773 /* Build the function declaration. */
6774 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6775 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6776 /* It's a function with internal linkage, generated by the
6778 TREE_PUBLIC (fndecl
) = 0;
6779 DECL_ARTIFICIAL (fndecl
) = 1;
6780 /* Make the function `inline' so that it is only emitted if it is
6781 actually needed. It is unlikely that it will be inlined, since
6782 it is only called via a function pointer, but we avoid unnecessary
6783 emissions this way. */
6784 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6785 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6786 /* Build the parameter. */
6791 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6792 DECL_CONTEXT (parmdecl
) = fndecl
;
6793 TREE_USED (parmdecl
) = 1;
6794 DECL_READ_P (parmdecl
) = 1;
6795 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6799 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6801 pop_lang_context ();
6803 return current_function_decl
;
6806 /* Finish the cleanup function begun by start_cleanup_fn. */
6809 end_cleanup_fn (void)
6811 expand_or_defer_fn (finish_function (0));
6813 pop_from_top_level ();
6816 /* Generate code to handle the destruction of DECL, an object with
6817 static storage duration. */
6820 register_dtor_fn (tree decl
)
6827 bool ob_parm
, dso_parm
, use_dtor
;
6828 tree arg0
, arg1
, arg2
;
6831 type
= TREE_TYPE (decl
);
6832 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6833 return void_zero_node
;
6835 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
6836 "__aeabi_atexit"), and DECL is a class object, we can just pass the
6837 destructor to "__cxa_atexit"; we don't have to build a temporary
6838 function to do the cleanup. */
6839 dso_parm
= (flag_use_cxa_atexit
6840 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
6841 ob_parm
= (DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
6842 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
6847 /* Find the destructor. */
6848 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6849 gcc_assert (idx
>= 0);
6850 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
6851 /* Make sure it is accessible. */
6852 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
6853 tf_warning_or_error
);
6857 /* Call build_cleanup before we enter the anonymous function so
6858 that any access checks will be done relative to the current
6859 scope, rather than the scope of the anonymous function. */
6860 build_cleanup (decl
);
6862 /* Now start the function. */
6863 cleanup
= start_cleanup_fn ();
6865 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6866 to the original function, rather than the anonymous one. That
6867 will make the back end think that nested functions are in use,
6868 which causes confusion. */
6869 push_deferring_access_checks (dk_no_check
);
6870 fcall
= build_cleanup (decl
);
6871 pop_deferring_access_checks ();
6873 /* Create the body of the anonymous function. */
6874 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6875 finish_expr_stmt (fcall
);
6876 finish_compound_stmt (compound_stmt
);
6880 /* Call atexit with the cleanup function. */
6881 mark_used (cleanup
);
6882 cleanup
= build_address (cleanup
);
6884 if (DECL_THREAD_LOCAL_P (decl
))
6885 atex_node
= get_thread_atexit_node ();
6887 atex_node
= get_atexit_node ();
6891 /* We must convert CLEANUP to the type that "__cxa_atexit"
6893 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6894 /* "__cxa_atexit" will pass the address of DECL to the
6895 cleanup function. */
6897 addr
= build_address (decl
);
6898 /* The declared type of the parameter to "__cxa_atexit" is
6899 "void *". For plain "T*", we could just let the
6900 machinery in cp_build_function_call convert it -- but if the
6901 type is "cv-qualified T *", then we need to convert it
6902 before passing it in, to avoid spurious errors. */
6903 addr
= build_nop (ptr_type_node
, addr
);
6906 /* Since the cleanup functions we build ignore the address
6907 they're given, there's no reason to pass the actual address
6908 in, and, in general, it's cheaper to pass NULL than any
6910 addr
= null_pointer_node
;
6913 arg2
= cp_build_addr_expr (get_dso_handle_node (),
6914 tf_warning_or_error
);
6916 /* Just pass NULL to the dso handle parm if we don't actually
6917 have a DSO handle on this target. */
6918 arg2
= null_pointer_node
;
6924 if (!DECL_THREAD_LOCAL_P (decl
)
6925 && targetm
.cxx
.use_aeabi_atexit ())
6941 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
6942 arg0
, arg1
, arg2
, NULL_TREE
);
6945 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6946 is its initializer. Generate code to handle the construction
6947 and destruction of DECL. */
6950 expand_static_init (tree decl
, tree init
)
6952 gcc_assert (VAR_P (decl
));
6953 gcc_assert (TREE_STATIC (decl
));
6955 /* Some variables require no dynamic initialization. */
6957 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6959 /* Make sure the destructor is callable. */
6960 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6964 if (DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
6965 && !DECL_FUNCTION_SCOPE_P (decl
))
6968 error ("non-local variable %qD declared %<__thread%> "
6969 "needs dynamic initialization", decl
);
6971 error ("non-local variable %qD declared %<__thread%> "
6972 "has a non-trivial destructor", decl
);
6973 static bool informed
;
6976 inform (DECL_SOURCE_LOCATION (decl
),
6977 "C++11 %<thread_local%> allows dynamic initialization "
6984 if (DECL_FUNCTION_SCOPE_P (decl
))
6986 /* Emit code to perform this initialization but once. */
6987 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6988 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6989 tree guard
, guard_addr
;
6991 /* We don't need thread-safety code for thread-local vars. */
6992 bool thread_guard
= (flag_threadsafe_statics
6993 && !DECL_THREAD_LOCAL_P (decl
));
6995 /* Emit code to perform this initialization but once. This code
6998 static <type> guard;
6999 if (!guard.first_byte) {
7000 if (__cxa_guard_acquire (&guard)) {
7003 // Do initialization.
7004 flag = true; __cxa_guard_release (&guard);
7005 // Register variable for destruction at end of program.
7007 if (!flag) __cxa_guard_abort (&guard);
7011 Note that the `flag' variable is only set to 1 *after* the
7012 initialization is complete. This ensures that an exception,
7013 thrown during the construction, will cause the variable to
7014 reinitialized when we pass through this code again, as per:
7018 If the initialization exits by throwing an exception, the
7019 initialization is not complete, so it will be tried again
7020 the next time control enters the declaration.
7022 This process should be thread-safe, too; multiple threads
7023 should not be able to initialize the variable more than
7026 /* Create the guard variable. */
7027 guard
= get_guard (decl
);
7029 /* This optimization isn't safe on targets with relaxed memory
7030 consistency. On such targets we force synchronization in
7031 __cxa_guard_acquire. */
7032 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7034 /* Begin the conditional initialization. */
7035 if_stmt
= begin_if_stmt ();
7036 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
7037 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7042 tree vfntype
= NULL_TREE
;
7043 tree acquire_name
, release_name
, abort_name
;
7044 tree acquire_fn
, release_fn
, abort_fn
;
7045 guard_addr
= build_address (guard
);
7047 acquire_name
= get_identifier ("__cxa_guard_acquire");
7048 release_name
= get_identifier ("__cxa_guard_release");
7049 abort_name
= get_identifier ("__cxa_guard_abort");
7050 acquire_fn
= identifier_global_value (acquire_name
);
7051 release_fn
= identifier_global_value (release_name
);
7052 abort_fn
= identifier_global_value (abort_name
);
7054 acquire_fn
= push_library_fn
7055 (acquire_name
, build_function_type_list (integer_type_node
,
7056 TREE_TYPE (guard_addr
),
7058 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7059 if (!release_fn
|| !abort_fn
)
7060 vfntype
= build_function_type_list (void_type_node
,
7061 TREE_TYPE (guard_addr
),
7064 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7065 ECF_NOTHROW
| ECF_LEAF
);
7067 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7068 ECF_NOTHROW
| ECF_LEAF
);
7070 inner_if_stmt
= begin_if_stmt ();
7071 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7074 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7075 begin
= get_target_expr (boolean_false_node
);
7076 flag
= TARGET_EXPR_SLOT (begin
);
7078 TARGET_EXPR_CLEANUP (begin
)
7079 = build3 (COND_EXPR
, void_type_node
, flag
,
7081 build_call_n (abort_fn
, 1, guard_addr
));
7082 CLEANUP_EH_ONLY (begin
) = 1;
7084 /* Do the initialization itself. */
7085 init
= add_stmt_to_compound (begin
, init
);
7086 init
= add_stmt_to_compound
7087 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7088 init
= add_stmt_to_compound
7089 (init
, build_call_n (release_fn
, 1, guard_addr
));
7092 init
= add_stmt_to_compound (init
, set_guard (guard
));
7094 /* Use atexit to register a function for destroying this static
7096 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7098 finish_expr_stmt (init
);
7102 finish_compound_stmt (inner_then_clause
);
7103 finish_then_clause (inner_if_stmt
);
7104 finish_if_stmt (inner_if_stmt
);
7107 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7109 finish_compound_stmt (then_clause
);
7110 finish_then_clause (if_stmt
);
7111 finish_if_stmt (if_stmt
);
7114 else if (DECL_THREAD_LOCAL_P (decl
))
7115 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7117 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7121 /* Make TYPE a complete type based on INITIAL_VALUE.
7122 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7123 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7124 3 if the initializer list is empty (in pedantic mode). */
7127 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7130 tree type
, elt_type
;
7132 /* Don't get confused by a CONSTRUCTOR for some other type. */
7133 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
7134 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
))
7139 unsigned HOST_WIDE_INT i
;
7142 /* An array of character type can be initialized from a
7143 brace-enclosed string constant.
7145 FIXME: this code is duplicated from reshape_init. Probably
7146 we should just call reshape_init here? */
7147 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7148 && TREE_CODE (initial_value
) == CONSTRUCTOR
7149 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7151 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7152 tree value
= (*v
)[0].value
;
7154 if (TREE_CODE (value
) == STRING_CST
7155 && v
->length () == 1)
7156 initial_value
= value
;
7159 /* If any of the elements are parameter packs, we can't actually
7160 complete this type now because the array size is dependent. */
7161 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7163 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7166 if (PACK_EXPANSION_P (value
))
7172 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7174 /* We can create the array before the element type is complete, which
7175 means that we didn't have these two bits set in the original type
7176 either. In completing the type, we are expected to propagate these
7177 bits. See also complete_type which does the same thing for arrays
7180 if (TYPE_DOMAIN (type
))
7182 elt_type
= TREE_TYPE (type
);
7183 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7184 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7185 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7191 /* As above, but either give an error or reject zero-size arrays, depending
7195 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7196 bool do_default
, tsubst_flags_t complain
)
7199 bool sfinae
= !(complain
& tf_error
);
7200 /* In SFINAE context we can't be lenient about zero-size arrays. */
7203 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7209 /* Not an error. */;
7210 else if (failure
== 1)
7211 error ("initializer fails to determine size of %qT", *ptype
);
7212 else if (failure
== 2)
7215 error ("array size missing in %qT", *ptype
);
7217 else if (failure
== 3)
7218 error ("zero-size array %qT", *ptype
);
7219 *ptype
= error_mark_node
;
7224 /* Return zero if something is declared to be a member of type
7225 CTYPE when in the context of CUR_TYPE. STRING is the error
7226 message to print in that case. Otherwise, quietly return 1. */
7229 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7231 if (ctype
&& ctype
!= cur_type
)
7233 if (flags
== DTOR_FLAG
)
7234 error ("destructor for alien class %qT cannot be a member", ctype
);
7236 error ("constructor for alien class %qT cannot be a member", ctype
);
7242 /* Subroutine of `grokdeclarator'. */
7244 /* Generate errors possibly applicable for a given set of specifiers.
7245 This is for ARM $7.1.2. */
7248 bad_specifiers (tree object
,
7249 enum bad_spec_place type
,
7260 error ("%qD declared as a %<virtual%> variable", object
);
7262 error ("%qD declared as an %<inline%> variable", object
);
7264 error ("%<const%> and %<volatile%> function specifiers on "
7265 "%qD invalid in variable declaration", object
);
7269 error ("%qD declared as a %<virtual%> parameter", object
);
7271 error ("%qD declared as an %<inline%> parameter", object
);
7273 error ("%<const%> and %<volatile%> function specifiers on "
7274 "%qD invalid in parameter declaration", object
);
7278 error ("%qD declared as a %<virtual%> type", object
);
7280 error ("%qD declared as an %<inline%> type", object
);
7282 error ("%<const%> and %<volatile%> function specifiers on "
7283 "%qD invalid in type declaration", object
);
7287 error ("%qD declared as a %<virtual%> field", object
);
7289 error ("%qD declared as an %<inline%> field", object
);
7291 error ("%<const%> and %<volatile%> function specifiers on "
7292 "%qD invalid in field declaration", object
);
7298 error ("%q+D declared as a friend", object
);
7300 && (TREE_CODE (object
) == TYPE_DECL
7301 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7302 && !TYPE_REFFN_P (TREE_TYPE (object
))
7303 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7304 error ("%q+D declared with an exception specification", object
);
7307 /* DECL is a member function or static data member and is presently
7308 being defined. Check that the definition is taking place in a
7312 check_class_member_definition_namespace (tree decl
)
7314 /* These checks only apply to member functions and static data
7316 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7317 /* We check for problems with specializations in pt.c in
7318 check_specialization_namespace, where we can issue better
7320 if (processing_specialization
)
7322 /* There are no restrictions on the placement of
7323 explicit instantiations. */
7324 if (processing_explicit_instantiation
)
7328 A member function definition that appears outside of the
7329 class definition shall appear in a namespace scope enclosing
7330 the class definition.
7334 The definition for a static data member shall appear in a
7335 namespace scope enclosing the member's class definition. */
7336 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7337 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7338 decl
, DECL_CONTEXT (decl
));
7341 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7342 METHOD_TYPE for a non-static member function; QUALS are the
7343 cv-qualifiers that apply to the function. */
7346 build_this_parm (tree type
, cp_cv_quals quals
)
7351 cp_cv_quals this_quals
;
7353 if (CLASS_TYPE_P (type
))
7356 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7357 this_type
= build_pointer_type (this_type
);
7360 this_type
= type_of_this_parm (type
);
7361 /* The `this' parameter is implicitly `const'; it cannot be
7363 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7364 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7365 parm
= build_artificial_parm (this_identifier
, qual_type
);
7366 cp_apply_type_quals_to_decl (this_quals
, parm
);
7370 /* DECL is a static member function. Complain if it was declared
7371 with function-cv-quals. */
7374 check_static_quals (tree decl
, cp_cv_quals quals
)
7376 if (quals
!= TYPE_UNQUALIFIED
)
7377 error ("static member function %q#D declared with type qualifiers",
7381 /* Helper function. Replace the temporary this parameter injected
7382 during cp_finish_omp_declare_simd with the real this parameter. */
7385 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7387 tree this_parm
= (tree
) data
;
7388 if (TREE_CODE (*tp
) == PARM_DECL
7389 && DECL_NAME (*tp
) == this_identifier
7390 && *tp
!= this_parm
)
7392 else if (TYPE_P (*tp
))
7397 /* CTYPE is class type, or null if non-class.
7398 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7400 DECLARATOR is the function's name.
7401 PARMS is a chain of PARM_DECLs for the function.
7402 VIRTUALP is truthvalue of whether the function is virtual or not.
7403 FLAGS are to be passed through to `grokclassfn'.
7404 QUALS are qualifiers indicating whether the function is `const'
7406 RAISES is a list of exceptions that this function can raise.
7407 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7408 not look, and -1 if we should not call `grokclassfn' at all.
7410 SFK is the kind of special function (if any) for the new function.
7412 Returns `NULL_TREE' if something goes wrong, after issuing
7413 applicable error messages. */
7416 grokfndecl (tree ctype
,
7420 tree orig_declarator
,
7422 enum overload_flags flags
,
7424 cp_ref_qualifier rqual
,
7430 special_function_kind sfk
,
7435 location_t location
)
7438 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7442 type
= build_ref_qualified_type (type
, rqual
);
7444 type
= build_exception_variant (type
, raises
);
7446 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7448 /* If we have an explicit location, use it, otherwise use whatever
7449 build_lang_decl used (probably input_location). */
7450 if (location
!= UNKNOWN_LOCATION
)
7451 DECL_SOURCE_LOCATION (decl
) = location
;
7453 if (TREE_CODE (type
) == METHOD_TYPE
)
7456 parm
= build_this_parm (type
, quals
);
7457 DECL_CHAIN (parm
) = parms
;
7460 DECL_ARGUMENTS (decl
) = parms
;
7461 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7462 DECL_CONTEXT (t
) = decl
;
7463 /* Propagate volatile out from type to decl. */
7464 if (TYPE_VOLATILE (type
))
7465 TREE_THIS_VOLATILE (decl
) = 1;
7467 /* Setup decl according to sfk. */
7470 case sfk_constructor
:
7471 case sfk_copy_constructor
:
7472 case sfk_move_constructor
:
7473 DECL_CONSTRUCTOR_P (decl
) = 1;
7475 case sfk_destructor
:
7476 DECL_DESTRUCTOR_P (decl
) = 1;
7482 /* If pointers to member functions use the least significant bit to
7483 indicate whether a function is virtual, ensure a pointer
7484 to this function will have that bit clear. */
7485 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7486 && TREE_CODE (type
) == METHOD_TYPE
7487 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7488 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7491 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7495 ("defining explicit specialization %qD in friend declaration",
7499 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7500 tree args
= TREE_OPERAND (orig_declarator
, 1);
7502 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7504 /* Something like `template <class T> friend void f<T>()'. */
7505 error ("invalid use of template-id %qD in declaration "
7506 "of primary template",
7512 /* A friend declaration of the form friend void f<>(). Record
7513 the information in the TEMPLATE_ID_EXPR. */
7514 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7516 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7517 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7519 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7520 if (TREE_PURPOSE (t
)
7521 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7523 error ("default arguments are not allowed in declaration "
7524 "of friend template specialization %qD",
7530 error ("%<inline%> is not allowed in declaration of friend "
7531 "template specialization %qD",
7534 error ("%<constexpr%> is not allowed in declaration of friend "
7535 "template specialization %qD",
7542 /* If this decl has namespace scope, set that up. */
7544 set_decl_namespace (decl
, in_namespace
, friendp
);
7546 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7548 /* `main' and builtins have implicit 'C' linkage. */
7549 if ((MAIN_NAME_P (declarator
)
7550 || (IDENTIFIER_LENGTH (declarator
) > 10
7551 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7552 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7553 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
7554 || (targetcm
.cxx_implicit_extern_c
7555 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
7556 && current_lang_name
== lang_name_cplusplus
7557 && ctype
== NULL_TREE
7558 && DECL_FILE_SCOPE_P (decl
))
7559 SET_DECL_LANGUAGE (decl
, lang_c
);
7561 /* Should probably propagate const out from type to decl I bet (mrs). */
7564 DECL_STATIC_FUNCTION_P (decl
) = 1;
7565 DECL_CONTEXT (decl
) = ctype
;
7570 DECL_CONTEXT (decl
) = ctype
;
7572 check_class_member_definition_namespace (decl
);
7575 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7577 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7578 error ("cannot declare %<::main%> to be a template");
7580 error ("cannot declare %<::main%> to be inline");
7582 error ("cannot declare %<::main%> to be constexpr");
7584 error ("cannot declare %<::main%> to be static");
7589 /* Members of anonymous types and local classes have no linkage; make
7590 them internal. If a typedef is made later, this will be changed. */
7591 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
7592 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7595 if (publicp
&& cxx_dialect
== cxx98
)
7597 /* [basic.link]: A name with no linkage (notably, the name of a class
7598 or enumeration declared in a local scope) shall not be used to
7599 declare an entity with linkage.
7601 DR 757 relaxes this restriction for C++0x. */
7602 no_linkage_error (decl
);
7605 TREE_PUBLIC (decl
) = publicp
;
7608 DECL_INTERFACE_KNOWN (decl
) = 1;
7609 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7612 /* If the declaration was declared inline, mark it as such. */
7614 DECL_DECLARED_INLINE_P (decl
) = 1;
7616 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7618 DECL_EXTERNAL (decl
) = 1;
7619 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7624 ? G_("static member function %qD cannot have cv-qualifier")
7625 : G_("non-member function %qD cannot have cv-qualifier"),
7627 quals
= TYPE_UNQUALIFIED
;
7633 ? G_("static member function %qD cannot have ref-qualifier")
7634 : G_("non-member function %qD cannot have ref-qualifier"),
7636 rqual
= REF_QUAL_NONE
;
7640 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7641 && !grok_op_properties (decl
, /*complain=*/true))
7643 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7645 bool long_long_unsigned_p
;
7647 const char *suffix
= NULL
;
7648 /* [over.literal]/6: Literal operators shall not have C linkage. */
7649 if (DECL_LANGUAGE (decl
) == lang_c
)
7651 error ("literal operator with C linkage");
7655 if (DECL_NAMESPACE_SCOPE_P (decl
))
7657 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7660 error ("%qD has invalid argument list", decl
);
7664 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7665 if (long_long_unsigned_p
)
7667 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7668 warning (0, "integer suffix %<%s%>"
7669 " shadowed by implementation", suffix
);
7671 else if (long_double_p
)
7673 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7674 warning (0, "floating point suffix %<%s%>"
7675 " shadowed by implementation", suffix
);
7680 error ("%qD must be a non-member function", decl
);
7686 /* Make the init_value nonzero so pushdecl knows this is not
7687 tentative. error_mark_node is replaced later with the BLOCK. */
7688 DECL_INITIAL (decl
) = error_mark_node
;
7690 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7691 TREE_NOTHROW (decl
) = 1;
7693 if (flag_openmp
|| flag_cilkplus
)
7695 /* Adjust "omp declare simd" attributes. */
7696 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
7700 for (attr
= ods
; attr
;
7701 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
7703 if (TREE_CODE (type
) == METHOD_TYPE
)
7704 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
7705 DECL_ARGUMENTS (decl
), NULL
);
7706 if (TREE_VALUE (attr
) != NULL_TREE
)
7708 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
7709 cl
= c_omp_declare_simd_clauses_to_numbers
7710 (DECL_ARGUMENTS (decl
), cl
);
7712 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
7714 TREE_VALUE (attr
) = NULL_TREE
;
7720 /* Caller will do the rest of this. */
7724 if (ctype
!= NULL_TREE
)
7725 grokclassfn (ctype
, decl
, flags
);
7728 if (cxx_dialect
>= cxx11
7729 && DECL_DESTRUCTOR_P (decl
)
7730 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7731 && !processing_template_decl
)
7732 deduce_noexcept_on_destructor (decl
);
7734 decl
= check_explicit_specialization (orig_declarator
, decl
,
7737 4 * (friendp
!= 0));
7738 if (decl
== error_mark_node
)
7741 if (DECL_STATIC_FUNCTION_P (decl
))
7742 check_static_quals (decl
, quals
);
7746 cplus_decl_attributes (&decl
, *attrlist
, 0);
7747 *attrlist
= NULL_TREE
;
7750 /* Check main's type after attributes have been applied. */
7751 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7753 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7756 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7758 error ("%<::main%> must return %<int%>");
7759 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7760 TREE_TYPE (decl
) = newtype
;
7763 check_main_parameter_types (decl
);
7766 if (ctype
!= NULL_TREE
7767 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
7770 tree old_decl
= check_classfn (ctype
, decl
,
7771 (processing_template_decl
7772 > template_class_depth (ctype
))
7773 ? current_template_parms
7776 if (old_decl
== error_mark_node
)
7784 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
7785 /* Because grokfndecl is always supposed to return a
7786 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7787 here. We depend on our callers to figure out that its
7788 really a template that's being returned. */
7789 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
7791 if (DECL_STATIC_FUNCTION_P (old_decl
)
7792 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7794 /* Remove the `this' parm added by grokclassfn. */
7795 revert_static_member_fn (decl
);
7796 check_static_quals (decl
, quals
);
7798 if (DECL_ARTIFICIAL (old_decl
))
7800 error ("definition of implicitly-declared %qD", old_decl
);
7803 else if (DECL_DEFAULTED_FN (old_decl
))
7805 error ("definition of explicitly-defaulted %q+D", decl
);
7806 error ("%q+#D explicitly defaulted here", old_decl
);
7810 /* Since we've smashed OLD_DECL to its
7811 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7812 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7813 decl
= DECL_TEMPLATE_RESULT (decl
);
7815 /* Attempt to merge the declarations. This can fail, in
7816 the case of some invalid specialization declarations. */
7817 pushed_scope
= push_scope (ctype
);
7818 ok
= duplicate_decls (decl
, old_decl
, friendp
);
7820 pop_scope (pushed_scope
);
7823 error ("no %q#D member function declared in class %qT",
7827 if (ok
== error_mark_node
)
7833 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
7836 if (ctype
== NULL_TREE
|| check
)
7840 DECL_VIRTUAL_P (decl
) = 1;
7845 /* decl is a FUNCTION_DECL.
7846 specifiers are the parsed virt-specifiers.
7848 Set flags to reflect the virt-specifiers.
7853 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
7855 if (decl
== NULL_TREE
)
7857 if (specifiers
& VIRT_SPEC_OVERRIDE
)
7858 DECL_OVERRIDE_P (decl
) = 1;
7859 if (specifiers
& VIRT_SPEC_FINAL
)
7860 DECL_FINAL_P (decl
) = 1;
7864 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7865 the linkage that DECL will receive in the object file. */
7868 set_linkage_for_static_data_member (tree decl
)
7870 /* A static data member always has static storage duration and
7871 external linkage. Note that static data members are forbidden in
7872 local classes -- the only situation in which a class has
7873 non-external linkage. */
7874 TREE_PUBLIC (decl
) = 1;
7875 TREE_STATIC (decl
) = 1;
7876 /* For non-template classes, static data members are always put
7877 out in exactly those files where they are defined, just as
7878 with ordinary namespace-scope variables. */
7879 if (!processing_template_decl
)
7880 DECL_INTERFACE_KNOWN (decl
) = 1;
7883 /* Create a VAR_DECL named NAME with the indicated TYPE.
7885 If SCOPE is non-NULL, it is the class type or namespace containing
7886 the variable. If SCOPE is NULL, the variable should is created in
7887 the innermost enclosing scope. */
7890 grokvardecl (tree type
,
7892 const cp_decl_specifier_seq
*declspecs
,
7898 tree explicit_scope
;
7900 gcc_assert (!name
|| identifier_p (name
));
7902 /* Compute the scope in which to place the variable, but remember
7903 whether or not that scope was explicitly specified by the user. */
7904 explicit_scope
= scope
;
7907 /* An explicit "extern" specifier indicates a namespace-scope
7909 if (declspecs
->storage_class
== sc_extern
)
7910 scope
= current_decl_namespace ();
7911 else if (!at_function_scope_p ())
7912 scope
= current_scope ();
7916 && (/* If the variable is a namespace-scope variable declared in a
7917 template, we need DECL_LANG_SPECIFIC. */
7918 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
7919 /* Similarly for namespace-scope variables with language linkage
7921 || (TREE_CODE (scope
) == NAMESPACE_DECL
7922 && current_lang_name
!= lang_name_cplusplus
)
7923 /* Similarly for static data members. */
7925 decl
= build_lang_decl (VAR_DECL
, name
, type
);
7927 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7929 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
7930 set_decl_namespace (decl
, explicit_scope
, 0);
7932 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
7934 if (declspecs
->storage_class
== sc_extern
)
7936 DECL_THIS_EXTERN (decl
) = 1;
7937 DECL_EXTERNAL (decl
) = !initialized
;
7940 if (DECL_CLASS_SCOPE_P (decl
))
7942 set_linkage_for_static_data_member (decl
);
7943 /* This function is only called with out-of-class definitions. */
7944 DECL_EXTERNAL (decl
) = 0;
7945 check_class_member_definition_namespace (decl
);
7947 /* At top level, either `static' or no s.c. makes a definition
7948 (perhaps tentative), and absence of `static' makes it public. */
7949 else if (toplevel_bindings_p ())
7951 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
7952 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7953 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7955 /* Not at top level, only `static' makes a static definition. */
7958 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
7959 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7962 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
7964 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
7965 if (declspecs
->gnu_thread_keyword_p
)
7966 DECL_GNU_TLS_P (decl
) = true;
7969 /* If the type of the decl has no linkage, make sure that we'll
7970 notice that in mark_used. */
7971 if (cxx_dialect
> cxx98
7972 && decl_linkage (decl
) != lk_none
7973 && DECL_LANG_SPECIFIC (decl
) == NULL
7974 && !DECL_EXTERN_C_P (decl
)
7975 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
7976 retrofit_lang_decl (decl
);
7978 if (TREE_PUBLIC (decl
))
7980 /* [basic.link]: A name with no linkage (notably, the name of a class
7981 or enumeration declared in a local scope) shall not be used to
7982 declare an entity with linkage.
7984 DR 757 relaxes this restriction for C++0x. */
7985 if (cxx_dialect
< cxx11
)
7986 no_linkage_error (decl
);
7989 DECL_INTERFACE_KNOWN (decl
) = 1;
7994 /* Create and return a canonical pointer to member function type, for
7995 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7998 build_ptrmemfunc_type (tree type
)
8002 tree unqualified_variant
= NULL_TREE
;
8004 if (type
== error_mark_node
)
8007 /* If a canonical type already exists for this type, use it. We use
8008 this method instead of type_hash_canon, because it only does a
8009 simple equality check on the list of field members. */
8011 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8014 /* Make sure that we always have the unqualified pointer-to-member
8016 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
8018 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8020 t
= make_class_type (RECORD_TYPE
);
8021 xref_basetypes (t
, NULL_TREE
);
8023 /* Let the front end know this is a pointer to member function... */
8024 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8025 /* ... and not really a class type. */
8026 SET_CLASS_TYPE_P (t
, 0);
8028 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8031 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8033 DECL_CHAIN (field
) = fields
;
8036 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8038 /* Zap out the name so that the back end will give us the debugging
8039 information for this anonymous RECORD_TYPE. */
8040 TYPE_NAME (t
) = NULL_TREE
;
8042 /* If this is not the unqualified form of this pointer-to-member
8043 type, set the TYPE_MAIN_VARIANT for this type to be the
8044 unqualified type. Since they are actually RECORD_TYPEs that are
8045 not variants of each other, we must do this manually.
8046 As we just built a new type there is no need to do yet another copy. */
8047 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
8049 int type_quals
= cp_type_quals (type
);
8050 TYPE_READONLY (t
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
8051 TYPE_VOLATILE (t
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
8052 TYPE_RESTRICT (t
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
8053 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
8054 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
8055 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
8056 TREE_TYPE (TYPE_BINFO (t
)) = t
;
8059 /* Cache this pointer-to-member type so that we can find it again
8061 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8063 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8064 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8065 else if (TYPE_CANONICAL (type
) != type
)
8066 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8071 /* Create and return a pointer to data member type. */
8074 build_ptrmem_type (tree class_type
, tree member_type
)
8076 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8078 cp_cv_quals quals
= type_memfn_quals (member_type
);
8079 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8080 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8081 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8085 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8086 return build_offset_type (class_type
, member_type
);
8090 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8091 Check to see that the definition is valid. Issue appropriate error
8092 messages. Return 1 if the definition is particularly bad, or 0
8096 check_static_variable_definition (tree decl
, tree type
)
8098 /* Can't check yet if we don't know the type. */
8099 if (dependent_type_p (type
))
8101 /* If DECL is declared constexpr, we'll do the appropriate checks
8102 in check_initializer. */
8103 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8105 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8107 if (!COMPLETE_TYPE_P (type
))
8108 error ("in-class initialization of static data member %q#D of "
8109 "incomplete type", decl
);
8110 else if (literal_type_p (type
))
8111 permerror (input_location
,
8112 "%<constexpr%> needed for in-class initialization of "
8113 "static data member %q#D of non-integral type", decl
);
8115 error ("in-class initialization of static data member %q#D of "
8116 "non-literal type", decl
);
8120 /* Motion 10 at San Diego: If a static const integral data member is
8121 initialized with an integral constant expression, the initializer
8122 may appear either in the declaration (within the class), or in
8123 the definition, but not both. If it appears in the class, the
8124 member is a member constant. The file-scope definition is always
8126 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8128 error ("invalid in-class initialization of static data member "
8129 "of non-integral type %qT",
8133 else if (!CP_TYPE_CONST_P (type
))
8134 error ("ISO C++ forbids in-class initialization of non-const "
8135 "static member %qD",
8137 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8138 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8139 "%qD of non-integral type %qT", decl
, type
);
8144 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8145 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8146 expressions out into temporary variables so that walk_tree doesn't
8147 step into them (c++/15764). */
8150 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8152 struct pointer_set_t
*pset
= (struct pointer_set_t
*)data
;
8153 tree expr
= *expr_p
;
8154 if (TREE_CODE (expr
) == SAVE_EXPR
)
8156 tree op
= TREE_OPERAND (expr
, 0);
8157 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8158 if (TREE_SIDE_EFFECTS (op
))
8159 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8162 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8167 /* Entry point for the above. */
8170 stabilize_vla_size (tree size
)
8172 struct pointer_set_t
*pset
= pointer_set_create ();
8173 /* Break out any function calls into temporary variables. */
8174 cp_walk_tree (&size
, stabilize_save_expr_r
, pset
, pset
);
8175 pointer_set_destroy (pset
);
8178 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8179 not inside of SAVE_EXPR and fold them. */
8182 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8184 tree expr
= *expr_p
;
8185 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8187 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8189 *(bool *)data
= true;
8190 if (SIZEOF_EXPR_TYPE_P (expr
))
8191 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8192 SIZEOF_EXPR
, false);
8193 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8194 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8197 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8199 if (expr
== error_mark_node
)
8200 expr
= size_one_node
;
8207 /* Given the SIZE (i.e., number of elements) in an array, compute an
8208 appropriate index type for the array. If non-NULL, NAME is the
8209 name of the thing being declared. */
8212 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8216 tree abi_1_itype
= NULL_TREE
;
8218 if (error_operand_p (size
))
8219 return error_mark_node
;
8221 if (!type_dependent_expression_p (size
))
8223 tree type
= TREE_TYPE (size
);
8225 mark_rvalue_use (size
);
8227 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8228 && TREE_SIDE_EFFECTS (size
))
8229 /* In C++98, we mark a non-constant array bound with a magic
8230 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8233 size
= fold_non_dependent_expr_sfinae (size
, complain
);
8235 if (CLASS_TYPE_P (type
)
8236 && CLASSTYPE_LITERAL_P (type
))
8238 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8241 if (!(complain
& tf_error
))
8242 return error_mark_node
;
8244 error ("size of array %qD has non-integral type %qT",
8247 error ("size of array has non-integral type %qT", type
);
8248 size
= integer_one_node
;
8250 if (size
== error_mark_node
)
8251 return error_mark_node
;
8252 type
= TREE_TYPE (size
);
8253 /* We didn't support this case in GCC 3.2, so don't bother
8254 trying to model it now in ABI v1. */
8255 abi_1_itype
= error_mark_node
;
8258 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8259 size
= maybe_constant_value (size
);
8261 if (!TREE_CONSTANT (size
))
8265 if (error_operand_p (size
))
8266 return error_mark_node
;
8268 /* The array bound must be an integer type. */
8269 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8271 if (!(complain
& tf_error
))
8272 return error_mark_node
;
8274 error ("size of array %qD has non-integral type %qT", name
, type
);
8276 error ("size of array has non-integral type %qT", type
);
8277 size
= integer_one_node
;
8278 type
= TREE_TYPE (size
);
8282 /* A type is dependent if it is...an array type constructed from any
8283 dependent type or whose size is specified by a constant expression
8284 that is value-dependent. */
8285 /* We can only call value_dependent_expression_p on integral constant
8286 expressions; treat non-constant expressions as dependent, too. */
8287 if (processing_template_decl
8288 && (type_dependent_expression_p (size
)
8289 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8291 /* We cannot do any checking for a SIZE that isn't known to be
8292 constant. Just build the index type and mark that it requires
8293 structural equality checks. */
8294 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8295 size
, size_one_node
));
8296 TYPE_DEPENDENT_P (itype
) = 1;
8297 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8298 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8302 if (!abi_version_at_least (2) && processing_template_decl
8303 && abi_1_itype
== NULL_TREE
)
8304 /* For abi-1, we handled all instances in templates the same way,
8305 even when they were non-dependent. This affects the manglings
8306 produced. So, we do the normal checking for non-dependent
8307 sizes, but at the end we'll return the same type that abi-1
8308 would have, but with TYPE_CANONICAL set to the "right"
8309 value that the current ABI would provide. */
8310 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8311 osize
, integer_one_node
));
8313 /* Normally, the array-bound will be a constant. */
8314 if (TREE_CODE (size
) == INTEGER_CST
)
8316 /* Check to see if the array bound overflowed. Make that an
8317 error, no matter how generous we're being. */
8318 constant_expression_error (size
);
8320 /* An array must have a positive number of elements. */
8321 if (tree_int_cst_lt (size
, integer_zero_node
))
8323 if (!(complain
& tf_error
))
8324 return error_mark_node
;
8326 error ("size of array %qD is negative", name
);
8328 error ("size of array is negative");
8329 size
= integer_one_node
;
8331 /* As an extension we allow zero-sized arrays. */
8332 else if (integer_zerop (size
))
8334 if (!(complain
& tf_error
))
8335 /* We must fail if performing argument deduction (as
8336 indicated by the state of complain), so that
8337 another substitution can be found. */
8338 return error_mark_node
;
8339 else if (in_system_header_at (input_location
))
8340 /* Allow them in system headers because glibc uses them. */;
8342 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8344 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8347 else if (TREE_CONSTANT (size
)
8348 /* We don't allow VLAs at non-function scopes, or during
8349 tentative template substitution. */
8350 || !at_function_scope_p ()
8351 || (cxx_dialect
< cxx1y
&& !(complain
& tf_error
)))
8353 if (!(complain
& tf_error
))
8354 return error_mark_node
;
8355 /* `(int) &fn' is not a valid array bound. */
8357 error ("size of array %qD is not an integral constant-expression",
8360 error ("size of array is not an integral constant-expression");
8361 size
= integer_one_node
;
8363 else if (cxx_dialect
< cxx1y
&& pedantic
&& warn_vla
!= 0)
8366 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8368 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8370 else if (warn_vla
> 0)
8374 "variable length array %qD is used", name
);
8377 "variable length array is used");
8380 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8381 /* A variable sized array. */
8382 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8385 HOST_WIDE_INT saved_processing_template_decl
;
8387 /* Compute the index of the largest element in the array. It is
8388 one less than the number of elements in the array. We save
8389 and restore PROCESSING_TEMPLATE_DECL so that computations in
8390 cp_build_binary_op will be appropriately folded. */
8391 saved_processing_template_decl
= processing_template_decl
;
8392 processing_template_decl
= 0;
8393 itype
= cp_build_binary_op (input_location
,
8395 cp_convert (ssizetype
, size
, complain
),
8396 cp_convert (ssizetype
, integer_one_node
,
8399 itype
= fold (itype
);
8400 processing_template_decl
= saved_processing_template_decl
;
8402 if (!TREE_CONSTANT (itype
))
8404 /* A variable sized array. */
8405 itype
= variable_size (itype
);
8407 if (TREE_CODE (itype
) != SAVE_EXPR
)
8409 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8410 they might survive till gimplification. */
8411 tree newitype
= itype
;
8413 cp_walk_tree_without_duplicates (&newitype
,
8414 fold_sizeof_expr_r
, &found
);
8416 itype
= variable_size (fold (newitype
));
8419 stabilize_vla_size (itype
);
8421 if (cxx_dialect
>= cxx1y
&& flag_exceptions
)
8423 /* If the VLA bound is larger than half the address space,
8424 or less than zero, throw std::bad_array_length. */
8425 tree comp
= build2 (LT_EXPR
, boolean_type_node
, itype
,
8427 comp
= build3 (COND_EXPR
, void_type_node
, comp
,
8428 throw_bad_array_length (), void_zero_node
);
8429 finish_expr_stmt (comp
);
8431 else if (flag_sanitize
& SANITIZE_VLA
)
8433 /* From C++1y onwards, we throw an exception on a negative
8434 length size of an array; see above. */
8436 /* We have to add 1 -- in the ubsan routine we generate
8437 LE_EXPR rather than LT_EXPR. */
8438 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8439 build_one_cst (TREE_TYPE (itype
)));
8440 t
= ubsan_instrument_vla (input_location
, t
);
8441 finish_expr_stmt (t
);
8444 /* Make sure that there was no overflow when creating to a signed
8445 index type. (For example, on a 32-bit machine, an array with
8446 size 2^32 - 1 is too big.) */
8447 else if (TREE_CODE (itype
) == INTEGER_CST
8448 && TREE_OVERFLOW (itype
))
8450 if (!(complain
& tf_error
))
8451 return error_mark_node
;
8452 error ("overflow in array dimension");
8453 TREE_OVERFLOW (itype
) = 0;
8457 /* Create and return the appropriate index type. */
8458 if (abi_1_itype
&& abi_1_itype
!= error_mark_node
)
8460 tree t
= build_index_type (itype
);
8461 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
8462 itype
= abi_1_itype
;
8465 itype
= build_index_type (itype
);
8467 /* If the index type were dependent, we would have returned early, so
8468 remember that it isn't. */
8469 TYPE_DEPENDENT_P (itype
) = 0;
8470 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8474 /* Returns the scope (if any) in which the entity declared by
8475 DECLARATOR will be located. If the entity was declared with an
8476 unqualified name, NULL_TREE is returned. */
8479 get_scope_of_declarator (const cp_declarator
*declarator
)
8481 while (declarator
&& declarator
->kind
!= cdk_id
)
8482 declarator
= declarator
->declarator
;
8484 /* If the declarator-id is a SCOPE_REF, the scope in which the
8485 declaration occurs is the first operand. */
8487 && declarator
->u
.id
.qualifying_scope
)
8488 return declarator
->u
.id
.qualifying_scope
;
8490 /* Otherwise, the declarator is not a qualified name; the entity will
8491 be declared in the current scope. */
8495 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8496 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8500 create_array_type_for_decl (tree name
, tree type
, tree size
)
8502 tree itype
= NULL_TREE
;
8504 /* If things have already gone awry, bail now. */
8505 if (type
== error_mark_node
|| size
== error_mark_node
)
8506 return error_mark_node
;
8508 /* 8.3.4/1: If the type of the identifier of D contains the auto
8509 type-specifier, the program is ill-formed. */
8510 if (pedantic
&& type_uses_auto (type
))
8511 pedwarn (input_location
, OPT_Wpedantic
,
8512 "declaration of %qD as array of %<auto%>", name
);
8514 /* If there are some types which cannot be array elements,
8515 issue an error-message and return. */
8516 switch (TREE_CODE (type
))
8520 error ("declaration of %qD as array of void", name
);
8522 error ("creating array of void");
8523 return error_mark_node
;
8527 error ("declaration of %qD as array of functions", name
);
8529 error ("creating array of functions");
8530 return error_mark_node
;
8532 case REFERENCE_TYPE
:
8534 error ("declaration of %qD as array of references", name
);
8536 error ("creating array of references");
8537 return error_mark_node
;
8541 error ("declaration of %qD as array of function members", name
);
8543 error ("creating array of function members");
8544 return error_mark_node
;
8552 The constant expressions that specify the bounds of the arrays
8553 can be omitted only for the first member of the sequence. */
8554 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8557 error ("declaration of %qD as multidimensional array must "
8558 "have bounds for all dimensions except the first",
8561 error ("multidimensional array must have bounds for all "
8562 "dimensions except the first");
8564 return error_mark_node
;
8567 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
)
8568 && (flag_iso
|| warn_vla
> 0))
8569 pedwarn (input_location
, OPT_Wvla
, "array of array of runtime bound");
8571 /* 8.3.4p1: ...if the type of the identifier of D contains the auto
8572 type-specifier, the program is ill-formed. */
8573 if (type_uses_auto (type
))
8575 error ("%qD declared as array of %qT", name
, type
);
8576 return error_mark_node
;
8579 /* Figure out the index type for the array. */
8581 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8584 T is called the array element type; this type shall not be [...] an
8585 abstract class type. */
8586 abstract_virtuals_error (name
, type
);
8588 return build_cplus_array_type (type
, itype
);
8591 /* Check that it's OK to declare a function with the indicated TYPE.
8592 SFK indicates the kind of special function (if any) that this
8593 function is. OPTYPE is the type given in a conversion operator
8594 declaration, or the class type for a constructor/destructor.
8595 Returns the actual return type of the function; that
8596 may be different than TYPE if an error occurs, or for certain
8597 special functions. */
8600 check_special_function_return_type (special_function_kind sfk
,
8606 case sfk_constructor
:
8608 error ("return type specification for constructor invalid");
8610 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8611 type
= build_pointer_type (optype
);
8613 type
= void_type_node
;
8616 case sfk_destructor
:
8618 error ("return type specification for destructor invalid");
8619 /* We can't use the proper return type here because we run into
8620 problems with ambiguous bases and covariant returns.
8621 Java classes are left unchanged because (void *) isn't a valid
8622 Java type, and we don't want to change the Java ABI. */
8623 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8624 type
= build_pointer_type (void_type_node
);
8626 type
= void_type_node
;
8629 case sfk_conversion
:
8631 error ("return type specified for %<operator %T%>", optype
);
8642 /* A variable or data member (whose unqualified name is IDENTIFIER)
8643 has been declared with the indicated TYPE. If the TYPE is not
8644 acceptable, issue an error message and return a type to use for
8645 error-recovery purposes. */
8648 check_var_type (tree identifier
, tree type
)
8650 if (VOID_TYPE_P (type
))
8653 error ("unnamed variable or field declared void");
8654 else if (identifier_p (identifier
))
8656 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8657 error ("variable or field %qE declared void", identifier
);
8660 error ("variable or field declared void");
8661 type
= error_mark_node
;
8667 /* Given declspecs and a declarator (abstract or otherwise), determine
8668 the name and type of the object declared and construct a DECL node
8671 DECLSPECS points to the representation of declaration-specifier
8672 sequence that precedes declarator.
8674 DECL_CONTEXT says which syntactic context this declaration is in:
8675 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8676 FUNCDEF for a function definition. Like NORMAL but a few different
8677 error messages in each case. Return value may be zero meaning
8678 this definition is too screwy to try to parse.
8679 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8680 handle member functions (which have FIELD context).
8681 Return value may be zero meaning this definition is too screwy to
8683 PARM for a parameter declaration (either within a function prototype
8684 or before a function body). Make a PARM_DECL, or return void_type_node.
8685 TPARM for a template parameter declaration.
8686 CATCHPARM for a parameter declaration before a catch clause.
8687 TYPENAME if for a typename (in a cast or sizeof).
8688 Don't make a DECL node; just return the ..._TYPE node.
8689 FIELD for a struct or union field; make a FIELD_DECL.
8690 BITFIELD for a field with specified width.
8692 INITIALIZED is as for start_decl.
8694 ATTRLIST is a pointer to the list of attributes, which may be NULL
8695 if there are none; *ATTRLIST may be modified if attributes from inside
8696 the declarator should be applied to the declaration.
8698 When this function is called, scoping variables (such as
8699 CURRENT_CLASS_TYPE) should reflect the scope in which the
8700 declaration occurs, not the scope in which the new declaration will
8701 be placed. For example, on:
8705 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8708 Returns a DECL (if a declarator is present), a TYPE (if there is no
8709 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8713 grokdeclarator (const cp_declarator
*declarator
,
8714 cp_decl_specifier_seq
*declspecs
,
8715 enum decl_context decl_context
,
8719 tree type
= NULL_TREE
;
8721 int explicit_int128
= 0;
8722 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8723 int explicit_int
= 0;
8724 int explicit_char
= 0;
8725 int defaulted_int
= 0;
8727 tree typedef_decl
= NULL_TREE
;
8728 const char *name
= NULL
;
8729 tree typedef_type
= NULL_TREE
;
8730 /* True if this declarator is a function definition. */
8731 bool funcdef_flag
= false;
8732 cp_declarator_kind innermost_code
= cdk_error
;
8735 /* See the code below that used this. */
8736 tree decl_attr
= NULL_TREE
;
8739 /* Keep track of what sort of function is being processed
8740 so that we can warn about default return values, or explicit
8741 return values which do not match prescribed defaults. */
8742 special_function_kind sfk
= sfk_none
;
8744 tree dname
= NULL_TREE
;
8745 tree ctor_return_type
= NULL_TREE
;
8746 enum overload_flags flags
= NO_SPECIAL
;
8747 /* cv-qualifiers that apply to the declarator, for a declaration of
8748 a member function. */
8749 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8750 /* virt-specifiers that apply to the declarator, for a declaration of
8751 a member function. */
8752 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8753 /* ref-qualifier that applies to the declarator, for a declaration of
8754 a member function. */
8755 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
8756 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8758 tree raises
= NULL_TREE
;
8759 int template_count
= 0;
8760 tree returned_attrs
= NULL_TREE
;
8761 tree parms
= NULL_TREE
;
8762 const cp_declarator
*id_declarator
;
8763 /* The unqualified name of the declarator; either an
8764 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8765 tree unqualified_id
;
8766 /* The class type, if any, in which this entity is located,
8767 or NULL_TREE if none. Note that this value may be different from
8768 the current class type; for example if an attempt is made to declare
8769 "A::f" inside "B", this value will be "A". */
8770 tree ctype
= current_class_type
;
8771 /* The NAMESPACE_DECL for the namespace in which this entity is
8772 located. If an unqualified name is used to declare the entity,
8773 this value will be NULL_TREE, even if the entity is located at
8775 tree in_namespace
= NULL_TREE
;
8776 cp_storage_class storage_class
;
8777 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8778 bool type_was_error_mark_node
= false;
8779 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8780 bool template_type_arg
= false;
8781 bool template_parm_flag
= false;
8782 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
8783 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8784 source_location saved_loc
= input_location
;
8787 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8788 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8789 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8790 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8791 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8792 explicit_int128
= declspecs
->explicit_int128_p
;
8793 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8795 if (decl_context
== FUNCDEF
)
8796 funcdef_flag
= true, decl_context
= NORMAL
;
8797 else if (decl_context
== MEMFUNCDEF
)
8798 funcdef_flag
= true, decl_context
= FIELD
;
8799 else if (decl_context
== BITFIELD
)
8800 bitfield
= 1, decl_context
= FIELD
;
8801 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8802 template_type_arg
= true, decl_context
= TYPENAME
;
8803 else if (decl_context
== TPARM
)
8804 template_parm_flag
= true, decl_context
= PARM
;
8806 if (initialized
> 1)
8807 funcdef_flag
= true;
8809 /* Look inside a declarator for the name being declared
8810 and get it as a string, for an error message. */
8811 for (id_declarator
= declarator
;
8813 id_declarator
= id_declarator
->declarator
)
8815 if (id_declarator
->kind
!= cdk_id
)
8816 innermost_code
= id_declarator
->kind
;
8818 switch (id_declarator
->kind
)
8821 if (id_declarator
->declarator
8822 && id_declarator
->declarator
->kind
== cdk_id
)
8824 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8825 if (sfk
== sfk_destructor
)
8832 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8833 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8836 if (qualifying_scope
)
8838 if (at_function_scope_p ())
8842 A declarator-id shall not be qualified except
8845 None of the cases are permitted in block
8847 if (qualifying_scope
== global_namespace
)
8848 error ("invalid use of qualified-name %<::%D%>",
8850 else if (TYPE_P (qualifying_scope
))
8851 error ("invalid use of qualified-name %<%T::%D%>",
8852 qualifying_scope
, decl
);
8854 error ("invalid use of qualified-name %<%D::%D%>",
8855 qualifying_scope
, decl
);
8856 return error_mark_node
;
8858 else if (TYPE_P (qualifying_scope
))
8860 ctype
= qualifying_scope
;
8861 if (!MAYBE_CLASS_TYPE_P (ctype
))
8863 error ("%q#T is not a class or a namespace", ctype
);
8866 else if (innermost_code
!= cdk_function
8867 && current_class_type
8868 && !uniquely_derived_from_p (ctype
,
8869 current_class_type
))
8871 error ("invalid use of qualified-name %<%T::%D%>",
8872 qualifying_scope
, decl
);
8873 return error_mark_node
;
8876 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
8877 in_namespace
= qualifying_scope
;
8879 switch (TREE_CODE (decl
))
8885 if (innermost_code
!= cdk_function
)
8887 error ("declaration of %qD as non-function", decl
);
8888 return error_mark_node
;
8890 else if (!qualifying_scope
8891 && !(current_class_type
&& at_class_scope_p ()))
8893 error ("declaration of %qD as non-member", decl
);
8894 return error_mark_node
;
8897 type
= TREE_OPERAND (decl
, 0);
8899 type
= constructor_name (type
);
8900 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
8905 case TEMPLATE_ID_EXPR
:
8907 tree fns
= TREE_OPERAND (decl
, 0);
8910 if (!identifier_p (dname
))
8912 gcc_assert (is_overloaded_fn (dname
));
8913 dname
= DECL_NAME (get_first_fn (dname
));
8918 case IDENTIFIER_NODE
:
8919 if (identifier_p (decl
))
8922 if (C_IS_RESERVED_WORD (dname
))
8924 error ("declarator-id missing; using reserved word %qD",
8926 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8928 else if (!IDENTIFIER_TYPENAME_P (dname
))
8929 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8932 gcc_assert (flags
== NO_SPECIAL
);
8933 flags
= TYPENAME_FLAG
;
8934 ctor_return_type
= TREE_TYPE (dname
);
8935 sfk
= sfk_conversion
;
8936 if (is_typename_at_global_scope (dname
))
8937 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8939 name
= "<invalid operator>";
8956 return error_mark_node
;
8961 if (id_declarator
->kind
== cdk_id
)
8967 The declarator in a function-definition shall have the form
8968 D1 ( parameter-declaration-clause) ... */
8969 if (funcdef_flag
&& innermost_code
!= cdk_function
)
8971 error ("function definition does not declare parameters");
8972 return error_mark_node
;
8975 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8976 && innermost_code
!= cdk_function
8977 && ! (ctype
&& !declspecs
->any_specifiers_p
))
8979 error ("declaration of %qD as non-function", dname
);
8980 return error_mark_node
;
8984 && identifier_p (dname
)
8985 && UDLIT_OPER_P (dname
)
8986 && innermost_code
!= cdk_function
)
8988 error ("declaration of %qD as non-function", dname
);
8989 return error_mark_node
;
8992 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
8996 error ("declaration of %qD as %<typedef%>", dname
);
8997 return error_mark_node
;
8999 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9001 error ("declaration of %qD as parameter", dname
);
9002 return error_mark_node
;
9006 /* Anything declared one level down from the top level
9007 must be one of the parameters of a function
9008 (because the body is at least two levels down). */
9010 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9011 by not allowing C++ class definitions to specify their parameters
9012 with xdecls (must be spec.d in the parmlist).
9014 Since we now wait to push a class scope until we are sure that
9015 we are in a legitimate method context, we must set oldcname
9016 explicitly (since current_class_name is not yet alive).
9018 We also want to avoid calling this a PARM if it is in a namespace. */
9020 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9022 cp_binding_level
*b
= current_binding_level
;
9023 current_binding_level
= b
->level_chain
;
9024 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9025 decl_context
= PARM
;
9026 current_binding_level
= b
;
9030 name
= decl_context
== PARM
? "parameter" : "type name";
9032 if (constexpr_p
&& typedef_p
)
9034 error ("%<constexpr%> cannot appear in a typedef declaration");
9035 return error_mark_node
;
9038 /* If there were multiple types specified in the decl-specifier-seq,
9039 issue an error message. */
9040 if (declspecs
->multiple_types_p
)
9042 error ("two or more data types in declaration of %qs", name
);
9043 return error_mark_node
;
9046 if (declspecs
->conflicting_specifiers_p
)
9048 error ("conflicting specifiers in declaration of %qs", name
);
9049 return error_mark_node
;
9052 /* Extract the basic type from the decl-specifier-seq. */
9053 type
= declspecs
->type
;
9054 if (type
== error_mark_node
)
9057 type_was_error_mark_node
= true;
9059 /* If the entire declaration is itself tagged as deprecated then
9060 suppress reports of deprecated items. */
9061 if (type
&& TREE_DEPRECATED (type
)
9062 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9063 warn_deprecated_use (type
, NULL_TREE
);
9064 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9066 typedef_decl
= type
;
9067 type
= TREE_TYPE (typedef_decl
);
9068 if (TREE_DEPRECATED (type
)
9069 && DECL_ARTIFICIAL (typedef_decl
)
9070 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9071 warn_deprecated_use (type
, NULL_TREE
);
9073 /* No type at all: default to `int', and set DEFAULTED_INT
9074 because it was not a user-defined typedef. */
9075 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
9077 /* These imply 'int'. */
9078 type
= integer_type_node
;
9082 explicit_int
= declspecs
->explicit_int_p
;
9083 explicit_char
= declspecs
->explicit_char_p
;
9086 /* See the code below that used this. */
9088 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9090 typedef_type
= type
;
9093 if (sfk
!= sfk_conversion
)
9094 ctor_return_type
= ctype
;
9096 if (sfk
!= sfk_none
)
9097 type
= check_special_function_return_type (sfk
, type
,
9099 else if (type
== NULL_TREE
)
9105 /* We handle `main' specially here, because 'main () { }' is so
9106 common. With no options, it is allowed. With -Wreturn-type,
9107 it is a warning. It is only an error with -pedantic-errors. */
9108 is_main
= (funcdef_flag
9109 && dname
&& identifier_p (dname
)
9110 && MAIN_NAME_P (dname
)
9111 && ctype
== NULL_TREE
9112 && in_namespace
== NULL_TREE
9113 && current_namespace
== global_namespace
);
9115 if (type_was_error_mark_node
)
9116 /* We've already issued an error, don't complain more. */;
9117 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9118 /* Allow it, sigh. */;
9120 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9122 pedwarn (input_location
, OPT_Wpedantic
,
9123 "ISO C++ forbids declaration of %qs with no type", name
);
9125 warning (OPT_Wreturn_type
,
9126 "ISO C++ forbids declaration of %qs with no type", name
);
9128 type
= integer_type_node
;
9133 if (explicit_int128
)
9135 if (int128_integer_type_node
== NULL_TREE
)
9137 error ("%<__int128%> is not supported by this target");
9138 explicit_int128
= false;
9140 else if (pedantic
&& ! in_system_header_at (input_location
))
9141 pedwarn (input_location
, OPT_Wpedantic
,
9142 "ISO C++ does not support %<__int128%> for %qs", name
);
9145 /* Now process the modifiers that were specified
9146 and check for invalid combinations. */
9148 /* Long double is a special combination. */
9149 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9152 type
= cp_build_qualified_type (long_double_type_node
,
9153 cp_type_quals (type
));
9156 /* Check all other uses of type modifiers. */
9158 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9162 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9163 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9164 else if (signed_p
&& unsigned_p
)
9165 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9166 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9167 error ("%<long long%> invalid for %qs", name
);
9168 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9169 error ("%<long%> invalid for %qs", name
);
9170 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9171 error ("%<short%> invalid for %qs", name
);
9172 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9173 error ("%<long%> or %<short%> invalid for %qs", name
);
9174 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_int128
)
9175 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9176 else if ((long_p
|| short_p
) && explicit_char
)
9177 error ("%<long%> or %<short%> specified with char for %qs", name
);
9178 else if (long_p
&& short_p
)
9179 error ("%<long%> and %<short%> specified together for %qs", name
);
9180 else if (type
== char16_type_node
|| type
== char32_type_node
)
9182 if (signed_p
|| unsigned_p
)
9183 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9184 else if (short_p
|| long_p
)
9185 error ("%<short%> or %<long%> invalid for %qs", name
);
9190 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_int128
&& pedantic
)
9192 pedwarn (input_location
, OPT_Wpedantic
,
9193 "long, short, signed or unsigned used invalidly for %qs",
9195 if (flag_pedantic_errors
)
9200 /* Discard the type modifiers if they are invalid. */
9211 /* Decide whether an integer type is signed or not.
9212 Optionally treat bitfields as signed by default. */
9216 It is implementation-defined whether a plain (neither
9217 explicitly signed or unsigned) char, short, int, or long
9218 bit-field is signed or unsigned.
9220 Naturally, we extend this to long long as well. Note that
9221 this does not include wchar_t. */
9222 || (bitfield
&& !flag_signed_bitfields
9224 /* A typedef for plain `int' without `signed' can be
9225 controlled just like plain `int', but a typedef for
9226 `signed int' cannot be so controlled. */
9228 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9229 && TREE_CODE (type
) == INTEGER_TYPE
9230 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9232 if (explicit_int128
)
9233 type
= int128_unsigned_type_node
;
9235 type
= long_long_unsigned_type_node
;
9237 type
= long_unsigned_type_node
;
9239 type
= short_unsigned_type_node
;
9240 else if (type
== char_type_node
)
9241 type
= unsigned_char_type_node
;
9242 else if (typedef_decl
)
9243 type
= unsigned_type_for (type
);
9245 type
= unsigned_type_node
;
9247 else if (signed_p
&& type
== char_type_node
)
9248 type
= signed_char_type_node
;
9249 else if (explicit_int128
)
9250 type
= int128_integer_type_node
;
9252 type
= long_long_integer_type_node
;
9254 type
= long_integer_type_node
;
9256 type
= short_integer_type_node
;
9258 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9260 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9261 error ("complex invalid for %qs", name
);
9262 /* If we just have "complex", it is equivalent to
9263 "complex double", but if any modifiers at all are specified it is
9264 the complex form of TYPE. E.g, "complex short" is
9265 "complex short int". */
9266 else if (defaulted_int
&& ! longlong
&& ! explicit_int128
9267 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
9268 type
= complex_double_type_node
;
9269 else if (type
== integer_type_node
)
9270 type
= complex_integer_type_node
;
9271 else if (type
== float_type_node
)
9272 type
= complex_float_type_node
;
9273 else if (type
== double_type_node
)
9274 type
= complex_double_type_node
;
9275 else if (type
== long_double_type_node
)
9276 type
= complex_long_double_type_node
;
9278 type
= build_complex_type (type
);
9281 type_quals
= TYPE_UNQUALIFIED
;
9282 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9283 type_quals
|= TYPE_QUAL_CONST
;
9284 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9285 type_quals
|= TYPE_QUAL_VOLATILE
;
9286 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9287 type_quals
|= TYPE_QUAL_RESTRICT
;
9288 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9289 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9292 /* If we're using the injected-class-name to form a compound type or a
9293 declaration, replace it with the underlying class so we don't get
9294 redundant typedefs in the debug output. But if we are returning the
9295 type unchanged, leave it alone so that it's available to
9296 maybe_get_template_decl_from_type_decl. */
9297 if (CLASS_TYPE_P (type
)
9298 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9299 && type
== TREE_TYPE (TYPE_NAME (type
))
9300 && (declarator
|| type_quals
))
9301 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9303 type_quals
|= cp_type_quals (type
);
9304 type
= cp_build_qualified_type_real
9305 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
9306 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9307 /* We might have ignored or rejected some of the qualifiers. */
9308 type_quals
= cp_type_quals (type
);
9311 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9312 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9313 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9315 storage_class
= declspecs
->storage_class
;
9316 if (storage_class
== sc_static
)
9317 staticp
= 1 + (decl_context
== FIELD
);
9319 if (virtualp
&& staticp
== 2)
9321 error ("member %qD cannot be declared both virtual and static", dname
);
9322 storage_class
= sc_none
;
9325 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9327 /* Issue errors about use of storage classes for parameters. */
9328 if (decl_context
== PARM
)
9332 error ("typedef declaration invalid in parameter declaration");
9333 return error_mark_node
;
9335 else if (template_parm_flag
&& storage_class
!= sc_none
)
9337 error ("storage class specified for template parameter %qs", name
);
9338 return error_mark_node
;
9340 else if (storage_class
== sc_static
9341 || storage_class
== sc_extern
9343 error ("storage class specifiers invalid in parameter declarations");
9345 /* Function parameters cannot be constexpr. If we saw one, moan
9346 and pretend it wasn't there. */
9349 error ("a parameter cannot be declared %<constexpr%>");
9354 /* Give error if `virtual' is used outside of class declaration. */
9356 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9358 error ("%<virtual%> outside class declaration");
9362 /* Static anonymous unions are dealt with here. */
9363 if (staticp
&& decl_context
== TYPENAME
9365 && ANON_AGGR_TYPE_P (declspecs
->type
))
9366 decl_context
= FIELD
;
9368 /* Warn about storage classes that are invalid for certain
9369 kinds of declarations (parameters, typenames, etc.). */
9372 && storage_class
!= sc_extern
9373 && storage_class
!= sc_static
)
9376 error ("multiple storage classes in declaration of %qs", name
);
9379 if (decl_context
!= NORMAL
9380 && ((storage_class
!= sc_none
9381 && storage_class
!= sc_mutable
)
9384 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9385 && (storage_class
== sc_register
9386 || storage_class
== sc_auto
))
9390 else if (decl_context
== FIELD
9391 /* C++ allows static class elements. */
9392 && storage_class
== sc_static
)
9393 /* C++ also allows inlines and signed and unsigned elements,
9394 but in those cases we don't come in here. */
9398 if (decl_context
== FIELD
)
9399 error ("storage class specified for %qs", name
);
9402 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9403 error ("storage class specified for parameter %qs", name
);
9405 error ("storage class specified for typename");
9407 if (storage_class
== sc_register
9408 || storage_class
== sc_auto
9409 || storage_class
== sc_extern
9411 storage_class
= sc_none
;
9414 else if (storage_class
== sc_extern
&& funcdef_flag
9415 && ! toplevel_bindings_p ())
9416 error ("nested function %qs declared %<extern%>", name
);
9417 else if (toplevel_bindings_p ())
9419 if (storage_class
== sc_auto
)
9420 error ("top-level declaration of %qs specifies %<auto%>", name
);
9423 && storage_class
!= sc_extern
9424 && storage_class
!= sc_static
)
9426 if (declspecs
->gnu_thread_keyword_p
)
9427 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9428 "declared %<__thread%>", name
);
9430 /* When thread_local is applied to a variable of block scope the
9431 storage-class-specifier static is implied if it does not appear
9433 storage_class
= declspecs
->storage_class
= sc_static
;
9437 if (storage_class
&& friendp
)
9439 error ("storage class specifiers invalid in friend function declarations");
9440 storage_class
= sc_none
;
9445 unqualified_id
= NULL_TREE
;
9448 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9449 switch (TREE_CODE (unqualified_id
))
9452 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9453 if (TYPE_P (unqualified_id
))
9454 unqualified_id
= constructor_name (unqualified_id
);
9457 case IDENTIFIER_NODE
:
9458 case TEMPLATE_ID_EXPR
:
9466 if (declspecs
->std_attributes
)
9468 /* Apply the c++11 attributes to the type preceding them. */
9469 input_location
= declspecs
->locations
[ds_std_attribute
];
9470 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9471 input_location
= saved_loc
;
9474 /* Determine the type of the entity declared by recurring on the
9476 for (; declarator
; declarator
= declarator
->declarator
)
9478 const cp_declarator
*inner_declarator
;
9481 if (type
== error_mark_node
)
9482 return error_mark_node
;
9484 attrs
= declarator
->attributes
;
9490 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9491 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9492 if (declarator
->kind
== cdk_function
)
9493 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9494 if (declarator
->kind
== cdk_array
)
9495 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9496 returned_attrs
= decl_attributes (&type
,
9497 chainon (returned_attrs
, attrs
),
9501 if (declarator
->kind
== cdk_id
)
9504 inner_declarator
= declarator
->declarator
;
9506 switch (declarator
->kind
)
9509 type
= create_array_type_for_decl (dname
, type
,
9510 declarator
->u
.array
.bounds
);
9511 if (declarator
->std_attributes
)
9514 The optional attribute-specifier-seq appertains to the
9516 returned_attrs
= chainon (returned_attrs
,
9517 declarator
->std_attributes
);
9525 /* Declaring a function type.
9526 Make sure we have a valid type for the function to return. */
9528 if (type_quals
!= TYPE_UNQUALIFIED
)
9530 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9531 warning (OPT_Wignored_qualifiers
,
9532 "type qualifiers ignored on function return type");
9533 /* We now know that the TYPE_QUALS don't apply to the
9534 decl, but to its return type. */
9535 type_quals
= TYPE_UNQUALIFIED
;
9537 errmsg
= targetm
.invalid_return_type (type
);
9541 type
= integer_type_node
;
9544 /* Error about some types functions can't return. */
9546 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9548 error ("%qs declared as function returning a function", name
);
9549 return error_mark_node
;
9551 if (TREE_CODE (type
) == ARRAY_TYPE
)
9553 error ("%qs declared as function returning an array", name
);
9554 return error_mark_node
;
9557 input_location
= declspecs
->locations
[ds_type_spec
];
9558 abstract_virtuals_error (ACU_RETURN
, type
);
9559 input_location
= saved_loc
;
9561 /* Pick up type qualifiers which should be applied to `this'. */
9562 memfn_quals
= declarator
->u
.function
.qualifiers
;
9563 /* Pick up virt-specifiers. */
9564 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9565 /* And ref-qualifier, too */
9566 rqual
= declarator
->u
.function
.ref_qualifier
;
9567 /* Pick up the exception specifications. */
9568 raises
= declarator
->u
.function
.exception_specification
;
9569 /* If the exception-specification is ill-formed, let's pretend
9570 there wasn't one. */
9571 if (raises
== error_mark_node
)
9574 /* Say it's a definition only for the CALL_EXPR
9575 closest to the identifier. */
9576 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9578 /* Handle a late-specified return type. */
9581 if (type_uses_auto (type
))
9583 if (!declarator
->u
.function
.late_return_type
)
9585 if (current_class_type
9586 && LAMBDA_TYPE_P (current_class_type
))
9587 /* OK for C++11 lambdas. */;
9588 else if (cxx_dialect
< cxx1y
)
9590 error ("%qs function uses "
9591 "%<auto%> type specifier without trailing "
9592 "return type", name
);
9593 inform (input_location
, "deduced return type "
9594 "only available with -std=c++1y or "
9598 error ("virtual function cannot "
9599 "have deduced return type");
9601 else if (!is_auto (type
))
9603 error ("%qs function with trailing return type has"
9604 " %qT as its type rather than plain %<auto%>",
9606 return error_mark_node
;
9609 else if (declarator
->u
.function
.late_return_type
)
9611 if (cxx_dialect
< cxx11
)
9612 /* Not using maybe_warn_cpp0x because this should
9613 always be an error. */
9614 error ("trailing return type only available with "
9615 "-std=c++11 or -std=gnu++11");
9617 error ("%qs function with trailing return type not "
9618 "declared with %<auto%> type specifier", name
);
9619 return error_mark_node
;
9622 type
= splice_late_return_type
9623 (type
, declarator
->u
.function
.late_return_type
);
9624 if (type
== error_mark_node
)
9625 return error_mark_node
;
9627 if (ctype
== NULL_TREE
9628 && decl_context
== FIELD
9630 && (friendp
== 0 || dname
== current_class_name
))
9631 ctype
= current_class_type
;
9633 if (ctype
&& (sfk
== sfk_constructor
9634 || sfk
== sfk_destructor
))
9636 /* We are within a class's scope. If our declarator name
9637 is the same as the class name, and we are defining
9638 a function, then it is a constructor/destructor, and
9639 therefore returns a void type. */
9641 /* ISO C++ 12.4/2. A destructor may not be declared
9642 const or volatile. A destructor may not be static.
9643 A destructor may not be declared with ref-qualifier.
9645 ISO C++ 12.1. A constructor may not be declared
9646 const or volatile. A constructor may not be
9647 virtual. A constructor may not be static.
9648 A constructor may not be declared with ref-qualifier. */
9650 error ((flags
== DTOR_FLAG
)
9651 ? G_("destructor cannot be static member function")
9652 : G_("constructor cannot be static member function"));
9655 error ((flags
== DTOR_FLAG
)
9656 ? G_("destructors may not be cv-qualified")
9657 : G_("constructors may not be cv-qualified"));
9658 memfn_quals
= TYPE_UNQUALIFIED
;
9663 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
9664 error ((flags
== DTOR_FLAG
)
9665 ? "destructors may not be ref-qualified"
9666 : "constructors may not be ref-qualified");
9667 rqual
= REF_QUAL_NONE
;
9670 if (decl_context
== FIELD
9671 && !member_function_or_else (ctype
,
9674 return error_mark_node
;
9676 if (flags
!= DTOR_FLAG
)
9678 /* It's a constructor. */
9683 permerror (input_location
, "constructors cannot be declared virtual");
9686 if (decl_context
== FIELD
9687 && sfk
!= sfk_constructor
)
9688 return error_mark_node
;
9690 if (decl_context
== FIELD
)
9696 error ("can%'t initialize friend function %qs", name
);
9699 /* Cannot be both friend and virtual. */
9700 error ("virtual functions cannot be friends");
9703 if (decl_context
== NORMAL
)
9704 error ("friend declaration not in class definition");
9705 if (current_function_decl
&& funcdef_flag
)
9706 error ("can%'t define friend function %qs in a local "
9710 else if (ctype
&& sfk
== sfk_conversion
)
9714 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9719 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9722 if (inner_declarator
9723 && inner_declarator
->kind
== cdk_id
9724 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9725 && arg_types
!= void_list_node
)
9727 error ("destructors may not have parameters");
9728 arg_types
= void_list_node
;
9732 type
= build_function_type (type
, arg_types
);
9733 if (declarator
->std_attributes
)
9736 The optional attribute-specifier-seq appertains to
9737 the function type. */
9738 decl_attributes (&type
, declarator
->std_attributes
,
9746 /* Filter out pointers-to-references and references-to-references.
9747 We can get these if a TYPE_DECL is used. */
9749 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9751 if (declarator
->kind
!= cdk_reference
)
9753 error ("cannot declare pointer to %q#T", type
);
9754 type
= TREE_TYPE (type
);
9757 /* In C++0x, we allow reference to reference declarations
9758 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9759 and template type arguments [14.3.1/4 temp.arg.type]. The
9760 check for direct reference to reference declarations, which
9761 are still forbidden, occurs below. Reasoning behind the change
9762 can be found in DR106, DR540, and the rvalue reference
9764 else if (cxx_dialect
== cxx98
)
9766 error ("cannot declare reference to %q#T", type
);
9767 type
= TREE_TYPE (type
);
9770 else if (VOID_TYPE_P (type
))
9772 if (declarator
->kind
== cdk_reference
)
9773 error ("cannot declare reference to %q#T", type
);
9774 else if (declarator
->kind
== cdk_ptrmem
)
9775 error ("cannot declare pointer to %q#T member", type
);
9778 /* We now know that the TYPE_QUALS don't apply to the decl,
9779 but to the target of the pointer. */
9780 type_quals
= TYPE_UNQUALIFIED
;
9782 /* This code used to handle METHOD_TYPE, but I don't think it's
9783 possible to get it here anymore. */
9784 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9785 if (declarator
->kind
== cdk_ptrmem
9786 && TREE_CODE (type
) == FUNCTION_TYPE
)
9788 memfn_quals
|= type_memfn_quals (type
);
9789 type
= build_memfn_type (type
,
9790 declarator
->u
.pointer
.class_type
,
9793 if (type
== error_mark_node
)
9794 return error_mark_node
;
9796 rqual
= REF_QUAL_NONE
;
9797 memfn_quals
= TYPE_UNQUALIFIED
;
9800 if (TREE_CODE (type
) == FUNCTION_TYPE
9801 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
9802 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
9803 error (declarator
->kind
== cdk_reference
9804 ? G_("cannot declare reference to qualified function type %qT")
9805 : G_("cannot declare pointer to qualified function type %qT"),
9808 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
)
9809 && (flag_iso
|| warn_vla
> 0))
9810 pedwarn (input_location
, OPT_Wvla
,
9811 declarator
->kind
== cdk_reference
9812 ? G_("reference to array of runtime bound")
9813 : G_("pointer to array of runtime bound"));
9815 /* When the pointed-to type involves components of variable size,
9816 care must be taken to ensure that the size evaluation code is
9817 emitted early enough to dominate all the possible later uses
9818 and late enough for the variables on which it depends to have
9821 This is expected to happen automatically when the pointed-to
9822 type has a name/declaration of it's own, but special attention
9823 is required if the type is anonymous.
9825 We handle the NORMAL and FIELD contexts here by inserting a
9826 dummy statement that just evaluates the size at a safe point
9827 and ensures it is not deferred until e.g. within a deeper
9828 conditional context (c++/43555).
9830 We expect nothing to be needed here for PARM or TYPENAME.
9831 Evaluating the size at this point for TYPENAME would
9832 actually be incorrect, as we might be in the middle of an
9833 expression with side effects on the pointed-to type size
9834 "arguments" prior to the pointer declaration point and the
9835 size evaluation could end up prior to the side effects. */
9837 if (!TYPE_NAME (type
)
9838 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9839 && at_function_scope_p ()
9840 && variably_modified_type_p (type
, NULL_TREE
))
9841 /* Force evaluation of the SAVE_EXPR. */
9842 finish_expr_stmt (TYPE_SIZE (type
));
9844 if (declarator
->kind
== cdk_reference
)
9846 /* In C++0x, the type we are creating a reference to might be
9847 a typedef which is itself a reference type. In that case,
9848 we follow the reference collapsing rules in
9849 [7.1.3/8 dcl.typedef] to create the final reference type:
9851 "If a typedef TD names a type that is a reference to a type
9852 T, an attempt to create the type 'lvalue reference to cv TD'
9853 creates the type 'lvalue reference to T,' while an attempt
9854 to create the type "rvalue reference to cv TD' creates the
9857 if (VOID_TYPE_P (type
))
9858 /* We already gave an error. */;
9859 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9861 if (declarator
->u
.reference
.rvalue_ref
)
9862 /* Leave type alone. */;
9864 type
= cp_build_reference_type (TREE_TYPE (type
), false);
9867 type
= cp_build_reference_type
9868 (type
, declarator
->u
.reference
.rvalue_ref
);
9870 /* In C++0x, we need this check for direct reference to
9871 reference declarations, which are forbidden by
9872 [8.3.2/5 dcl.ref]. Reference to reference declarations
9873 are only allowed indirectly through typedefs and template
9874 type arguments. Example:
9876 void foo(int & &); // invalid ref-to-ref decl
9878 typedef int & int_ref;
9879 void foo(int_ref &); // valid ref-to-ref decl
9881 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
9882 error ("cannot declare reference to %q#T, which is not "
9883 "a typedef or a template type argument", type
);
9885 else if (TREE_CODE (type
) == METHOD_TYPE
)
9886 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9887 else if (declarator
->kind
== cdk_ptrmem
)
9889 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
9891 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
9892 /* We will already have complained. */
9893 type
= error_mark_node
;
9895 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
9899 type
= build_pointer_type (type
);
9901 /* Process a list of type modifier keywords (such as
9902 const or volatile) that were given inside the `*' or `&'. */
9904 if (declarator
->u
.pointer
.qualifiers
)
9907 = cp_build_qualified_type (type
,
9908 declarator
->u
.pointer
.qualifiers
);
9909 type_quals
= cp_type_quals (type
);
9912 /* Apply C++11 attributes to the pointer, and not to the
9913 type pointed to. This is unlike what is done for GNU
9914 attributes above. It is to comply with [dcl.ptr]/1:
9916 [the optional attribute-specifier-seq (7.6.1) appertains
9917 to the pointer and not to the object pointed to]. */
9918 if (declarator
->std_attributes
)
9919 decl_attributes (&type
, declarator
->std_attributes
,
9933 /* A `constexpr' specifier used in an object declaration declares
9934 the object as `const'. */
9935 if (constexpr_p
&& innermost_code
!= cdk_function
)
9937 if (type_quals
& TYPE_QUAL_VOLATILE
)
9938 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9939 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9941 type_quals
|= TYPE_QUAL_CONST
;
9942 type
= cp_build_qualified_type (type
, type_quals
);
9946 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
9947 && TREE_CODE (type
) != FUNCTION_TYPE
9948 && TREE_CODE (type
) != METHOD_TYPE
)
9950 error ("template-id %qD used as a declarator",
9952 unqualified_id
= dname
;
9955 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9956 qualified with a class-name, turn it into a METHOD_TYPE, unless
9957 we know that the function is static. We take advantage of this
9958 opportunity to do other processing that pertains to entities
9959 explicitly declared to be class members. Note that if DECLARATOR
9960 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9961 would not have exited the loop above. */
9963 && declarator
->u
.id
.qualifying_scope
9964 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
9966 ctype
= declarator
->u
.id
.qualifying_scope
;
9967 ctype
= TYPE_MAIN_VARIANT (ctype
);
9968 template_count
= num_template_headers_for_class (ctype
);
9970 if (ctype
== current_class_type
)
9974 permerror (input_location
, "member functions are implicitly friends of their class");
9978 permerror (declarator
->id_loc
,
9979 "extra qualification %<%T::%> on member %qs",
9982 else if (/* If the qualifying type is already complete, then we
9983 can skip the following checks. */
9984 !COMPLETE_TYPE_P (ctype
)
9985 && (/* If the function is being defined, then
9986 qualifying type must certainly be complete. */
9988 /* A friend declaration of "T::f" is OK, even if
9989 "T" is a template parameter. But, if this
9990 function is not a friend, the qualifying type
9992 || (!friendp
&& !CLASS_TYPE_P (ctype
))
9993 /* For a declaration, the type need not be
9994 complete, if either it is dependent (since there
9995 is no meaningful definition of complete in that
9996 case) or the qualifying class is currently being
9998 || !(dependent_type_p (ctype
)
9999 || currently_open_class (ctype
)))
10000 /* Check that the qualifying type is complete. */
10001 && !complete_type_or_else (ctype
, NULL_TREE
))
10002 return error_mark_node
;
10003 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10005 if (current_class_type
10006 && (!friendp
|| funcdef_flag
))
10008 error (funcdef_flag
10009 ? G_("cannot define member function %<%T::%s%> "
10011 : G_("cannot declare member function %<%T::%s%> "
10013 ctype
, name
, current_class_type
);
10014 return error_mark_node
;
10017 else if (typedef_p
&& current_class_type
)
10019 error ("cannot declare member %<%T::%s%> within %qT",
10020 ctype
, name
, current_class_type
);
10021 return error_mark_node
;
10025 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10026 ctype
= current_class_type
;
10028 /* Now TYPE has the actual type. */
10030 if (returned_attrs
)
10033 *attrlist
= chainon (returned_attrs
, *attrlist
);
10035 attrlist
= &returned_attrs
;
10039 && declarator
->kind
== cdk_id
10040 && declarator
->std_attributes
)
10041 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10042 a declarator-id appertains to the entity that is declared. */
10043 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10045 /* Handle parameter packs. */
10046 if (parameter_pack_p
)
10048 if (decl_context
== PARM
)
10049 /* Turn the type into a pack expansion.*/
10050 type
= make_pack_expansion (type
);
10052 error ("non-parameter %qs cannot be a parameter pack", name
);
10055 /* Did array size calculations overflow or does the array cover more
10056 than half of the address-space? */
10057 if (TREE_CODE (type
) == ARRAY_TYPE
10058 && COMPLETE_TYPE_P (type
)
10059 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
10060 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
10062 error ("size of array %qs is too large", name
);
10063 /* If we proceed with the array type as it is, we'll eventually
10064 crash in tree_to_[su]hwi(). */
10065 type
= error_mark_node
;
10068 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10069 && !processing_template_decl
10070 && variably_modified_type_p (type
, NULL_TREE
))
10072 if (decl_context
== FIELD
)
10073 error ("data member may not have variably modified type %qT", type
);
10075 error ("parameter may not have variably modified type %qT", type
);
10076 type
= error_mark_node
;
10079 if (explicitp
== 1 || (explicitp
&& friendp
))
10081 /* [dcl.fct.spec] The explicit specifier shall only be used in
10082 declarations of constructors within a class definition. */
10083 error ("only declarations of constructors can be %<explicit%>");
10087 if (storage_class
== sc_mutable
)
10089 if (decl_context
!= FIELD
|| friendp
)
10091 error ("non-member %qs cannot be declared %<mutable%>", name
);
10092 storage_class
= sc_none
;
10094 else if (decl_context
== TYPENAME
|| typedef_p
)
10096 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10097 storage_class
= sc_none
;
10099 else if (TREE_CODE (type
) == FUNCTION_TYPE
10100 || TREE_CODE (type
) == METHOD_TYPE
)
10102 error ("function %qs cannot be declared %<mutable%>", name
);
10103 storage_class
= sc_none
;
10107 error ("static %qs cannot be declared %<mutable%>", name
);
10108 storage_class
= sc_none
;
10110 else if (type_quals
& TYPE_QUAL_CONST
)
10112 error ("const %qs cannot be declared %<mutable%>", name
);
10113 storage_class
= sc_none
;
10115 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10117 permerror (input_location
, "reference %qs cannot be declared "
10118 "%<mutable%>", name
);
10119 storage_class
= sc_none
;
10123 /* If this is declaring a typedef name, return a TYPE_DECL. */
10124 if (typedef_p
&& decl_context
!= TYPENAME
)
10128 /* Note that the grammar rejects storage classes
10129 in typenames, fields or parameters. */
10130 if (current_lang_name
== lang_name_java
)
10131 TYPE_FOR_JAVA (type
) = 1;
10133 /* This declaration:
10135 typedef void f(int) const;
10137 declares a function type which is not a member of any
10138 particular class, but which is cv-qualified; for
10139 example "f S::*" declares a pointer to a const-qualified
10140 member function of S. We record the cv-qualification in the
10142 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10144 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10146 /* We have now dealt with these qualifiers. */
10147 memfn_quals
= TYPE_UNQUALIFIED
;
10148 rqual
= REF_QUAL_NONE
;
10151 if (type_uses_auto (type
))
10153 error ("typedef declared %<auto%>");
10154 type
= error_mark_node
;
10157 if (cxx_dialect
>= cxx1y
&& array_of_runtime_bound_p (type
)
10158 && (flag_iso
|| warn_vla
> 0))
10159 pedwarn (input_location
, OPT_Wvla
,
10160 "typedef naming array of runtime bound");
10162 if (decl_context
== FIELD
)
10163 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10165 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10166 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10167 error_at (DECL_SOURCE_LOCATION (decl
),
10168 "typedef name may not be a nested-name-specifier");
10169 TREE_TYPE (decl
) = error_mark_node
;
10172 if (decl_context
!= FIELD
)
10174 if (!current_function_decl
)
10175 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10176 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10177 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10178 (current_function_decl
)))
10179 /* The TYPE_DECL is "abstract" because there will be
10180 clones of this constructor/destructor, and there will
10181 be copies of this TYPE_DECL generated in those
10182 clones. The decloning optimization (for space) may
10183 revert this subsequently if it determines that
10184 the clones should share a common implementation. */
10185 DECL_ABSTRACT (decl
) = 1;
10187 else if (current_class_type
10188 && constructor_name_p (unqualified_id
, current_class_type
))
10189 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10190 "as enclosing class",
10193 /* If the user declares "typedef struct {...} foo" then the
10194 struct will have an anonymous name. Fill that name in now.
10195 Nothing can refer to it, so nothing needs know about the name
10197 if (type
!= error_mark_node
10199 && TYPE_NAME (type
)
10200 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10201 && TYPE_ANONYMOUS_P (type
)
10202 && declspecs
->type_definition_p
10203 && attributes_naming_typedef_ok (*attrlist
)
10204 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10208 /* Replace the anonymous name with the real name everywhere. */
10209 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10211 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10212 /* We do not rename the debug info representing the
10213 anonymous tagged type because the standard says in
10214 [dcl.typedef] that the naming applies only for
10215 linkage purposes. */
10216 /*debug_hooks->set_name (t, decl);*/
10217 TYPE_NAME (t
) = decl
;
10220 if (TYPE_LANG_SPECIFIC (type
))
10221 TYPE_WAS_ANONYMOUS (type
) = 1;
10223 /* If this is a typedef within a template class, the nested
10224 type is a (non-primary) template. The name for the
10225 template needs updating as well. */
10226 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10227 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10228 = TYPE_IDENTIFIER (type
);
10230 /* Adjust linkage now that we aren't anonymous anymore. */
10231 reset_type_linkage (type
);
10233 /* FIXME remangle member functions; member functions of a
10234 type with external linkage have external linkage. */
10238 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10239 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10241 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10242 memfn_quals
!= TYPE_UNQUALIFIED
,
10243 inlinep
, friendp
, raises
!= NULL_TREE
);
10245 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10246 /* Acknowledge that this was written:
10247 `using analias = atype;'. */
10248 TYPE_DECL_ALIAS_P (decl
) = 1;
10253 /* Detect the case of an array type of unspecified size
10254 which came, as such, direct from a typedef name.
10255 We must copy the type, so that the array's domain can be
10256 individually set by the object's initializer. */
10258 if (type
&& typedef_type
10259 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10260 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10261 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10263 /* Detect where we're using a typedef of function type to declare a
10264 function. PARMS will not be set, so we must create it now. */
10266 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10268 tree decls
= NULL_TREE
;
10271 for (args
= TYPE_ARG_TYPES (type
);
10272 args
&& args
!= void_list_node
;
10273 args
= TREE_CHAIN (args
))
10275 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10277 DECL_CHAIN (decl
) = decls
;
10281 parms
= nreverse (decls
);
10283 if (decl_context
!= TYPENAME
)
10285 /* The qualifiers on the function type become the qualifiers on
10286 the non-static member function. */
10287 memfn_quals
|= type_memfn_quals (type
);
10288 rqual
= type_memfn_rqual (type
);
10289 type_quals
= TYPE_UNQUALIFIED
;
10293 /* If this is a type name (such as, in a cast or sizeof),
10294 compute the type and return it now. */
10296 if (decl_context
== TYPENAME
)
10298 /* Note that the grammar rejects storage classes
10299 in typenames, fields or parameters. */
10300 if (type_quals
!= TYPE_UNQUALIFIED
)
10301 type_quals
= TYPE_UNQUALIFIED
;
10303 /* Special case: "friend class foo" looks like a TYPENAME context. */
10306 if (type_quals
!= TYPE_UNQUALIFIED
)
10308 error ("type qualifiers specified for friend class declaration");
10309 type_quals
= TYPE_UNQUALIFIED
;
10313 error ("%<inline%> specified for friend class declaration");
10319 /* Don't allow friend declaration without a class-key. */
10320 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10321 permerror (input_location
, "template parameters cannot be friends");
10322 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10323 permerror (input_location
, "friend declaration requires class-key, "
10324 "i.e. %<friend class %T::%D%>",
10325 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10327 permerror (input_location
, "friend declaration requires class-key, "
10328 "i.e. %<friend %#T%>",
10332 /* Only try to do this stuff if we didn't already give up. */
10333 if (type
!= integer_type_node
)
10335 /* A friendly class? */
10336 if (current_class_type
)
10337 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10338 /*complain=*/true);
10340 error ("trying to make class %qT a friend of global scope",
10343 type
= void_type_node
;
10346 else if (memfn_quals
|| rqual
)
10348 if (ctype
== NULL_TREE
10349 && TREE_CODE (type
) == METHOD_TYPE
)
10350 ctype
= TYPE_METHOD_BASETYPE (type
);
10353 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10354 /* Core issue #547: need to allow this in template type args.
10355 Allow it in general in C++11 for alias-declarations. */
10356 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10357 && TREE_CODE (type
) == FUNCTION_TYPE
)
10358 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10360 error ("invalid qualifiers on non-member function type");
10365 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10366 && decl_context
!= CATCHPARM
10367 && TREE_CODE (type
) != UNION_TYPE
10370 error ("abstract declarator %qT used as declaration", type
);
10371 return error_mark_node
;
10374 /* Only functions may be declared using an operator-function-id. */
10376 && IDENTIFIER_OPNAME_P (unqualified_id
)
10377 && TREE_CODE (type
) != FUNCTION_TYPE
10378 && TREE_CODE (type
) != METHOD_TYPE
)
10380 error ("declaration of %qD as non-function", unqualified_id
);
10381 return error_mark_node
;
10384 /* We don't check parameter types here because we can emit a better
10385 error message later. */
10386 if (decl_context
!= PARM
)
10388 type
= check_var_type (unqualified_id
, type
);
10389 if (type
== error_mark_node
)
10390 return error_mark_node
;
10393 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10394 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10396 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10398 if (ctype
|| in_namespace
)
10399 error ("cannot use %<::%> in parameter declaration");
10401 if (type_uses_auto (type
))
10403 if (cxx_dialect
>= cxx1y
)
10404 error ("%<auto%> parameter not permitted in this context");
10406 error ("parameter declared %<auto%>");
10407 type
= error_mark_node
;
10410 /* A parameter declared as an array of T is really a pointer to T.
10411 One declared as a function is really a pointer to a function.
10412 One declared as a member is really a pointer to member. */
10414 if (TREE_CODE (type
) == ARRAY_TYPE
)
10416 /* Transfer const-ness of array into that of type pointed to. */
10417 type
= build_pointer_type (TREE_TYPE (type
));
10418 type_quals
= TYPE_UNQUALIFIED
;
10420 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10421 type
= build_pointer_type (type
);
10424 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10425 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10427 cp_cv_quals real_quals
= memfn_quals
;
10428 if (constexpr_p
&& sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10429 real_quals
|= TYPE_QUAL_CONST
;
10430 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10436 if (decl_context
== PARM
)
10438 decl
= cp_build_parm_decl (unqualified_id
, type
);
10440 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10441 memfn_quals
!= TYPE_UNQUALIFIED
,
10442 inlinep
, friendp
, raises
!= NULL_TREE
);
10444 else if (decl_context
== FIELD
)
10446 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10447 && type_uses_auto (type
))
10449 error ("non-static data member declared %<auto%>");
10450 type
= error_mark_node
;
10453 /* The C99 flexible array extension. */
10454 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10455 && TYPE_DOMAIN (type
) == NULL_TREE
)
10457 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10458 tf_warning_or_error
);
10459 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10462 if (type
== error_mark_node
)
10464 /* Happens when declaring arrays of sizes which
10465 are error_mark_node, for example. */
10468 else if (in_namespace
&& !friendp
)
10470 /* Something like struct S { int N::j; }; */
10471 error ("invalid use of %<::%>");
10472 return error_mark_node
;
10474 else if (TREE_CODE (type
) == FUNCTION_TYPE
10475 || TREE_CODE (type
) == METHOD_TYPE
)
10478 tree function_context
;
10482 /* This should never happen in pure C++ (the check
10483 could be an assert). It could happen in
10484 Objective-C++ if someone writes invalid code that
10485 uses a function declaration for an instance
10486 variable or property (instance variables and
10487 properties are parsed as FIELD_DECLs, but they are
10488 part of an Objective-C class, not a C++ class).
10489 That code is invalid and is caught by this
10493 error ("declaration of function %qD in invalid context",
10495 return error_mark_node
;
10498 /* ``A union may [ ... ] not [ have ] virtual functions.''
10500 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10502 error ("function %qD declared virtual inside a union",
10504 return error_mark_node
;
10507 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10511 error ("%qD cannot be declared virtual, since it "
10512 "is always static",
10519 /* Check that the name used for a destructor makes sense. */
10520 if (sfk
== sfk_destructor
)
10522 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10526 gcc_assert (friendp
);
10527 error ("expected qualified name in friend declaration "
10528 "for destructor %qD", uqname
);
10529 return error_mark_node
;
10532 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10534 error ("declaration of %qD as member of %qT",
10536 return error_mark_node
;
10540 error ("a destructor cannot be %<constexpr%>");
10541 return error_mark_node
;
10544 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10546 error ("expected qualified name in friend declaration "
10547 "for constructor %qD",
10548 id_declarator
->u
.id
.unqualified_name
);
10549 return error_mark_node
;
10552 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10553 function_context
= (ctype
!= NULL_TREE
) ?
10554 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10555 publicp
= (! friendp
|| ! staticp
)
10556 && function_context
== NULL_TREE
;
10557 decl
= grokfndecl (ctype
, type
,
10558 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10559 ? unqualified_id
: dname
,
10562 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10563 friendp
? -1 : 0, friendp
, publicp
,
10564 inlinep
| (2 * constexpr_p
),
10566 funcdef_flag
, template_count
, in_namespace
,
10567 attrlist
, declarator
->id_loc
);
10568 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10569 if (decl
== NULL_TREE
)
10570 return error_mark_node
;
10572 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10573 /* The decl and setting of decl_attr is also turned off. */
10574 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10577 /* [class.conv.ctor]
10579 A constructor declared without the function-specifier
10580 explicit that can be called with a single parameter
10581 specifies a conversion from the type of its first
10582 parameter to the type of its class. Such a constructor
10583 is called a converting constructor. */
10584 if (explicitp
== 2)
10585 DECL_NONCONVERTING_P (decl
) = 1;
10587 else if (!staticp
&& !dependent_type_p (type
)
10588 && !COMPLETE_TYPE_P (complete_type (type
))
10589 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10591 if (unqualified_id
)
10592 error ("field %qD has incomplete type %qT",
10593 unqualified_id
, type
);
10595 error ("name %qT has incomplete type", type
);
10597 type
= error_mark_node
;
10604 error ("%qE is neither function nor member function; "
10605 "cannot be declared friend", unqualified_id
);
10613 /* Friends are treated specially. */
10614 if (ctype
== current_class_type
)
10615 ; /* We already issued a permerror. */
10616 else if (decl
&& DECL_NAME (decl
))
10618 if (template_class_depth (current_class_type
) == 0)
10620 decl
= check_explicit_specialization
10621 (unqualified_id
, decl
, template_count
,
10622 2 * funcdef_flag
+ 4);
10623 if (decl
== error_mark_node
)
10624 return error_mark_node
;
10627 decl
= do_friend (ctype
, unqualified_id
, decl
,
10633 return error_mark_node
;
10636 /* Structure field. It may not be a function, except for C++. */
10638 if (decl
== NULL_TREE
)
10642 /* C++ allows static class members. All other work
10643 for this is done by grokfield. */
10644 decl
= build_lang_decl_loc (declarator
10645 ? declarator
->id_loc
10647 VAR_DECL
, unqualified_id
, type
);
10648 set_linkage_for_static_data_member (decl
);
10649 /* Even if there is an in-class initialization, DECL
10650 is considered undefined until an out-of-class
10651 definition is provided. */
10652 DECL_EXTERNAL (decl
) = 1;
10656 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
10657 if (declspecs
->gnu_thread_keyword_p
)
10658 DECL_GNU_TLS_P (decl
) = true;
10661 if (constexpr_p
&& !initialized
)
10663 error ("constexpr static data member %qD must have an "
10664 "initializer", decl
);
10665 constexpr_p
= false;
10672 error ("non-static data member %qE declared %<constexpr%>",
10674 constexpr_p
= false;
10676 decl
= build_decl (input_location
,
10677 FIELD_DECL
, unqualified_id
, type
);
10678 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10679 if (bitfield
&& !unqualified_id
)
10680 TREE_NO_WARNING (decl
) = 1;
10682 if (storage_class
== sc_mutable
)
10684 DECL_MUTABLE_P (decl
) = 1;
10685 storage_class
= sc_none
;
10690 /* An attempt is being made to initialize a non-static
10691 member. This is new in C++11. */
10692 maybe_warn_cpp0x (CPP0X_NSDMI
);
10694 /* If this has been parsed with static storage class, but
10695 errors forced staticp to be cleared, ensure NSDMI is
10697 if (declspecs
->storage_class
== sc_static
)
10698 DECL_INITIAL (decl
) = error_mark_node
;
10702 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10703 memfn_quals
!= TYPE_UNQUALIFIED
,
10704 inlinep
, friendp
, raises
!= NULL_TREE
);
10707 else if (TREE_CODE (type
) == FUNCTION_TYPE
10708 || TREE_CODE (type
) == METHOD_TYPE
)
10710 tree original_name
;
10713 if (!unqualified_id
)
10714 return error_mark_node
;
10716 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10717 original_name
= dname
;
10719 original_name
= unqualified_id
;
10721 if (storage_class
== sc_auto
)
10722 error ("storage class %<auto%> invalid for function %qs", name
);
10723 else if (storage_class
== sc_register
)
10724 error ("storage class %<register%> invalid for function %qs", name
);
10727 if (declspecs
->gnu_thread_keyword_p
)
10728 error ("storage class %<__thread%> invalid for function %qs",
10731 error ("storage class %<thread_local%> invalid for function %qs",
10735 if (virt_specifiers
)
10736 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10737 /* Function declaration not at top level.
10738 Storage classes other than `extern' are not allowed
10739 and `extern' makes no difference. */
10740 if (! toplevel_bindings_p ()
10741 && (storage_class
== sc_static
10742 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10745 if (storage_class
== sc_static
)
10746 pedwarn (input_location
, OPT_Wpedantic
,
10747 "%<static%> specified invalid for function %qs "
10748 "declared out of global scope", name
);
10750 pedwarn (input_location
, OPT_Wpedantic
,
10751 "%<inline%> specifier invalid for function %qs "
10752 "declared out of global scope", name
);
10755 if (ctype
== NULL_TREE
)
10759 error ("virtual non-class function %qs", name
);
10762 else if (sfk
== sfk_constructor
10763 || sfk
== sfk_destructor
)
10765 error (funcdef_flag
10766 ? G_("%qs defined in a non-class scope")
10767 : G_("%qs declared in a non-class scope"), name
);
10772 /* Record whether the function is public. */
10773 publicp
= (ctype
!= NULL_TREE
10774 || storage_class
!= sc_static
);
10776 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10777 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10779 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10781 template_count
, in_namespace
, attrlist
,
10782 declarator
->id_loc
);
10783 if (decl
== NULL_TREE
)
10784 return error_mark_node
;
10788 int invalid_static
= 0;
10790 /* Don't allow a static member function in a class, and forbid
10791 declaring main to be static. */
10792 if (TREE_CODE (type
) == METHOD_TYPE
)
10794 permerror (input_location
, "cannot declare member function %qD to have "
10795 "static linkage", decl
);
10796 invalid_static
= 1;
10798 else if (current_function_decl
)
10800 /* FIXME need arm citation */
10801 error ("cannot declare static function inside another function");
10802 invalid_static
= 1;
10805 if (invalid_static
)
10808 storage_class
= sc_none
;
10814 /* It's a variable. */
10816 /* An uninitialized decl with `extern' is a reference. */
10817 decl
= grokvardecl (type
, unqualified_id
,
10820 (type_quals
& TYPE_QUAL_CONST
) != 0,
10821 ctype
? ctype
: in_namespace
);
10822 bad_specifiers (decl
, BSP_VAR
, virtualp
,
10823 memfn_quals
!= TYPE_UNQUALIFIED
,
10824 inlinep
, friendp
, raises
!= NULL_TREE
);
10828 DECL_CONTEXT (decl
) = ctype
;
10831 permerror (input_location
, "%<static%> may not be used when defining "
10832 "(as opposed to declaring) a static data member");
10834 storage_class
= sc_none
;
10836 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
10838 error ("static member %qD declared %<register%>", decl
);
10839 storage_class
= sc_none
;
10841 if (storage_class
== sc_extern
&& pedantic
)
10843 pedwarn (input_location
, OPT_Wpedantic
,
10844 "cannot explicitly declare member %q#D to have "
10845 "extern linkage", decl
);
10846 storage_class
= sc_none
;
10849 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
10851 error ("declaration of constexpr variable %qD is not a definition",
10853 constexpr_p
= false;
10857 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
10859 if (toplevel_bindings_p ())
10861 /* It's common practice (and completely valid) to have a const
10862 be initialized and declared extern. */
10863 if (!(type_quals
& TYPE_QUAL_CONST
))
10864 warning (0, "%qs initialized and declared %<extern%>", name
);
10868 error ("%qs has both %<extern%> and initializer", name
);
10869 return error_mark_node
;
10873 /* Record `register' declaration for warnings on &
10874 and in case doing stupid register allocation. */
10876 if (storage_class
== sc_register
)
10877 DECL_REGISTER (decl
) = 1;
10878 else if (storage_class
== sc_extern
)
10879 DECL_THIS_EXTERN (decl
) = 1;
10880 else if (storage_class
== sc_static
)
10881 DECL_THIS_STATIC (decl
) = 1;
10883 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10884 if (constexpr_p
&& VAR_P (decl
))
10885 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
10887 /* Record constancy and volatility on the DECL itself . There's
10888 no need to do this when processing a template; we'll do this
10889 for the instantiated declaration based on the type of DECL. */
10890 if (!processing_template_decl
)
10891 cp_apply_type_quals_to_decl (type_quals
, decl
);
10897 /* Subroutine of start_function. Ensure that each of the parameter
10898 types (as listed in PARMS) is complete, as is required for a
10899 function definition. */
10902 require_complete_types_for_parms (tree parms
)
10904 for (; parms
; parms
= DECL_CHAIN (parms
))
10906 if (dependent_type_p (TREE_TYPE (parms
)))
10908 if (!VOID_TYPE_P (TREE_TYPE (parms
))
10909 && complete_type_or_else (TREE_TYPE (parms
), parms
))
10911 relayout_decl (parms
);
10912 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
10915 /* grokparms or complete_type_or_else will have already issued
10917 TREE_TYPE (parms
) = error_mark_node
;
10921 /* Returns nonzero if T is a local variable. */
10924 local_variable_p (const_tree t
)
10927 /* A VAR_DECL with a context that is a _TYPE is a static data
10929 && !TYPE_P (CP_DECL_CONTEXT (t
))
10930 /* Any other non-local variable must be at namespace scope. */
10931 && !DECL_NAMESPACE_SCOPE_P (t
))
10932 || (TREE_CODE (t
) == PARM_DECL
))
10938 /* Like local_variable_p, but suitable for use as a tree-walking
10942 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
10945 if (local_variable_p (*tp
)
10946 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
10948 else if (TYPE_P (*tp
))
10949 *walk_subtrees
= 0;
10954 /* Check that ARG, which is a default-argument expression for a
10955 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10956 something goes wrong. DECL may also be a _TYPE node, rather than a
10957 DECL, if there is no DECL available. */
10960 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
10965 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10966 /* We get a DEFAULT_ARG when looking at an in-class declaration
10967 with a default argument. Ignore the argument for now; we'll
10968 deal with it after the class is complete. */
10977 decl_type
= TREE_TYPE (decl
);
10979 if (arg
== error_mark_node
10980 || decl
== error_mark_node
10981 || TREE_TYPE (arg
) == error_mark_node
10982 || decl_type
== error_mark_node
)
10983 /* Something already went wrong. There's no need to check
10985 return error_mark_node
;
10987 /* [dcl.fct.default]
10989 A default argument expression is implicitly converted to the
10991 ++cp_unevaluated_operand
;
10992 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
10994 --cp_unevaluated_operand
;
10996 if (warn_zero_as_null_pointer_constant
10997 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
10998 && null_ptr_cst_p (arg
)
10999 && (complain
& tf_warning
)
11000 && maybe_warn_zero_as_null_pointer_constant (arg
, input_location
))
11001 return nullptr_node
;
11003 /* [dcl.fct.default]
11005 Local variables shall not be used in default argument
11008 The keyword `this' shall not be used in a default argument of a
11009 member function. */
11010 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11013 if (complain
& tf_warning_or_error
)
11015 if (DECL_NAME (var
) == this_identifier
)
11016 permerror (input_location
, "default argument %qE uses %qD",
11019 error ("default argument %qE uses local variable %qD", arg
, var
);
11021 return error_mark_node
;
11028 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11031 type_is_deprecated (tree type
)
11033 enum tree_code code
;
11034 if (TREE_DEPRECATED (type
))
11036 if (TYPE_NAME (type
)
11037 && TREE_DEPRECATED (TYPE_NAME (type
)))
11040 /* Do warn about using typedefs to a deprecated class. */
11041 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11042 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11044 code
= TREE_CODE (type
);
11046 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11047 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11048 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11049 return type_is_deprecated (TREE_TYPE (type
));
11051 if (TYPE_PTRMEMFUNC_P (type
))
11052 return type_is_deprecated
11053 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11058 /* Decode the list of parameter types for a function type.
11059 Given the list of things declared inside the parens,
11060 return a list of types.
11062 If this parameter does not end with an ellipsis, we append
11065 *PARMS is set to the chain of PARM_DECLs created. */
11068 grokparms (tree parmlist
, tree
*parms
)
11070 tree result
= NULL_TREE
;
11071 tree decls
= NULL_TREE
;
11075 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11077 tree type
= NULL_TREE
;
11078 tree init
= TREE_PURPOSE (parm
);
11079 tree decl
= TREE_VALUE (parm
);
11080 const char *errmsg
;
11082 if (parm
== void_list_node
)
11085 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11088 type
= TREE_TYPE (decl
);
11089 if (VOID_TYPE_P (type
))
11091 if (same_type_p (type
, void_type_node
)
11092 && DECL_SELF_REFERENCE_P (type
)
11093 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
11094 /* this is a parmlist of `(void)', which is ok. */
11096 cxx_incomplete_type_error (decl
, type
);
11097 /* It's not a good idea to actually create parameters of
11098 type `void'; other parts of the compiler assume that a
11099 void type terminates the parameter list. */
11100 type
= error_mark_node
;
11101 TREE_TYPE (decl
) = error_mark_node
;
11104 if (type
!= error_mark_node
11105 && TYPE_FOR_JAVA (type
)
11106 && MAYBE_CLASS_TYPE_P (type
))
11108 error ("parameter %qD has Java class type", decl
);
11109 type
= error_mark_node
;
11110 TREE_TYPE (decl
) = error_mark_node
;
11114 if (type
!= error_mark_node
11115 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11118 type
= error_mark_node
;
11119 TREE_TYPE (decl
) = error_mark_node
;
11122 if (type
!= error_mark_node
)
11124 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11126 tree deptype
= type_is_deprecated (type
);
11128 warn_deprecated_use (deptype
, NULL_TREE
);
11131 /* Top-level qualifiers on the parameters are
11132 ignored for function types. */
11133 type
= cp_build_qualified_type (type
, 0);
11134 if (TREE_CODE (type
) == METHOD_TYPE
)
11136 error ("parameter %qD invalidly declared method type", decl
);
11137 type
= build_pointer_type (type
);
11138 TREE_TYPE (decl
) = type
;
11140 else if (abstract_virtuals_error (decl
, type
))
11141 any_error
= 1; /* Seems like a good idea. */
11142 else if (POINTER_TYPE_P (type
))
11144 /* [dcl.fct]/6, parameter types cannot contain pointers
11145 (references) to arrays of unknown bound. */
11146 tree t
= TREE_TYPE (type
);
11147 int ptr
= TYPE_PTR_P (type
);
11151 if (TYPE_PTR_P (t
))
11153 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11155 else if (!TYPE_DOMAIN (t
))
11159 if (TREE_CODE (t
) == ARRAY_TYPE
)
11161 ? G_("parameter %qD includes pointer to array of "
11162 "unknown bound %qT")
11163 : G_("parameter %qD includes reference to array of "
11164 "unknown bound %qT"),
11170 else if (init
&& !processing_template_decl
)
11171 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11174 DECL_CHAIN (decl
) = decls
;
11176 result
= tree_cons (init
, type
, result
);
11178 decls
= nreverse (decls
);
11179 result
= nreverse (result
);
11181 result
= chainon (result
, void_list_node
);
11188 /* D is a constructor or overloaded `operator='.
11190 Let T be the class in which D is declared. Then, this function
11193 -1 if D's is an ill-formed constructor or copy assignment operator
11194 whose first parameter is of type `T'.
11195 0 if D is not a copy constructor or copy assignment
11197 1 if D is a copy constructor or copy assignment operator whose
11198 first parameter is a reference to non-const qualified T.
11199 2 if D is a copy constructor or copy assignment operator whose
11200 first parameter is a reference to const qualified T.
11202 This function can be used as a predicate. Positive values indicate
11203 a copy constructor and nonzero values indicate a copy assignment
11207 copy_fn_p (const_tree d
)
11213 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11215 if (TREE_CODE (d
) == TEMPLATE_DECL
11216 || (DECL_TEMPLATE_INFO (d
)
11217 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11218 /* Instantiations of template member functions are never copy
11219 functions. Note that member functions of templated classes are
11220 represented as template functions internally, and we must
11221 accept those as copy functions. */
11224 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11228 arg_type
= TREE_VALUE (args
);
11229 if (arg_type
== error_mark_node
)
11232 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11234 /* Pass by value copy assignment operator. */
11237 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11238 && !TYPE_REF_IS_RVALUE (arg_type
)
11239 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11241 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11247 args
= TREE_CHAIN (args
);
11249 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11250 /* There are more non-optional args. */
11256 /* D is a constructor or overloaded `operator='.
11258 Let T be the class in which D is declared. Then, this function
11259 returns true when D is a move constructor or move assignment
11260 operator, false otherwise. */
11263 move_fn_p (const_tree d
)
11265 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11267 if (cxx_dialect
== cxx98
)
11268 /* There are no move constructors if we are in C++98 mode. */
11271 if (TREE_CODE (d
) == TEMPLATE_DECL
11272 || (DECL_TEMPLATE_INFO (d
)
11273 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11274 /* Instantiations of template member functions are never move
11275 functions. Note that member functions of templated classes are
11276 represented as template functions internally, and we must
11277 accept those as move functions. */
11280 return move_signature_fn_p (d
);
11283 /* D is a constructor or overloaded `operator='.
11285 Then, this function returns true when D has the same signature as a move
11286 constructor or move assignment operator (because either it is such a
11287 ctor/op= or it is a template specialization with the same signature),
11288 false otherwise. */
11291 move_signature_fn_p (const_tree d
)
11295 bool result
= false;
11297 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11301 arg_type
= TREE_VALUE (args
);
11302 if (arg_type
== error_mark_node
)
11305 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11306 && TYPE_REF_IS_RVALUE (arg_type
)
11307 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11311 args
= TREE_CHAIN (args
);
11313 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11314 /* There are more non-optional args. */
11320 /* Remember any special properties of member function DECL. */
11323 grok_special_member_properties (tree decl
)
11327 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11330 class_type
= DECL_CONTEXT (decl
);
11331 if (DECL_CONSTRUCTOR_P (decl
))
11333 int ctor
= copy_fn_p (decl
);
11335 if (!DECL_ARTIFICIAL (decl
))
11336 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11342 A non-template constructor for class X is a copy
11343 constructor if its first parameter is of type X&, const
11344 X&, volatile X& or const volatile X&, and either there
11345 are no other parameters or else all other parameters have
11346 default arguments. */
11347 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11348 if (user_provided_p (decl
))
11349 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11351 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11353 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11355 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11356 if (user_provided_p (decl
))
11357 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
11359 else if (move_fn_p (decl
) && user_provided_p (decl
))
11360 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11361 else if (is_list_ctor (decl
))
11362 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11364 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11365 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11366 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11368 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11372 A non-template assignment operator for class X is a copy
11373 assignment operator if its parameter is of type X, X&, const
11374 X&, volatile X& or const volatile X&. */
11376 int assop
= copy_fn_p (decl
);
11380 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11381 if (user_provided_p (decl
))
11382 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11384 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11386 else if (move_fn_p (decl
) && user_provided_p (decl
))
11387 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11389 /* Destructors are handled in check_methods. */
11392 /* Check a constructor DECL has the correct form. Complains
11393 if the class has a constructor of the form X(X). */
11396 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11398 int ctor_parm
= copy_fn_p (decl
);
11404 A declaration of a constructor for a class X is ill-formed if
11405 its first parameter is of type (optionally cv-qualified) X
11406 and either there are no other parameters or else all other
11407 parameters have default arguments.
11409 We *don't* complain about member template instantiations that
11410 have this form, though; they can occur as we try to decide
11411 what constructor to use during overload resolution. Since
11412 overload resolution will never prefer such a constructor to
11413 the non-template copy constructor (which is either explicitly
11414 or implicitly defined), there's no need to worry about their
11415 existence. Theoretically, they should never even be
11416 instantiated, but that's hard to forestall. */
11417 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11425 /* An operator with this code is unary, but can also be binary. */
11428 ambi_op_p (enum tree_code code
)
11430 return (code
== INDIRECT_REF
11431 || code
== ADDR_EXPR
11432 || code
== UNARY_PLUS_EXPR
11433 || code
== NEGATE_EXPR
11434 || code
== PREINCREMENT_EXPR
11435 || code
== PREDECREMENT_EXPR
);
11438 /* An operator with this name can only be unary. */
11441 unary_op_p (enum tree_code code
)
11443 return (code
== TRUTH_NOT_EXPR
11444 || code
== BIT_NOT_EXPR
11445 || code
== COMPONENT_REF
11446 || code
== TYPE_EXPR
);
11449 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11450 errors are issued for invalid declarations. */
11453 grok_op_properties (tree decl
, bool complain
)
11455 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11457 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11458 tree name
= DECL_NAME (decl
);
11459 enum tree_code operator_code
;
11464 /* Count the number of arguments and check for ellipsis. */
11465 for (argtype
= argtypes
, arity
= 0;
11466 argtype
&& argtype
!= void_list_node
;
11467 argtype
= TREE_CHAIN (argtype
))
11469 ellipsis_p
= !argtype
;
11471 class_type
= DECL_CONTEXT (decl
);
11472 if (class_type
&& !CLASS_TYPE_P (class_type
))
11473 class_type
= NULL_TREE
;
11475 if (DECL_CONV_FN_P (decl
))
11476 operator_code
= TYPE_EXPR
;
11480 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11481 if (ansi_opname (CODE) == name) \
11483 operator_code = (CODE); \
11486 else if (ansi_assopname (CODE) == name) \
11488 operator_code = (CODE); \
11489 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11493 #include "operators.def"
11494 #undef DEF_OPERATOR
11496 gcc_unreachable ();
11499 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11500 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11503 switch (operator_code
)
11506 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11510 TYPE_GETS_DELETE (class_type
) |= 1;
11514 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11517 case VEC_DELETE_EXPR
:
11518 TYPE_GETS_DELETE (class_type
) |= 2;
11525 /* [basic.std.dynamic.allocation]/1:
11527 A program is ill-formed if an allocation function is declared
11528 in a namespace scope other than global scope or declared static
11531 The same also holds true for deallocation functions. */
11532 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11533 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11535 if (DECL_NAMESPACE_SCOPE_P (decl
))
11537 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11539 error ("%qD may not be declared within a namespace", decl
);
11542 else if (!TREE_PUBLIC (decl
))
11544 error ("%qD may not be declared as static", decl
);
11550 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11552 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11553 DECL_IS_OPERATOR_NEW (decl
) = 1;
11555 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11556 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11559 /* An operator function must either be a non-static member function
11560 or have at least one parameter of a class, a reference to a class,
11561 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11562 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11564 if (operator_code
== TYPE_EXPR
11565 || operator_code
== CALL_EXPR
11566 || operator_code
== COMPONENT_REF
11567 || operator_code
== ARRAY_REF
11568 || operator_code
== NOP_EXPR
)
11570 error ("%qD must be a nonstatic member function", decl
);
11577 if (DECL_STATIC_FUNCTION_P (decl
))
11579 error ("%qD must be either a non-static member "
11580 "function or a non-member function", decl
);
11584 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11586 tree arg
= non_reference (TREE_VALUE (p
));
11587 if (arg
== error_mark_node
)
11590 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11591 because these checks are performed even on
11592 template functions. */
11593 if (MAYBE_CLASS_TYPE_P (arg
)
11594 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11598 if (!p
|| p
== void_list_node
)
11601 error ("%qD must have an argument of class or "
11602 "enumerated type", decl
);
11608 /* There are no restrictions on the arguments to an overloaded
11610 if (operator_code
== CALL_EXPR
)
11613 /* Warn about conversion operators that will never be used. */
11614 if (IDENTIFIER_TYPENAME_P (name
)
11615 && ! DECL_TEMPLATE_INFO (decl
)
11617 /* Warn only declaring the function; there is no need to
11618 warn again about out-of-class definitions. */
11619 && class_type
== current_class_type
)
11621 tree t
= TREE_TYPE (name
);
11622 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11625 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11627 if (VOID_TYPE_P (t
))
11628 warning (OPT_Wconversion
,
11630 ? G_("conversion to a reference to void "
11631 "will never use a type conversion operator")
11632 : G_("conversion to void "
11633 "will never use a type conversion operator"));
11634 else if (class_type
)
11636 if (t
== class_type
)
11637 warning (OPT_Wconversion
,
11639 ? G_("conversion to a reference to the same type "
11640 "will never use a type conversion operator")
11641 : G_("conversion to the same type "
11642 "will never use a type conversion operator"));
11643 /* Don't force t to be complete here. */
11644 else if (MAYBE_CLASS_TYPE_P (t
)
11645 && COMPLETE_TYPE_P (t
)
11646 && DERIVED_FROM_P (t
, class_type
))
11647 warning (OPT_Wconversion
,
11649 ? G_("conversion to a reference to a base class "
11650 "will never use a type conversion operator")
11651 : G_("conversion to a base class "
11652 "will never use a type conversion operator"));
11657 if (operator_code
== COND_EXPR
)
11660 error ("ISO C++ prohibits overloading operator ?:");
11663 else if (ellipsis_p
)
11665 error ("%qD must not have variable number of arguments", decl
);
11668 else if (ambi_op_p (operator_code
))
11671 /* We pick the one-argument operator codes by default, so
11672 we don't have to change anything. */
11674 else if (arity
== 2)
11676 /* If we thought this was a unary operator, we now know
11677 it to be a binary operator. */
11678 switch (operator_code
)
11681 operator_code
= MULT_EXPR
;
11685 operator_code
= BIT_AND_EXPR
;
11688 case UNARY_PLUS_EXPR
:
11689 operator_code
= PLUS_EXPR
;
11693 operator_code
= MINUS_EXPR
;
11696 case PREINCREMENT_EXPR
:
11697 operator_code
= POSTINCREMENT_EXPR
;
11700 case PREDECREMENT_EXPR
:
11701 operator_code
= POSTDECREMENT_EXPR
;
11705 gcc_unreachable ();
11708 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11710 if ((operator_code
== POSTINCREMENT_EXPR
11711 || operator_code
== POSTDECREMENT_EXPR
)
11712 && ! processing_template_decl
11713 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11716 error ("postfix %qD must take %<int%> as its argument",
11719 error ("postfix %qD must take %<int%> as its second "
11727 error ("%qD must take either zero or one argument", decl
);
11729 error ("%qD must take either one or two arguments", decl
);
11733 /* More Effective C++ rule 6. */
11735 && (operator_code
== POSTINCREMENT_EXPR
11736 || operator_code
== POSTDECREMENT_EXPR
11737 || operator_code
== PREINCREMENT_EXPR
11738 || operator_code
== PREDECREMENT_EXPR
))
11740 tree arg
= TREE_VALUE (argtypes
);
11741 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11742 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11743 arg
= TREE_TYPE (arg
);
11744 arg
= TYPE_MAIN_VARIANT (arg
);
11745 if (operator_code
== PREINCREMENT_EXPR
11746 || operator_code
== PREDECREMENT_EXPR
)
11748 if (TREE_CODE (ret
) != REFERENCE_TYPE
11749 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11751 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11752 build_reference_type (arg
));
11756 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11757 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11761 else if (unary_op_p (operator_code
))
11766 error ("%qD must take %<void%>", decl
);
11768 error ("%qD must take exactly one argument", decl
);
11772 else /* if (binary_op_p (operator_code)) */
11777 error ("%qD must take exactly one argument", decl
);
11779 error ("%qD must take exactly two arguments", decl
);
11783 /* More Effective C++ rule 7. */
11785 && (operator_code
== TRUTH_ANDIF_EXPR
11786 || operator_code
== TRUTH_ORIF_EXPR
11787 || operator_code
== COMPOUND_EXPR
))
11788 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11792 /* Effective C++ rule 23. */
11795 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11796 && (operator_code
== PLUS_EXPR
11797 || operator_code
== MINUS_EXPR
11798 || operator_code
== TRUNC_DIV_EXPR
11799 || operator_code
== MULT_EXPR
11800 || operator_code
== TRUNC_MOD_EXPR
)
11801 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11802 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11804 /* [over.oper]/8 */
11805 for (; argtypes
&& argtypes
!= void_list_node
;
11806 argtypes
= TREE_CHAIN (argtypes
))
11807 if (TREE_PURPOSE (argtypes
))
11809 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11810 if (operator_code
== POSTINCREMENT_EXPR
11811 || operator_code
== POSTDECREMENT_EXPR
)
11813 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
11818 error ("%qD cannot have default arguments", decl
);
11826 /* Return a string giving the keyword associate with CODE. */
11828 static const char *
11829 tag_name (enum tag_types code
)
11841 case typename_type
:
11844 gcc_unreachable ();
11848 /* Name lookup in an elaborated-type-specifier (after the keyword
11849 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11850 elaborated-type-specifier is invalid, issue a diagnostic and return
11851 error_mark_node; otherwise, return the *_TYPE to which it referred.
11852 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11855 check_elaborated_type_specifier (enum tag_types tag_code
,
11857 bool allow_template_p
)
11863 struct S { struct S *p; };
11865 name lookup will find the TYPE_DECL for the implicit "S::S"
11866 typedef. Adjust for that here. */
11867 if (DECL_SELF_REFERENCE_P (decl
))
11868 decl
= TYPE_NAME (TREE_TYPE (decl
));
11870 type
= TREE_TYPE (decl
);
11872 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11873 is false for this case as well. */
11874 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11876 error ("using template type parameter %qT after %qs",
11877 type
, tag_name (tag_code
));
11878 return error_mark_node
;
11880 /* Accept template template parameters. */
11881 else if (allow_template_p
11882 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
11883 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
11887 If the identifier resolves to a typedef-name or the
11888 simple-template-id resolves to an alias template
11889 specialization, the elaborated-type-specifier is ill-formed.
11891 In other words, the only legitimate declaration to use in the
11892 elaborated type specifier is the implicit typedef created when
11893 the type is declared. */
11894 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
11895 && !DECL_SELF_REFERENCE_P (decl
)
11896 && tag_code
!= typename_type
)
11898 if (alias_template_specialization_p (type
))
11899 error ("using alias template specialization %qT after %qs",
11900 type
, tag_name (tag_code
));
11902 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
11903 inform (DECL_SOURCE_LOCATION (decl
),
11904 "%qD has a previous declaration here", decl
);
11905 return error_mark_node
;
11907 else if (TREE_CODE (type
) != RECORD_TYPE
11908 && TREE_CODE (type
) != UNION_TYPE
11909 && tag_code
!= enum_type
11910 && tag_code
!= typename_type
)
11912 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
11913 inform (input_location
, "%q+T has a previous declaration here", type
);
11914 return error_mark_node
;
11916 else if (TREE_CODE (type
) != ENUMERAL_TYPE
11917 && tag_code
== enum_type
)
11919 error ("%qT referred to as enum", type
);
11920 inform (input_location
, "%q+T has a previous declaration here", type
);
11921 return error_mark_node
;
11923 else if (!allow_template_p
11924 && TREE_CODE (type
) == RECORD_TYPE
11925 && CLASSTYPE_IS_TEMPLATE (type
))
11927 /* If a class template appears as elaborated type specifier
11928 without a template header such as:
11930 template <class T> class C {};
11931 void f(class C); // No template header here
11933 then the required template argument is missing. */
11934 error ("template argument required for %<%s %T%>",
11935 tag_name (tag_code
),
11936 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
11937 return error_mark_node
;
11943 /* Lookup NAME in elaborate type specifier in scope according to
11944 SCOPE and issue diagnostics if necessary.
11945 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11946 found, and ERROR_MARK_NODE for type error. */
11949 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
11950 tag_scope scope
, bool template_header_p
)
11954 if (scope
== ts_global
)
11956 /* First try ordinary name lookup, ignoring hidden class name
11957 injected via friend declaration. */
11958 decl
= lookup_name_prefer_type (name
, 2);
11959 /* If that fails, the name will be placed in the smallest
11960 non-class, non-function-prototype scope according to 3.3.1/5.
11961 We may already have a hidden name declared as friend in this
11962 scope. So lookup again but not ignoring hidden names.
11963 If we find one, that name will be made visible rather than
11964 creating a new tag. */
11966 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
11969 decl
= lookup_type_scope (name
, scope
);
11972 && (DECL_CLASS_TEMPLATE_P (decl
)
11973 /* If scope is ts_current we're defining a class, so ignore a
11974 template template parameter. */
11975 || (scope
!= ts_current
11976 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
11977 decl
= DECL_TEMPLATE_RESULT (decl
);
11979 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
11981 /* Look for invalid nested type:
11985 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
11987 error ("%qD has the same name as the class in which it is "
11990 return error_mark_node
;
11993 /* Two cases we need to consider when deciding if a class
11994 template is allowed as an elaborated type specifier:
11995 1. It is a self reference to its own class.
11996 2. It comes with a template header.
12000 template <class T> class C {
12001 class C *c1; // DECL_SELF_REFERENCE_P is true
12004 template <class U> class C; // template_header_p is true
12005 template <class T> class C<T>::D {
12006 class C *c2; // DECL_SELF_REFERENCE_P is true
12009 t
= check_elaborated_type_specifier (tag_code
,
12012 | DECL_SELF_REFERENCE_P (decl
));
12015 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12017 error ("reference to %qD is ambiguous", name
);
12018 print_candidates (decl
);
12019 return error_mark_node
;
12025 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12026 Define the tag as a forward-reference if it is not defined.
12028 If a declaration is given, process it here, and report an error if
12029 multiple declarations are not identical.
12031 SCOPE is TS_CURRENT when this is also a definition. Only look in
12032 the current frame for the name (since C++ allows new names in any
12033 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12034 declaration. Only look beginning from the current scope outward up
12035 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12037 TEMPLATE_HEADER_P is true when this declaration is preceded by
12038 a set of template parameters. */
12041 xref_tag_1 (enum tag_types tag_code
, tree name
,
12042 tag_scope orig_scope
, bool template_header_p
)
12044 enum tree_code code
;
12046 tree context
= NULL_TREE
;
12049 gcc_assert (identifier_p (name
));
12055 code
= RECORD_TYPE
;
12061 code
= ENUMERAL_TYPE
;
12064 gcc_unreachable ();
12067 if (orig_scope
== ts_lambda
)
12068 scope
= ts_current
;
12070 scope
= orig_scope
;
12072 /* In case of anonymous name, xref_tag is only called to
12073 make type node and push name. Name lookup is not required. */
12074 if (ANON_AGGRNAME_P (name
))
12077 t
= lookup_and_check_tag (tag_code
, name
,
12078 scope
, template_header_p
);
12080 if (t
== error_mark_node
)
12081 return error_mark_node
;
12083 if (scope
!= ts_current
&& t
&& current_class_type
12084 && template_class_depth (current_class_type
)
12085 && template_header_p
)
12087 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12090 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12091 definition of this tag. Since, in addition, we are currently
12092 processing a (member) template declaration of a template
12093 class, we must be very careful; consider:
12100 { template <class V>
12101 friend struct S1; };
12103 Here, the S2::S1 declaration should not be confused with the
12104 outer declaration. In particular, the inner version should
12105 have a template parameter of level 2, not level 1. This
12106 would be particularly important if the member declaration
12109 template <class V = U> friend struct S1;
12111 say, when we should tsubst into `U' when instantiating
12112 S2. On the other hand, when presented with:
12122 we must find the inner binding eventually. We
12123 accomplish this by making sure that the new type we
12124 create to represent this declaration has the right
12126 context
= TYPE_CONTEXT (t
);
12132 /* If no such tag is yet defined, create a forward-reference node
12133 and record it as the "definition".
12134 When a real declaration of this type is found,
12135 the forward-reference will be altered into a real type. */
12136 if (code
== ENUMERAL_TYPE
)
12138 error ("use of enum %q#D without previous declaration", name
);
12139 return error_mark_node
;
12143 t
= make_class_type (code
);
12144 TYPE_CONTEXT (t
) = context
;
12145 if (orig_scope
== ts_lambda
)
12146 /* Remember that we're declaring a lambda to avoid bogus errors
12147 in push_template_decl. */
12148 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12149 t
= pushtag (name
, t
, scope
);
12154 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12156 if (!redeclare_class_template (t
, current_template_parms
))
12157 return error_mark_node
;
12159 else if (!processing_template_decl
12160 && CLASS_TYPE_P (t
)
12161 && CLASSTYPE_IS_TEMPLATE (t
))
12163 error ("redeclaration of %qT as a non-template", t
);
12164 error ("previous declaration %q+D", t
);
12165 return error_mark_node
;
12168 /* Make injected friend class visible. */
12169 if (scope
!= ts_within_enclosing_non_class
12170 && hidden_name_p (TYPE_NAME (t
)))
12172 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12173 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12175 if (TYPE_TEMPLATE_INFO (t
))
12177 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12178 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12186 /* Wrapper for xref_tag_1. */
12189 xref_tag (enum tag_types tag_code
, tree name
,
12190 tag_scope scope
, bool template_header_p
)
12194 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12195 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12196 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12202 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12204 enum tag_types tag_kind
;
12206 if (TREE_CODE (old
) == RECORD_TYPE
)
12207 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12209 tag_kind
= union_type
;
12211 if (id
== NULL_TREE
)
12212 id
= TYPE_IDENTIFIER (old
);
12214 return xref_tag (tag_kind
, id
, scope
, false);
12217 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12218 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12219 access_* node, and the TREE_VALUE is the type of the base-class.
12220 Non-NULL TREE_TYPE indicates virtual inheritance.
12222 Returns true if the binfo hierarchy was successfully created,
12223 false if an error was detected. */
12226 xref_basetypes (tree ref
, tree base_list
)
12229 tree binfo
, base_binfo
;
12230 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12231 unsigned max_bases
= 0; /* Maximum direct bases. */
12233 tree default_access
;
12234 tree igo_prev
; /* Track Inheritance Graph Order. */
12236 if (ref
== error_mark_node
)
12239 /* The base of a derived class is private by default, all others are
12241 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12242 && CLASSTYPE_DECLARED_CLASS (ref
)
12243 ? access_private_node
: access_public_node
);
12245 /* First, make sure that any templates in base-classes are
12246 instantiated. This ensures that if we call ourselves recursively
12247 we do not get confused about which classes are marked and which
12249 basep
= &base_list
;
12252 tree basetype
= TREE_VALUE (*basep
);
12254 /* The dependent_type_p call below should really be dependent_scope_p
12255 so that we give a hard error about using an incomplete type as a
12256 base, but we allow it with a pedwarn for backward
12258 if (processing_template_decl
12259 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12260 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12261 if (!dependent_type_p (basetype
)
12262 && !complete_type_or_else (basetype
, NULL
))
12263 /* An incomplete type. Remove it from the list. */
12264 *basep
= TREE_CHAIN (*basep
);
12268 if (TREE_TYPE (*basep
))
12270 if (CLASS_TYPE_P (basetype
))
12271 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12272 basep
= &TREE_CHAIN (*basep
);
12276 TYPE_MARKED_P (ref
) = 1;
12278 /* The binfo slot should be empty, unless this is an (ill-formed)
12280 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12282 error ("redefinition of %q#T", ref
);
12286 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12288 binfo
= make_tree_binfo (max_bases
);
12290 TYPE_BINFO (ref
) = binfo
;
12291 BINFO_OFFSET (binfo
) = size_zero_node
;
12292 BINFO_TYPE (binfo
) = ref
;
12294 /* Apply base-class info set up to the variants of this type. */
12295 fixup_type_variants (ref
);
12299 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12300 /* An aggregate cannot have baseclasses. */
12301 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12303 if (TREE_CODE (ref
) == UNION_TYPE
)
12305 error ("derived union %qT invalid", ref
);
12312 if (TYPE_FOR_JAVA (ref
))
12314 error ("Java class %qT cannot have multiple bases", ref
);
12321 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12323 if (TYPE_FOR_JAVA (ref
))
12325 error ("Java class %qT cannot have virtual bases", ref
);
12330 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12332 tree access
= TREE_PURPOSE (base_list
);
12333 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12334 tree basetype
= TREE_VALUE (base_list
);
12336 if (access
== access_default_node
)
12337 access
= default_access
;
12339 if (PACK_EXPANSION_P (basetype
))
12340 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12341 if (TREE_CODE (basetype
) == TYPE_DECL
)
12342 basetype
= TREE_TYPE (basetype
);
12343 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12345 error ("base type %qT fails to be a struct or class type",
12350 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12351 TYPE_FOR_JAVA (ref
) = 1;
12353 base_binfo
= NULL_TREE
;
12354 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12356 base_binfo
= TYPE_BINFO (basetype
);
12357 /* The original basetype could have been a typedef'd type. */
12358 basetype
= BINFO_TYPE (base_binfo
);
12360 /* Inherit flags from the base. */
12361 TYPE_HAS_NEW_OPERATOR (ref
)
12362 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12363 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12364 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12365 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12366 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12367 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12368 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12369 CLASSTYPE_REPEATED_BASE_P (ref
)
12370 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12373 /* We must do this test after we've seen through a typedef
12375 if (TYPE_MARKED_P (basetype
))
12377 if (basetype
== ref
)
12378 error ("recursive type %qT undefined", basetype
);
12380 error ("duplicate base type %qT invalid", basetype
);
12384 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12385 /* Regenerate the pack expansion for the bases. */
12386 basetype
= make_pack_expansion (basetype
);
12388 TYPE_MARKED_P (basetype
) = 1;
12390 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12391 &igo_prev
, via_virtual
);
12392 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12393 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12395 BINFO_BASE_APPEND (binfo
, base_binfo
);
12396 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12399 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12400 /* If we didn't get max_vbases vbases, we must have shared at
12401 least one of them, and are therefore diamond shaped. */
12402 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12404 /* Unmark all the types. */
12405 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12406 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12407 TYPE_MARKED_P (ref
) = 0;
12409 /* Now see if we have a repeated base type. */
12410 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12412 for (base_binfo
= binfo
; base_binfo
;
12413 base_binfo
= TREE_CHAIN (base_binfo
))
12415 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12417 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12420 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12422 for (base_binfo
= binfo
; base_binfo
;
12423 base_binfo
= TREE_CHAIN (base_binfo
))
12424 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12425 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12434 /* Copies the enum-related properties from type SRC to type DST.
12435 Used with the underlying type of an enum and the enum itself. */
12437 copy_type_enum (tree dst
, tree src
)
12440 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12442 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12443 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12444 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12445 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12446 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12447 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12448 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12449 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12450 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12454 /* Begin compiling the definition of an enumeration type.
12457 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12459 UNDERLYING_TYPE is the type that will be used as the storage for
12460 the enumeration type. This should be NULL_TREE if no storage type
12463 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12465 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12467 Returns the type object, as yet incomplete.
12468 Also records info about it so that build_enumerator
12469 may be used to declare the individual values as they are read. */
12472 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12473 bool scoped_enum_p
, bool *is_new
)
12475 tree prevtype
= NULL_TREE
;
12476 gcc_assert (identifier_p (name
));
12480 /* [C++0x dcl.enum]p5:
12482 If not explicitly specified, the underlying type of a scoped
12483 enumeration type is int. */
12484 if (!underlying_type
&& scoped_enum_p
)
12485 underlying_type
= integer_type_node
;
12487 if (underlying_type
)
12488 underlying_type
= cv_unqualified (underlying_type
);
12490 /* If this is the real definition for a previous forward reference,
12491 fill in the contents in the same object that used to be the
12492 forward reference. */
12494 enumtype
= lookup_and_check_tag (enum_type
, name
,
12495 /*tag_scope=*/ts_current
,
12496 /*template_header_p=*/false);
12498 /* In case of a template_decl, the only check that should be deferred
12499 to instantiation time is the comparison of underlying types. */
12500 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12502 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12504 error_at (input_location
, "scoped/unscoped mismatch "
12505 "in enum %q#T", enumtype
);
12506 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12507 "previous definition here");
12508 enumtype
= error_mark_node
;
12510 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12512 error_at (input_location
, "underlying type mismatch "
12513 "in enum %q#T", enumtype
);
12514 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12515 "previous definition here");
12516 enumtype
= error_mark_node
;
12518 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12519 && !dependent_type_p (underlying_type
)
12520 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12521 && !same_type_p (underlying_type
,
12522 ENUM_UNDERLYING_TYPE (enumtype
)))
12524 error_at (input_location
, "different underlying type "
12525 "in enum %q#T", enumtype
);
12526 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12527 "previous definition here");
12528 underlying_type
= NULL_TREE
;
12532 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12533 || processing_template_decl
)
12535 /* In case of error, make a dummy enum to allow parsing to
12537 if (enumtype
== error_mark_node
)
12539 name
= make_anon_name ();
12540 enumtype
= NULL_TREE
;
12543 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12544 of an opaque enum, or an opaque enum of an already defined
12545 enumeration (C++0x only).
12546 In any other case, it'll be NULL_TREE. */
12552 prevtype
= enumtype
;
12554 /* Do not push the decl more than once, unless we need to
12555 compare underlying types at instantiation time */
12557 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12558 || (underlying_type
12559 && dependent_type_p (underlying_type
))
12560 || (ENUM_UNDERLYING_TYPE (enumtype
)
12561 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12563 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12564 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12567 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12570 if (enumtype
== error_mark_node
)
12571 return error_mark_node
;
12573 /* The enum is considered opaque until the opening '{' of the
12574 enumerator list. */
12575 SET_OPAQUE_ENUM_P (enumtype
, true);
12576 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12579 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12581 if (underlying_type
)
12583 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12585 copy_type_enum (enumtype
, underlying_type
);
12586 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12588 else if (dependent_type_p (underlying_type
))
12589 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12591 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12592 underlying_type
, enumtype
);
12595 /* If into a template class, the returned enum is always the first
12596 declaration (opaque or not) seen. This way all the references to
12597 this type will be to the same declaration. The following ones are used
12598 only to check for definition errors. */
12599 if (prevtype
&& processing_template_decl
)
12605 /* After processing and defining all the values of an enumeration type,
12606 install their decls in the enumeration type.
12607 ENUMTYPE is the type object. */
12610 finish_enum_value_list (tree enumtype
)
12613 tree underlying_type
;
12616 tree minnode
, maxnode
;
12619 bool fixed_underlying_type_p
12620 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12622 /* We built up the VALUES in reverse order. */
12623 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12625 /* For an enum defined in a template, just set the type of the values;
12626 all further processing is postponed until the template is
12627 instantiated. We need to set the type so that tsubst of a CONST_DECL
12629 if (processing_template_decl
)
12631 for (values
= TYPE_VALUES (enumtype
);
12633 values
= TREE_CHAIN (values
))
12634 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12638 /* Determine the minimum and maximum values of the enumerators. */
12639 if (TYPE_VALUES (enumtype
))
12641 minnode
= maxnode
= NULL_TREE
;
12643 for (values
= TYPE_VALUES (enumtype
);
12645 values
= TREE_CHAIN (values
))
12647 decl
= TREE_VALUE (values
);
12649 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12650 each enumerator has the type of its enumeration. Prior to the
12651 closing brace, the type of each enumerator is the type of its
12652 initializing value. */
12653 TREE_TYPE (decl
) = enumtype
;
12655 /* Update the minimum and maximum values, if appropriate. */
12656 value
= DECL_INITIAL (decl
);
12657 if (value
== error_mark_node
)
12658 value
= integer_zero_node
;
12659 /* Figure out what the minimum and maximum values of the
12660 enumerators are. */
12662 minnode
= maxnode
= value
;
12663 else if (tree_int_cst_lt (maxnode
, value
))
12665 else if (tree_int_cst_lt (value
, minnode
))
12672 If the enumerator-list is empty, the underlying type is as if
12673 the enumeration had a single enumerator with value 0. */
12674 minnode
= maxnode
= integer_zero_node
;
12676 if (!fixed_underlying_type_p
)
12678 /* Compute the number of bits require to represent all values of the
12679 enumeration. We must do this before the type of MINNODE and
12680 MAXNODE are transformed, since tree_int_cst_min_precision relies
12681 on the TREE_TYPE of the value it is passed. */
12682 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
12683 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
12684 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
12685 int precision
= MAX (lowprec
, highprec
);
12687 bool use_short_enum
;
12689 /* Determine the underlying type of the enumeration.
12693 The underlying type of an enumeration is an integral type that
12694 can represent all the enumerator values defined in the
12695 enumeration. It is implementation-defined which integral type is
12696 used as the underlying type for an enumeration except that the
12697 underlying type shall not be larger than int unless the value of
12698 an enumerator cannot fit in an int or unsigned int.
12700 We use "int" or an "unsigned int" as the underlying type, even if
12701 a smaller integral type would work, unless the user has
12702 explicitly requested that we use the smallest possible type. The
12703 user can request that for all enumerations with a command line
12704 flag, or for just one enumeration with an attribute. */
12706 use_short_enum
= flag_short_enums
12707 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12709 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12713 underlying_type
= integer_types
[itk
];
12714 if (underlying_type
!= NULL_TREE
12715 && TYPE_PRECISION (underlying_type
) >= precision
12716 && TYPE_SIGN (underlying_type
) == sgn
)
12719 if (itk
== itk_none
)
12723 IF no integral type can represent all the enumerator values, the
12724 enumeration is ill-formed. */
12725 error ("no integral type can represent all of the enumerator values "
12726 "for %qT", enumtype
);
12727 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12728 underlying_type
= integer_types
[itk_unsigned_long_long
];
12733 The value of sizeof() applied to an enumeration type, an object
12734 of an enumeration type, or an enumerator, is the value of sizeof()
12735 applied to the underlying type. */
12736 copy_type_enum (enumtype
, underlying_type
);
12738 /* Compute the minimum and maximum values for the type.
12742 For an enumeration where emin is the smallest enumerator and emax
12743 is the largest, the values of the enumeration are the values of the
12744 underlying type in the range bmin to bmax, where bmin and bmax are,
12745 respectively, the smallest and largest values of the smallest bit-
12746 field that can store emin and emax. */
12748 /* The middle-end currently assumes that types with TYPE_PRECISION
12749 narrower than their underlying type are suitably zero or sign
12750 extended to fill their mode. Similarly, it assumes that the front
12751 end assures that a value of a particular type must be within
12752 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12754 We used to set these fields based on bmin and bmax, but that led
12755 to invalid assumptions like optimizing away bounds checking. So
12756 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12757 TYPE_MAX_VALUE to the values for the mode above and only restrict
12758 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12759 ENUM_UNDERLYING_TYPE (enumtype
)
12760 = build_distinct_type_copy (underlying_type
);
12761 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12762 set_min_and_max_values_for_integral_type
12763 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
12765 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12766 if (flag_strict_enums
)
12767 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
12770 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12772 /* Convert each of the enumerators to the type of the underlying
12773 type of the enumeration. */
12774 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12776 location_t saved_location
;
12778 decl
= TREE_VALUE (values
);
12779 saved_location
= input_location
;
12780 input_location
= DECL_SOURCE_LOCATION (decl
);
12781 if (fixed_underlying_type_p
)
12782 /* If the enumeration type has a fixed underlying type, we
12783 already checked all of the enumerator values. */
12784 value
= DECL_INITIAL (decl
);
12786 value
= perform_implicit_conversion (underlying_type
,
12787 DECL_INITIAL (decl
),
12788 tf_warning_or_error
);
12789 input_location
= saved_location
;
12791 /* Do not clobber shared ints. */
12792 value
= copy_node (value
);
12794 TREE_TYPE (value
) = enumtype
;
12795 DECL_INITIAL (decl
) = value
;
12798 /* Fix up all variant types of this enum type. */
12799 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12800 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12802 if (at_class_scope_p ()
12803 && COMPLETE_TYPE_P (current_class_type
)
12804 && UNSCOPED_ENUM_P (enumtype
))
12805 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
12806 current_class_type
);
12808 /* Finish debugging output for this type. */
12809 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12812 /* Finishes the enum type. This is called only the first time an
12813 enumeration is seen, be it opaque or odinary.
12814 ENUMTYPE is the type object. */
12817 finish_enum (tree enumtype
)
12819 if (processing_template_decl
)
12821 if (at_function_scope_p ())
12822 add_stmt (build_min (TAG_DEFN
, enumtype
));
12826 /* If this is a forward declaration, there should not be any variants,
12827 though we can get a variant in the middle of an enum-specifier with
12828 wacky code like 'enum E { e = sizeof(const E*) };' */
12829 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
12830 && (TYPE_VALUES (enumtype
)
12831 || !TYPE_NEXT_VARIANT (enumtype
)));
12834 /* Build and install a CONST_DECL for an enumeration constant of the
12835 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12836 LOC is the location of NAME.
12837 Assignment of sequential values by default is handled here. */
12840 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
12846 /* If the VALUE was erroneous, pretend it wasn't there; that will
12847 result in the enum being assigned the next value in sequence. */
12848 if (value
== error_mark_node
)
12851 /* Remove no-op casts from the value. */
12853 STRIP_TYPE_NOPS (value
);
12855 if (! processing_template_decl
)
12857 /* Validate and default VALUE. */
12858 if (value
!= NULL_TREE
)
12860 value
= cxx_constant_value (value
);
12862 if (TREE_CODE (value
) != INTEGER_CST
12863 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
12865 error ("enumerator value for %qD is not an integer constant",
12871 /* Default based on previous value. */
12872 if (value
== NULL_TREE
)
12874 if (TYPE_VALUES (enumtype
))
12879 /* C++03 7.2/4: If no initializer is specified for the first
12880 enumerator, the type is an unspecified integral
12881 type. Otherwise the type is the same as the type of the
12882 initializing value of the preceding enumerator unless the
12883 incremented value is not representable in that type, in
12884 which case the type is an unspecified integral type
12885 sufficient to contain the incremented value. */
12886 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12887 if (error_operand_p (prev_value
))
12888 value
= error_mark_node
;
12891 tree type
= TREE_TYPE (prev_value
);
12892 signop sgn
= TYPE_SIGN (type
);
12893 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
12897 bool pos
= !wi::neg_p (wi
, sgn
);
12898 if (!wi::fits_to_tree_p (wi
, type
))
12901 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
12903 type
= integer_types
[itk
];
12904 if (type
!= NULL_TREE
12905 && (pos
|| !TYPE_UNSIGNED (type
))
12906 && wi::fits_to_tree_p (wi
, type
))
12909 if (type
&& cxx_dialect
< cxx11
12910 && itk
> itk_unsigned_long
)
12911 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
12912 incremented enumerator value is too large for %<unsigned long%>" : "\
12913 incremented enumerator value is too large for %<long%>");
12915 if (type
== NULL_TREE
)
12918 value
= wide_int_to_tree (type
, wi
);
12923 error ("overflow in enumeration values at %qD", name
);
12924 value
= error_mark_node
;
12929 value
= integer_zero_node
;
12932 /* Remove no-op casts from the value. */
12933 STRIP_TYPE_NOPS (value
);
12935 /* If the underlying type of the enum is fixed, check whether
12936 the enumerator values fits in the underlying type. If it
12937 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12938 if (ENUM_UNDERLYING_TYPE (enumtype
)
12940 && TREE_CODE (value
) == INTEGER_CST
)
12942 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
12943 error ("enumerator value %E is outside the range of underlying "
12944 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
12946 /* Convert the value to the appropriate type. */
12947 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
12951 /* C++ associates enums with global, function, or class declarations. */
12952 context
= current_scope ();
12954 /* Build the actual enumeration constant. Note that the enumeration
12955 constants have the underlying type of the enum (if it is fixed)
12956 or the type of their initializer (if the underlying type of the
12957 enum is not fixed):
12961 If the underlying type is fixed, the type of each enumerator
12962 prior to the closing brace is the underlying type; if the
12963 initializing value of an enumerator cannot be represented by
12964 the underlying type, the program is ill-formed. If the
12965 underlying type is not fixed, the type of each enumerator is
12966 the type of its initializing value.
12968 If the underlying type is not fixed, it will be computed by
12969 finish_enum and we will reset the type of this enumerator. Of
12970 course, if we're processing a template, there may be no value. */
12971 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12973 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
12975 DECL_CONTEXT (decl
) = enumtype
;
12976 TREE_CONSTANT (decl
) = 1;
12977 TREE_READONLY (decl
) = 1;
12978 DECL_INITIAL (decl
) = value
;
12980 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
12981 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12982 on the TYPE_FIELDS list for `S'. (That's so that you can say
12983 things like `S::i' later.) */
12984 finish_member_declaration (decl
);
12988 /* Add this enumeration constant to the list for this type. */
12989 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12992 /* Look for an enumerator with the given NAME within the enumeration
12993 type ENUMTYPE. This routine is used primarily for qualified name
12994 lookup into an enumerator in C++0x, e.g.,
12996 enum class Color { Red, Green, Blue };
12998 Color color = Color::Red;
13000 Returns the value corresponding to the enumerator, or
13001 NULL_TREE if no such enumerator was found. */
13003 lookup_enumerator (tree enumtype
, tree name
)
13006 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13008 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13009 return e
? TREE_VALUE (e
) : NULL_TREE
;
13013 /* We're defining DECL. Make sure that its type is OK. */
13016 check_function_type (tree decl
, tree current_function_parms
)
13018 tree fntype
= TREE_TYPE (decl
);
13019 tree return_type
= complete_type (TREE_TYPE (fntype
));
13021 /* In a function definition, arg types must be complete. */
13022 require_complete_types_for_parms (current_function_parms
);
13024 if (dependent_type_p (return_type
)
13025 || type_uses_auto (return_type
))
13027 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13028 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13030 tree args
= TYPE_ARG_TYPES (fntype
);
13032 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13033 error ("return type %q#T is incomplete", return_type
);
13035 error ("return type has Java class type %q#T", return_type
);
13037 /* Make it return void instead. */
13038 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13039 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13041 TREE_CHAIN (args
));
13043 fntype
= build_function_type (void_type_node
, args
);
13045 = build_exception_variant (fntype
,
13046 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13047 fntype
= (cp_build_type_attribute_variant
13048 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13049 TREE_TYPE (decl
) = fntype
;
13052 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13055 /* Create the FUNCTION_DECL for a function definition.
13056 DECLSPECS and DECLARATOR are the parts of the declaration;
13057 they describe the function's name and the type it returns,
13058 but twisted together in a fashion that parallels the syntax of C.
13060 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13061 DECLARATOR is really the DECL for the function we are about to
13062 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13063 indicating that the function is an inline defined in-class.
13065 This function creates a binding context for the function body
13066 as well as setting up the FUNCTION_DECL in current_function_decl.
13068 For C++, we must first check whether that datum makes any sense.
13069 For example, "class A local_a(1,2);" means that variable local_a
13070 is an aggregate of type A, which should have a constructor
13071 applied to it with the argument list [1, 2].
13073 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13074 or may be a BLOCK if the function has been defined previously
13075 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13076 error_mark_node if the function has never been defined, or
13077 a BLOCK if the function has been defined somewhere. */
13080 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13082 tree ctype
= NULL_TREE
;
13085 int doing_friend
= 0;
13086 cp_binding_level
*bl
;
13087 tree current_function_parms
;
13088 struct c_fileinfo
*finfo
13089 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13090 bool honor_interface
;
13092 /* Sanity check. */
13093 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13094 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13096 fntype
= TREE_TYPE (decl1
);
13097 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13098 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13100 /* ISO C++ 11.4/5. A friend function defined in a class is in
13101 the (lexical) scope of the class in which it is defined. */
13102 if (!ctype
&& DECL_FRIEND_P (decl1
))
13104 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13106 /* CTYPE could be null here if we're dealing with a template;
13107 for example, `inline friend float foo()' inside a template
13108 will have no CTYPE set. */
13109 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13115 if (DECL_DECLARED_INLINE_P (decl1
)
13116 && lookup_attribute ("noinline", attrs
))
13117 warning (0, "inline function %q+D given attribute noinline", decl1
);
13119 /* Handle gnu_inline attribute. */
13120 if (GNU_INLINE_P (decl1
))
13122 DECL_EXTERNAL (decl1
) = 1;
13123 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13124 DECL_INTERFACE_KNOWN (decl1
) = 1;
13125 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13128 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13129 /* This is a constructor, we must ensure that any default args
13130 introduced by this definition are propagated to the clones
13131 now. The clones are used directly in overload resolution. */
13132 adjust_clone_args (decl1
);
13134 /* Sometimes we don't notice that a function is a static member, and
13135 build a METHOD_TYPE for it. Fix that up now. */
13136 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13137 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13139 /* Set up current_class_type, and enter the scope of the class, if
13142 push_nested_class (ctype
);
13143 else if (DECL_STATIC_FUNCTION_P (decl1
))
13144 push_nested_class (DECL_CONTEXT (decl1
));
13146 /* Now that we have entered the scope of the class, we must restore
13147 the bindings for any template parameters surrounding DECL1, if it
13148 is an inline member template. (Order is important; consider the
13149 case where a template parameter has the same name as a field of
13150 the class.) It is not until after this point that
13151 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13152 if (flags
& SF_INCLASS_INLINE
)
13153 maybe_begin_member_template_processing (decl1
);
13155 /* Effective C++ rule 15. */
13157 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13158 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13159 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13161 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13162 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13163 if (!DECL_INITIAL (decl1
))
13164 DECL_INITIAL (decl1
) = error_mark_node
;
13166 /* This function exists in static storage.
13167 (This does not mean `static' in the C sense!) */
13168 TREE_STATIC (decl1
) = 1;
13170 /* We must call push_template_decl after current_class_type is set
13171 up. (If we are processing inline definitions after exiting a
13172 class scope, current_class_type will be NULL_TREE until set above
13173 by push_nested_class.) */
13174 if (processing_template_decl
)
13176 tree newdecl1
= push_template_decl (decl1
);
13177 if (newdecl1
== error_mark_node
)
13179 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13180 pop_nested_class ();
13186 /* We are now in the scope of the function being defined. */
13187 current_function_decl
= decl1
;
13189 /* Save the parm names or decls from this function's declarator
13190 where store_parm_decls will find them. */
13191 current_function_parms
= DECL_ARGUMENTS (decl1
);
13193 /* Make sure the parameter and return types are reasonable. When
13194 you declare a function, these types can be incomplete, but they
13195 must be complete when you define the function. */
13196 check_function_type (decl1
, current_function_parms
);
13198 /* Build the return declaration for the function. */
13199 restype
= TREE_TYPE (fntype
);
13201 if (DECL_RESULT (decl1
) == NULL_TREE
)
13205 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13206 DECL_ARTIFICIAL (resdecl
) = 1;
13207 DECL_IGNORED_P (resdecl
) = 1;
13208 DECL_RESULT (decl1
) = resdecl
;
13210 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13213 /* Let the user know we're compiling this function. */
13214 announce_function (decl1
);
13216 /* Record the decl so that the function name is defined.
13217 If we already have a decl for this name, and it is a FUNCTION_DECL,
13218 use the old decl. */
13219 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13221 /* A specialization is not used to guide overload resolution. */
13222 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13223 && !(DECL_USE_TEMPLATE (decl1
) &&
13224 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13226 tree olddecl
= pushdecl (decl1
);
13228 if (olddecl
== error_mark_node
)
13229 /* If something went wrong when registering the declaration,
13230 use DECL1; we have to have a FUNCTION_DECL to use when
13231 parsing the body of the function. */
13235 /* Otherwise, OLDDECL is either a previous declaration
13236 of the same function or DECL1 itself. */
13238 if (warn_missing_declarations
13239 && olddecl
== decl1
13240 && !DECL_MAIN_P (decl1
)
13241 && TREE_PUBLIC (decl1
)
13242 && !DECL_DECLARED_INLINE_P (decl1
))
13246 /* Check whether DECL1 is in an anonymous
13248 for (context
= DECL_CONTEXT (decl1
);
13250 context
= DECL_CONTEXT (context
))
13252 if (TREE_CODE (context
) == NAMESPACE_DECL
13253 && DECL_NAME (context
) == NULL_TREE
)
13257 if (context
== NULL
)
13258 warning (OPT_Wmissing_declarations
,
13259 "no previous declaration for %q+D", decl1
);
13267 /* We need to set the DECL_CONTEXT. */
13268 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13269 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13271 fntype
= TREE_TYPE (decl1
);
13272 restype
= TREE_TYPE (fntype
);
13274 /* If #pragma weak applies, mark the decl appropriately now.
13275 The pragma only applies to global functions. Because
13276 determining whether or not the #pragma applies involves
13277 computing the mangled name for the declaration, we cannot
13278 apply the pragma until after we have merged this declaration
13279 with any previous declarations; if the original declaration
13280 has a linkage specification, that specification applies to
13281 the definition as well, and may affect the mangled name. */
13282 if (DECL_FILE_SCOPE_P (decl1
))
13283 maybe_apply_pragma_weak (decl1
);
13286 /* Reset this in case the call to pushdecl changed it. */
13287 current_function_decl
= decl1
;
13289 gcc_assert (DECL_INITIAL (decl1
));
13291 /* This function may already have been parsed, in which case just
13292 return; our caller will skip over the body without parsing. */
13293 if (DECL_INITIAL (decl1
) != error_mark_node
)
13296 /* Initialize RTL machinery. We cannot do this until
13297 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13298 even when processing a template; this is how we get
13299 CFUN set up, and our per-function variables initialized.
13300 FIXME factor out the non-RTL stuff. */
13301 bl
= current_binding_level
;
13302 allocate_struct_function (decl1
, processing_template_decl
);
13304 /* Initialize the language data structures. Whenever we start
13305 a new function, we destroy temporaries in the usual way. */
13306 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
13307 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13308 current_binding_level
= bl
;
13310 if (!processing_template_decl
&& type_uses_auto (restype
))
13312 FNDECL_USED_AUTO (decl1
) = true;
13313 current_function_auto_return_pattern
= restype
;
13316 /* Start the statement-tree, start the tree now. */
13317 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13319 /* If we are (erroneously) defining a function that we have already
13320 defined before, wipe out what we knew before. */
13321 if (!DECL_PENDING_INLINE_P (decl1
))
13322 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13324 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13326 /* We know that this was set up by `grokclassfn'. We do not
13327 wait until `store_parm_decls', since evil parse errors may
13328 never get us to that point. Here we keep the consistency
13329 between `current_class_type' and `current_class_ptr'. */
13330 tree t
= DECL_ARGUMENTS (decl1
);
13332 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13333 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13335 cp_function_chain
->x_current_class_ref
13336 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13337 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13338 cp_function_chain
->x_current_class_ptr
= t
;
13340 /* Constructors and destructors need to know whether they're "in
13341 charge" of initializing virtual base classes. */
13342 t
= DECL_CHAIN (t
);
13343 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13345 current_in_charge_parm
= t
;
13346 t
= DECL_CHAIN (t
);
13348 if (DECL_HAS_VTT_PARM_P (decl1
))
13350 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13351 current_vtt_parm
= t
;
13355 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13356 /* Implicitly-defined methods (like the
13357 destructor for a class in which no destructor
13358 is explicitly declared) must not be defined
13359 until their definition is needed. So, we
13360 ignore interface specifications for
13361 compiler-generated functions. */
13362 && !DECL_ARTIFICIAL (decl1
));
13364 if (processing_template_decl
)
13365 /* Don't mess with interface flags. */;
13366 else if (DECL_INTERFACE_KNOWN (decl1
))
13368 tree ctx
= decl_function_context (decl1
);
13370 if (DECL_NOT_REALLY_EXTERN (decl1
))
13371 DECL_EXTERNAL (decl1
) = 0;
13373 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13374 /* This is a function in a local class in an extern inline
13375 or template function. */
13376 comdat_linkage (decl1
);
13378 /* If this function belongs to an interface, it is public.
13379 If it belongs to someone else's interface, it is also external.
13380 This only affects inlines and template instantiations. */
13381 else if (!finfo
->interface_unknown
&& honor_interface
)
13383 if (DECL_DECLARED_INLINE_P (decl1
)
13384 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13386 DECL_EXTERNAL (decl1
)
13387 = (finfo
->interface_only
13388 || (DECL_DECLARED_INLINE_P (decl1
)
13389 && ! flag_implement_inlines
13390 && !DECL_VINDEX (decl1
)));
13392 /* For WIN32 we also want to put these in linkonce sections. */
13393 maybe_make_one_only (decl1
);
13396 DECL_EXTERNAL (decl1
) = 0;
13397 DECL_INTERFACE_KNOWN (decl1
) = 1;
13398 /* If this function is in an interface implemented in this file,
13399 make sure that the back end knows to emit this function
13401 if (!DECL_EXTERNAL (decl1
))
13402 mark_needed (decl1
);
13404 else if (finfo
->interface_unknown
&& finfo
->interface_only
13405 && honor_interface
)
13407 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13408 interface, we will have both finfo->interface_unknown and
13409 finfo->interface_only set. In that case, we don't want to
13410 use the normal heuristics because someone will supply a
13411 #pragma implementation elsewhere, and deducing it here would
13412 produce a conflict. */
13413 comdat_linkage (decl1
);
13414 DECL_EXTERNAL (decl1
) = 0;
13415 DECL_INTERFACE_KNOWN (decl1
) = 1;
13416 DECL_DEFER_OUTPUT (decl1
) = 1;
13420 /* This is a definition, not a reference.
13421 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13422 if (!GNU_INLINE_P (decl1
))
13423 DECL_EXTERNAL (decl1
) = 0;
13425 if ((DECL_DECLARED_INLINE_P (decl1
)
13426 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13427 && ! DECL_INTERFACE_KNOWN (decl1
))
13428 DECL_DEFER_OUTPUT (decl1
) = 1;
13430 DECL_INTERFACE_KNOWN (decl1
) = 1;
13433 /* Determine the ELF visibility attribute for the function. We must not
13434 do this before calling "pushdecl", as we must allow "duplicate_decls"
13435 to merge any attributes appropriately. We also need to wait until
13437 if (!DECL_CLONED_FUNCTION_P (decl1
))
13438 determine_visibility (decl1
);
13440 if (!processing_template_decl
)
13441 maybe_instantiate_noexcept (decl1
);
13443 begin_scope (sk_function_parms
, decl1
);
13447 if (DECL_DESTRUCTOR_P (decl1
)
13448 || (DECL_CONSTRUCTOR_P (decl1
)
13449 && targetm
.cxx
.cdtor_returns_this ()))
13451 cdtor_label
= build_decl (input_location
,
13452 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13453 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13456 start_fname_decls ();
13458 store_parm_decls (current_function_parms
);
13464 /* Like start_preparsed_function, except that instead of a
13465 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13467 Returns true on success. If the DECLARATOR is not suitable
13468 for a function, we return false, which tells the parser to
13469 skip the entire function. */
13472 start_function (cp_decl_specifier_seq
*declspecs
,
13473 const cp_declarator
*declarator
,
13478 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13479 if (decl1
== error_mark_node
)
13481 /* If the declarator is not suitable for a function definition,
13482 cause a syntax error. */
13483 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13485 error ("invalid function declaration");
13489 if (DECL_MAIN_P (decl1
))
13490 /* main must return int. grokfndecl should have corrected it
13491 (and issued a diagnostic) if the user got it wrong. */
13492 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13493 integer_type_node
));
13495 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13498 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13502 use_eh_spec_block (tree fn
)
13504 return (flag_exceptions
&& flag_enforce_eh_specs
13505 && !processing_template_decl
13506 && !type_throw_all_p (TREE_TYPE (fn
))
13507 /* We insert the EH_SPEC_BLOCK only in the original
13508 function; then, it is copied automatically to the
13510 && !DECL_CLONED_FUNCTION_P (fn
)
13511 /* Implicitly-generated constructors and destructors have
13512 exception specifications. However, those specifications
13513 are the union of the possible exceptions specified by the
13514 constructors/destructors for bases and members, so no
13515 unallowed exception will ever reach this function. By
13516 not creating the EH_SPEC_BLOCK we save a little memory,
13517 and we avoid spurious warnings about unreachable
13519 && !DECL_DEFAULTED_FN (fn
));
13522 /* Store the parameter declarations into the current function declaration.
13523 This is called after parsing the parameter declarations, before
13524 digesting the body of the function.
13526 Also install to binding contour return value identifier, if any. */
13529 store_parm_decls (tree current_function_parms
)
13531 tree fndecl
= current_function_decl
;
13534 /* This is a chain of any other decls that came in among the parm
13535 declarations. If a parm is declared with enum {foo, bar} x;
13536 then CONST_DECLs for foo and bar are put here. */
13537 tree nonparms
= NULL_TREE
;
13539 if (current_function_parms
)
13541 /* This case is when the function was defined with an ANSI prototype.
13542 The parms already have decls, so we need not do anything here
13543 except record them as in effect
13544 and complain if any redundant old-style parm decls were written. */
13546 tree specparms
= current_function_parms
;
13549 /* Must clear this because it might contain TYPE_DECLs declared
13551 current_binding_level
->names
= NULL
;
13553 /* If we're doing semantic analysis, then we'll call pushdecl
13554 for each of these. We must do them in reverse order so that
13555 they end in the correct forward order. */
13556 specparms
= nreverse (specparms
);
13558 for (parm
= specparms
; parm
; parm
= next
)
13560 next
= DECL_CHAIN (parm
);
13561 if (TREE_CODE (parm
) == PARM_DECL
)
13563 if (DECL_NAME (parm
) == NULL_TREE
13564 || !VOID_TYPE_P (parm
))
13567 error ("parameter %qD declared void", parm
);
13571 /* If we find an enum constant or a type tag,
13572 put it aside for the moment. */
13573 TREE_CHAIN (parm
) = NULL_TREE
;
13574 nonparms
= chainon (nonparms
, parm
);
13578 /* Get the decls in their original chain order and record in the
13579 function. This is all and only the PARM_DECLs that were
13580 pushed into scope by the loop above. */
13581 DECL_ARGUMENTS (fndecl
) = getdecls ();
13584 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13586 /* Now store the final chain of decls for the arguments
13587 as the decl-chain of the current lexical scope.
13588 Put the enumerators in as well, at the front so that
13589 DECL_ARGUMENTS is not modified. */
13590 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13592 if (use_eh_spec_block (current_function_decl
))
13593 current_eh_spec_block
= begin_eh_spec_block ();
13597 /* We have finished doing semantic analysis on DECL, but have not yet
13598 generated RTL for its body. Save away our current state, so that
13599 when we want to generate RTL later we know what to do. */
13602 save_function_data (tree decl
)
13604 struct language_function
*f
;
13606 /* Save the language-specific per-function data so that we can
13607 get it back when we really expand this function. */
13608 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13611 f
= ggc_alloc
<language_function
> ();
13612 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13613 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13615 /* Clear out the bits we don't need. */
13616 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13617 f
->bindings
= NULL
;
13618 f
->x_local_names
= NULL
;
13619 f
->base
.local_typedefs
= NULL
;
13623 /* Set the return value of the constructor (if present). */
13626 finish_constructor_body (void)
13631 if (targetm
.cxx
.cdtor_returns_this ()
13632 && (! TYPE_FOR_JAVA (current_class_type
)))
13634 /* Any return from a constructor will end up here. */
13635 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13637 val
= DECL_ARGUMENTS (current_function_decl
);
13638 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13639 DECL_RESULT (current_function_decl
), val
);
13640 /* Return the address of the object. */
13641 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13642 add_stmt (exprstmt
);
13646 /* Do all the processing for the beginning of a destructor; set up the
13647 vtable pointers and cleanups for bases and members. */
13650 begin_destructor_body (void)
13652 tree compound_stmt
;
13654 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13655 issued an error message. We still want to try to process the
13656 body of the function, but initialize_vtbl_ptrs will crash if
13657 TYPE_BINFO is NULL. */
13658 if (COMPLETE_TYPE_P (current_class_type
))
13660 compound_stmt
= begin_compound_stmt (0);
13661 /* Make all virtual function table pointers in non-virtual base
13662 classes point to CURRENT_CLASS_TYPE's virtual function
13664 initialize_vtbl_ptrs (current_class_ptr
);
13665 finish_compound_stmt (compound_stmt
);
13667 /* Insert a cleanup to let the back end know that the object is dead
13668 when we exit the destructor, either normally or via exception. */
13669 tree clobber
= build_constructor (current_class_type
, NULL
);
13670 TREE_THIS_VOLATILE (clobber
) = true;
13671 tree exprstmt
= build2 (MODIFY_EXPR
, current_class_type
,
13672 current_class_ref
, clobber
);
13673 finish_decl_cleanup (NULL_TREE
, exprstmt
);
13675 /* And insert cleanups for our bases and members so that they
13676 will be properly destroyed if we throw. */
13677 push_base_cleanups ();
13681 /* At the end of every destructor we generate code to delete the object if
13682 necessary. Do that now. */
13685 finish_destructor_body (void)
13689 /* Any return from a destructor will end up here; that way all base
13690 and member cleanups will be run when the function returns. */
13691 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13693 /* In a virtual destructor, we must call delete. */
13694 if (DECL_VIRTUAL_P (current_function_decl
))
13697 tree virtual_size
= cxx_sizeof (current_class_type
);
13701 At the point of definition of a virtual destructor (including
13702 an implicit definition), non-placement operator delete shall
13703 be looked up in the scope of the destructor's class and if
13704 found shall be accessible and unambiguous. */
13705 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13707 /*global_p=*/false,
13708 /*placement=*/NULL_TREE
,
13709 /*alloc_fn=*/NULL_TREE
,
13710 tf_warning_or_error
);
13712 if_stmt
= begin_if_stmt ();
13713 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13714 current_in_charge_parm
,
13717 finish_expr_stmt (exprstmt
);
13718 finish_then_clause (if_stmt
);
13719 finish_if_stmt (if_stmt
);
13722 if (targetm
.cxx
.cdtor_returns_this ())
13726 val
= DECL_ARGUMENTS (current_function_decl
);
13727 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13728 DECL_RESULT (current_function_decl
), val
);
13729 /* Return the address of the object. */
13730 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13731 add_stmt (exprstmt
);
13735 /* Do the necessary processing for the beginning of a function body, which
13736 in this case includes member-initializers, but not the catch clauses of
13737 a function-try-block. Currently, this means opening a binding level
13738 for the member-initializers (in a ctor), member cleanups (in a dtor),
13739 and capture proxies (in a lambda operator()). */
13742 begin_function_body (void)
13746 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13749 if (processing_template_decl
)
13750 /* Do nothing now. */;
13752 /* Always keep the BLOCK node associated with the outermost pair of
13753 curly braces of a function. These are needed for correct
13754 operation of dwarfout.c. */
13755 keep_next_level (true);
13757 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13759 if (processing_template_decl
)
13760 /* Do nothing now. */;
13761 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13762 begin_destructor_body ();
13767 /* Do the processing for the end of a function body. Currently, this means
13768 closing out the cleanups for fully-constructed bases and members, and in
13769 the case of the destructor, deleting the object if desired. Again, this
13770 is only meaningful for [cd]tors, since they are the only functions where
13771 there is a significant distinction between the main body and any
13772 function catch clauses. Handling, say, main() return semantics here
13773 would be wrong, as flowing off the end of a function catch clause for
13774 main() would also need to return 0. */
13777 finish_function_body (tree compstmt
)
13779 if (compstmt
== NULL_TREE
)
13782 /* Close the block. */
13783 finish_compound_stmt (compstmt
);
13785 if (processing_template_decl
)
13786 /* Do nothing now. */;
13787 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
13788 finish_constructor_body ();
13789 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13790 finish_destructor_body ();
13793 /* Given a function, returns the BLOCK corresponding to the outermost level
13794 of curly braces, skipping the artificial block created for constructor
13798 outer_curly_brace_block (tree fndecl
)
13800 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
13801 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13802 /* Skip the artificial function body block. */
13803 block
= BLOCK_SUBBLOCKS (block
);
13807 /* If FNDECL is a class's key method, add the class to the list of
13808 keyed classes that should be emitted. */
13811 record_key_method_defined (tree fndecl
)
13813 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
13814 && DECL_VIRTUAL_P (fndecl
)
13815 && !processing_template_decl
)
13817 tree fnclass
= DECL_CONTEXT (fndecl
);
13818 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
13819 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
13823 /* Subroutine of finish_function.
13824 Save the body of constexpr functions for possible
13825 future compile time evaluation. */
13828 maybe_save_function_definition (tree fun
)
13830 if (!processing_template_decl
13831 && DECL_DECLARED_CONSTEXPR_P (fun
)
13832 && !DECL_CLONED_FUNCTION_P (fun
))
13833 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
13836 /* Finish up a function declaration and compile that function
13837 all the way to assembler language output. The free the storage
13838 for the function definition.
13840 FLAGS is a bitwise or of the following values:
13842 We just finished processing the body of an in-class inline
13843 function definition. (This processing will have taken place
13844 after the class definition is complete.) */
13847 finish_function (int flags
)
13849 tree fndecl
= current_function_decl
;
13850 tree fntype
, ctype
= NULL_TREE
;
13851 int inclass_inline
= (flags
& 2) != 0;
13853 /* When we get some parse errors, we can end up without a
13854 current_function_decl, so cope. */
13855 if (fndecl
== NULL_TREE
)
13856 return error_mark_node
;
13858 if (c_dialect_objc ())
13859 objc_finish_function ();
13861 gcc_assert (!defer_mark_used_calls
);
13862 defer_mark_used_calls
= true;
13864 record_key_method_defined (fndecl
);
13866 fntype
= TREE_TYPE (fndecl
);
13868 /* TREE_READONLY (fndecl) = 1;
13869 This caused &foo to be of type ptr-to-const-function
13870 which then got a warning when stored in a ptr-to-function variable. */
13872 gcc_assert (building_stmt_list_p ());
13873 /* The current function is being defined, so its DECL_INITIAL should
13874 be set, and unless there's a multiple definition, it should be
13875 error_mark_node. */
13876 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
13878 /* For a cloned function, we've already got all the code we need;
13879 there's no need to add any extra bits. */
13880 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13882 /* Make it so that `main' always returns 0 by default. */
13883 if (DECL_MAIN_P (current_function_decl
))
13884 finish_return_stmt (integer_zero_node
);
13886 if (use_eh_spec_block (current_function_decl
))
13887 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13888 (TREE_TYPE (current_function_decl
)),
13889 current_eh_spec_block
);
13892 /* If we're saving up tree structure, tie off the function now. */
13893 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
13895 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
13896 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
13898 finish_fname_decls ();
13900 /* If this function can't throw any exceptions, remember that. */
13901 if (!processing_template_decl
13902 && !cp_function_chain
->can_throw
13903 && !flag_non_call_exceptions
13904 && !decl_replaceable_p (fndecl
))
13905 TREE_NOTHROW (fndecl
) = 1;
13907 /* This must come after expand_function_end because cleanups might
13908 have declarations (from inline functions) that need to go into
13909 this function's blocks. */
13911 /* If the current binding level isn't the outermost binding level
13912 for this function, either there is a bug, or we have experienced
13913 syntax errors and the statement tree is malformed. */
13914 if (current_binding_level
->kind
!= sk_function_parms
)
13916 /* Make sure we have already experienced errors. */
13917 gcc_assert (errorcount
);
13919 /* Throw away the broken statement tree and extra binding
13921 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
13923 while (current_binding_level
->kind
!= sk_function_parms
)
13925 if (current_binding_level
->kind
== sk_class
)
13926 pop_nested_class ();
13928 poplevel (0, 0, 0);
13931 poplevel (1, 0, 1);
13933 /* Statements should always be full-expressions at the outermost set
13934 of curly braces for a function. */
13935 gcc_assert (stmts_are_full_exprs_p ());
13937 /* If there are no return statements in a function with auto return type,
13938 the return type is void. But if the declared type is something like
13939 auto*, this is an error. */
13940 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
13941 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
13943 if (!is_auto (current_function_auto_return_pattern
)
13944 && !current_function_returns_value
&& !current_function_returns_null
)
13946 error ("no return statements in function returning %qT",
13947 current_function_auto_return_pattern
);
13948 inform (input_location
, "only plain %<auto%> return type can be "
13949 "deduced to %<void%>");
13951 apply_deduced_return_type (fndecl
, void_type_node
);
13952 fntype
= TREE_TYPE (fndecl
);
13955 /* Save constexpr function body before it gets munged by
13956 the NRV transformation. */
13957 maybe_save_function_definition (fndecl
);
13959 /* Set up the named return value optimization, if we can. Candidate
13960 variables are selected in check_return_expr. */
13961 if (current_function_return_value
)
13963 tree r
= current_function_return_value
;
13966 if (r
!= error_mark_node
13967 /* This is only worth doing for fns that return in memory--and
13968 simpler, since we don't have to worry about promoted modes. */
13969 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
13970 /* Only allow this for variables declared in the outer scope of
13971 the function so we know that their lifetime always ends with a
13972 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13973 we were to do this optimization in tree-ssa. */
13974 && (outer
= outer_curly_brace_block (fndecl
))
13975 && chain_member (r
, BLOCK_VARS (outer
)))
13976 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
13978 current_function_return_value
= NULL_TREE
;
13981 /* Remember that we were in class scope. */
13982 if (current_class_name
)
13983 ctype
= current_class_type
;
13985 /* Must mark the RESULT_DECL as being in this function. */
13986 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13988 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13989 to the FUNCTION_DECL node itself. */
13990 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13992 /* Save away current state, if appropriate. */
13993 if (!processing_template_decl
)
13994 save_function_data (fndecl
);
13996 /* Complain if there's just no return statement. */
13997 if (warn_return_type
13998 && !VOID_TYPE_P (TREE_TYPE (fntype
))
13999 && !dependent_type_p (TREE_TYPE (fntype
))
14000 && !current_function_returns_value
&& !current_function_returns_null
14001 /* Don't complain if we abort or throw. */
14002 && !current_function_returns_abnormally
14003 /* Don't complain if there's an infinite loop. */
14004 && !current_function_infinite_loop
14005 /* Don't complain if we are declared noreturn. */
14006 && !TREE_THIS_VOLATILE (fndecl
)
14007 && !DECL_NAME (DECL_RESULT (fndecl
))
14008 && !TREE_NO_WARNING (fndecl
)
14009 /* Structor return values (if any) are set by the compiler. */
14010 && !DECL_CONSTRUCTOR_P (fndecl
)
14011 && !DECL_DESTRUCTOR_P (fndecl
)
14012 && targetm
.warn_func_return (fndecl
))
14014 warning (OPT_Wreturn_type
,
14015 "no return statement in function returning non-void");
14016 TREE_NO_WARNING (fndecl
) = 1;
14019 /* Store the end of the function, so that we get good line number
14020 info for the epilogue. */
14021 cfun
->function_end_locus
= input_location
;
14023 /* Complain about parameters that are only set, but never otherwise used. */
14024 if (warn_unused_but_set_parameter
14025 && !processing_template_decl
14026 && errorcount
== unused_but_set_errorcount
14027 && !DECL_CLONED_FUNCTION_P (fndecl
))
14031 for (decl
= DECL_ARGUMENTS (fndecl
);
14033 decl
= DECL_CHAIN (decl
))
14034 if (TREE_USED (decl
)
14035 && TREE_CODE (decl
) == PARM_DECL
14036 && !DECL_READ_P (decl
)
14037 && DECL_NAME (decl
)
14038 && !DECL_ARTIFICIAL (decl
)
14039 && !TREE_NO_WARNING (decl
)
14040 && !DECL_IN_SYSTEM_HEADER (decl
)
14041 && TREE_TYPE (decl
) != error_mark_node
14042 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14043 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14044 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14045 warning (OPT_Wunused_but_set_parameter
,
14046 "parameter %q+D set but not used", decl
);
14047 unused_but_set_errorcount
= errorcount
;
14050 /* Complain about locally defined typedefs that are not used in this
14052 maybe_warn_unused_local_typedefs ();
14054 /* Genericize before inlining. */
14055 if (!processing_template_decl
)
14057 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14058 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14059 cp_genericize (fndecl
);
14060 /* Clear out the bits we don't need. */
14061 f
->x_current_class_ptr
= NULL
;
14062 f
->x_current_class_ref
= NULL
;
14063 f
->x_eh_spec_block
= NULL
;
14064 f
->x_in_charge_parm
= NULL
;
14065 f
->x_vtt_parm
= NULL
;
14066 f
->x_return_value
= NULL
;
14067 f
->bindings
= NULL
;
14068 f
->extern_decl_map
= NULL
;
14069 f
->infinite_loops
= NULL
;
14071 /* Clear out the bits we don't need. */
14072 local_names
= NULL
;
14074 /* We're leaving the context of this function, so zap cfun. It's still in
14075 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14077 current_function_decl
= NULL
;
14079 /* If this is an in-class inline definition, we may have to pop the
14080 bindings for the template parameters that we added in
14081 maybe_begin_member_template_processing when start_function was
14083 if (inclass_inline
)
14084 maybe_end_member_template_processing ();
14086 /* Leave the scope of the class. */
14088 pop_nested_class ();
14093 current_function_decl
= NULL_TREE
;
14095 defer_mark_used_calls
= false;
14096 if (deferred_mark_used_calls
)
14101 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14103 vec_free (deferred_mark_used_calls
);
14109 /* Create the FUNCTION_DECL for a function definition.
14110 DECLSPECS and DECLARATOR are the parts of the declaration;
14111 they describe the return type and the name of the function,
14112 but twisted together in a fashion that parallels the syntax of C.
14114 This function creates a binding context for the function body
14115 as well as setting up the FUNCTION_DECL in current_function_decl.
14117 Returns a FUNCTION_DECL on success.
14119 If the DECLARATOR is not suitable for a function (it defines a datum
14120 instead), we return 0, which tells yyparse to report a parse error.
14122 May return void_type_node indicating that this method is actually
14123 a friend. See grokfield for more details.
14125 Came here with a `.pushlevel' .
14127 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14128 CHANGES TO CODE IN `grokfield'. */
14131 grokmethod (cp_decl_specifier_seq
*declspecs
,
14132 const cp_declarator
*declarator
, tree attrlist
)
14134 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14137 if (fndecl
== error_mark_node
)
14138 return error_mark_node
;
14140 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14142 error ("invalid member function declaration");
14143 return error_mark_node
;
14147 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14149 /* Pass friends other than inline friend functions back. */
14150 if (fndecl
== void_type_node
)
14153 if (DECL_IN_AGGR_P (fndecl
))
14155 if (DECL_CLASS_SCOPE_P (fndecl
))
14156 error ("%qD is already defined in class %qT", fndecl
,
14157 DECL_CONTEXT (fndecl
));
14158 return error_mark_node
;
14161 check_template_shadow (fndecl
);
14163 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14164 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14166 /* We process method specializations in finish_struct_1. */
14167 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14169 fndecl
= push_template_decl (fndecl
);
14170 if (fndecl
== error_mark_node
)
14174 if (! DECL_FRIEND_P (fndecl
))
14176 if (DECL_CHAIN (fndecl
))
14178 fndecl
= copy_node (fndecl
);
14179 TREE_CHAIN (fndecl
) = NULL_TREE
;
14183 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14185 DECL_IN_AGGR_P (fndecl
) = 1;
14190 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14191 we can lay it out later, when and if its type becomes complete.
14193 Also handle constexpr pointer to member variables where the initializer
14194 is an unlowered PTRMEM_CST because the class isn't complete yet. */
14197 maybe_register_incomplete_var (tree var
)
14199 gcc_assert (VAR_P (var
));
14201 /* Keep track of variables with incomplete types. */
14202 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14203 && DECL_EXTERNAL (var
))
14205 tree inner_type
= TREE_TYPE (var
);
14207 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14208 inner_type
= TREE_TYPE (inner_type
);
14209 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14211 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14212 /* RTTI TD entries are created while defining the type_info. */
14213 || (TYPE_LANG_SPECIFIC (inner_type
)
14214 && TYPE_BEING_DEFINED (inner_type
)))
14216 incomplete_var iv
= {var
, inner_type
};
14217 vec_safe_push (incomplete_vars
, iv
);
14219 else if (TYPE_PTRMEM_P (inner_type
)
14220 && DECL_INITIAL (var
)
14221 && TREE_CODE (DECL_INITIAL (var
)) == PTRMEM_CST
)
14223 tree context
= TYPE_PTRMEM_CLASS_TYPE (inner_type
);
14224 gcc_assert (TYPE_BEING_DEFINED (context
));
14225 incomplete_var iv
= {var
, context
};
14226 vec_safe_push (incomplete_vars
, iv
);
14231 /* Called when a class type (given by TYPE) is defined. If there are
14232 any existing VAR_DECLs whose type has been completed by this
14233 declaration, update them now. */
14236 complete_vars (tree type
)
14239 incomplete_var
*iv
;
14241 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14243 if (same_type_p (type
, iv
->incomplete_type
))
14245 tree var
= iv
->decl
;
14246 tree type
= TREE_TYPE (var
);
14248 if (TYPE_PTRMEM_P (type
))
14249 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14252 /* Complete the type of the variable. The VAR_DECL itself
14253 will be laid out in expand_expr. */
14254 complete_type (type
);
14255 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14258 /* Remove this entry from the list. */
14259 incomplete_vars
->unordered_remove (ix
);
14265 /* Check for pending declarations which may have abstract type. */
14266 complete_type_check_abstract (type
);
14269 /* If DECL is of a type which needs a cleanup, build and return an
14270 expression to perform that cleanup here. Return NULL_TREE if no
14271 cleanup need be done. */
14274 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14280 /* Assume no cleanup is required. */
14281 cleanup
= NULL_TREE
;
14283 if (error_operand_p (decl
))
14286 /* Handle "__attribute__((cleanup))". We run the cleanup function
14287 before the destructor since the destructor is what actually
14288 terminates the lifetime of the object. */
14289 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14296 /* Get the name specified by the user for the cleanup function. */
14297 id
= TREE_VALUE (TREE_VALUE (attr
));
14298 /* Look up the name to find the cleanup function to call. It is
14299 important to use lookup_name here because that is what is
14300 used in c-common.c:handle_cleanup_attribute when performing
14301 initial checks on the attribute. Note that those checks
14302 include ensuring that the function found is not an overloaded
14303 function, or an object with an overloaded call operator,
14304 etc.; we can rely on the fact that the function found is an
14305 ordinary FUNCTION_DECL. */
14306 fn
= lookup_name (id
);
14307 arg
= build_address (decl
);
14309 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14310 if (cleanup
== error_mark_node
)
14311 return error_mark_node
;
14313 /* Handle ordinary C++ destructors. */
14314 type
= TREE_TYPE (decl
);
14315 if (type_build_dtor_call (type
))
14317 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14321 if (TREE_CODE (type
) == ARRAY_TYPE
)
14324 addr
= build_address (decl
);
14326 call
= build_delete (TREE_TYPE (addr
), addr
,
14327 sfk_complete_destructor
, flags
, 0, complain
);
14328 if (call
== error_mark_node
)
14329 cleanup
= error_mark_node
;
14330 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14331 /* Discard the call. */;
14333 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14338 /* build_delete sets the location of the destructor call to the
14339 current location, even though the destructor is going to be
14340 called later, at the end of the current scope. This can lead to
14341 a "jumpy" behaviour for users of debuggers when they step around
14342 the end of the block. So let's unset the location of the
14343 destructor call instead. */
14344 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14345 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14348 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
))))
14349 /* Treat objects with destructors as used; the destructor may do
14350 something substantive. */
14357 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14358 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14359 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14362 static_fn_type (tree memfntype
)
14367 if (TYPE_PTRMEMFUNC_P (memfntype
))
14368 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14369 if (POINTER_TYPE_P (memfntype
)
14370 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14371 memfntype
= TREE_TYPE (memfntype
);
14372 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14374 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14375 args
= TYPE_ARG_TYPES (memfntype
);
14376 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14377 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14378 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14379 fntype
= (cp_build_type_attribute_variant
14380 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14381 fntype
= (build_exception_variant
14382 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14386 /* DECL was originally constructed as a non-static member function,
14387 but turned out to be static. Update it accordingly. */
14390 revert_static_member_fn (tree decl
)
14392 tree stype
= static_fn_type (decl
);
14393 cp_cv_quals quals
= type_memfn_quals (stype
);
14394 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14396 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14397 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14399 TREE_TYPE (decl
) = stype
;
14401 if (DECL_ARGUMENTS (decl
))
14402 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14403 DECL_STATIC_FUNCTION_P (decl
) = 1;
14406 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14407 one of the language-independent trees. */
14409 enum cp_tree_node_structure_enum
14410 cp_tree_node_structure (union lang_tree_node
* t
)
14412 switch (TREE_CODE (&t
->generic
))
14414 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14415 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14416 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14417 case OVERLOAD
: return TS_CP_OVERLOAD
;
14418 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14419 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14420 case BASELINK
: return TS_CP_BASELINK
;
14421 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14422 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14423 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14424 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14425 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14426 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14427 default: return TS_CP_GENERIC
;
14431 /* Build the void_list_node (void_type_node having been created). */
14433 build_void_list_node (void)
14435 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14440 cp_missing_noreturn_ok_p (tree decl
)
14442 /* A missing noreturn is ok for the `main' function. */
14443 return DECL_MAIN_P (decl
);
14446 /* Return the COMDAT group into which DECL should be placed. */
14449 cxx_comdat_group (tree decl
)
14453 /* Virtual tables, construction virtual tables, and virtual table
14454 tables all go in a single COMDAT group, named after the primary
14456 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14457 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
14458 /* For all other DECLs, the COMDAT group is the mangled name of the
14459 declaration itself. */
14462 while (DECL_THUNK_P (decl
))
14464 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14465 into the same section as the target function. In that case
14466 we must return target's name. */
14467 tree target
= THUNK_TARGET (decl
);
14468 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14469 && DECL_SECTION_NAME (target
) != NULL
14470 && DECL_ONE_ONLY (target
))
14475 name
= DECL_ASSEMBLER_NAME (decl
);
14481 /* Returns the return type for FN as written by the user, which may include
14482 a placeholder for a deduced return type. */
14485 fndecl_declared_return_type (tree fn
)
14487 fn
= STRIP_TEMPLATE (fn
);
14488 if (FNDECL_USED_AUTO (fn
))
14490 struct language_function
*f
= NULL
;
14491 if (DECL_STRUCT_FUNCTION (fn
))
14492 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
14494 f
= DECL_SAVED_FUNCTION_DATA (fn
);
14495 return f
->x_auto_return_pattern
;
14497 return TREE_TYPE (TREE_TYPE (fn
));
14500 /* Returns true iff DECL was declared with an auto return type and it has
14501 not yet been deduced to a real type. */
14504 undeduced_auto_decl (tree decl
)
14506 if (cxx_dialect
< cxx1y
)
14508 return type_uses_auto (TREE_TYPE (decl
));
14511 /* Complain if DECL has an undeduced return type. */
14514 require_deduced_type (tree decl
)
14516 if (undeduced_auto_decl (decl
))
14517 error ("use of %qD before deduction of %<auto%>", decl
);
14520 #include "gt-cp-decl.h"