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 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2310 "%qD: visibility attribute ignored because it "
2311 "conflicts with previous declaration", newdecl
))
2312 inform (DECL_SOURCE_LOCATION (olddecl
),
2313 "previous declaration of %qD", olddecl
);
2315 /* Choose the declaration which specified visibility. */
2316 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2318 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2319 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2321 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2322 so keep this behavior. */
2323 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2325 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2326 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2328 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2329 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2331 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2332 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2334 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2335 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2336 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2338 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2339 with that from NEWDECL below. */
2340 if (DECL_LANG_SPECIFIC (olddecl
))
2342 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2343 != DECL_LANG_SPECIFIC (newdecl
));
2344 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2347 /* Merge the USED information. */
2348 if (TREE_USED (olddecl
))
2349 TREE_USED (newdecl
) = 1;
2350 else if (TREE_USED (newdecl
))
2351 TREE_USED (olddecl
) = 1;
2352 if (VAR_P (newdecl
))
2354 if (DECL_READ_P (olddecl
))
2355 DECL_READ_P (newdecl
) = 1;
2356 else if (DECL_READ_P (newdecl
))
2357 DECL_READ_P (olddecl
) = 1;
2359 if (DECL_PRESERVE_P (olddecl
))
2360 DECL_PRESERVE_P (newdecl
) = 1;
2361 else if (DECL_PRESERVE_P (newdecl
))
2362 DECL_PRESERVE_P (olddecl
) = 1;
2364 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2365 to olddecl and deleted. */
2366 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2367 && DECL_FUNCTION_VERSIONED (olddecl
))
2369 /* Set the flag for newdecl so that it gets copied to olddecl. */
2370 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2371 /* newdecl will be purged after copying to olddecl and is no longer
2373 delete_function_version (newdecl
);
2376 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2380 function_size
= sizeof (struct tree_decl_common
);
2382 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2383 (char *) newdecl
+ sizeof (struct tree_common
),
2384 function_size
- sizeof (struct tree_common
));
2386 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2387 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2388 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2389 if (new_template_info
)
2390 /* If newdecl is a template instantiation, it is possible that
2391 the following sequence of events has occurred:
2393 o A friend function was declared in a class template. The
2394 class template was instantiated.
2396 o The instantiation of the friend declaration was
2397 recorded on the instantiation list, and is newdecl.
2399 o Later, however, instantiate_class_template called pushdecl
2400 on the newdecl to perform name injection. But, pushdecl in
2401 turn called duplicate_decls when it discovered that another
2402 declaration of a global function with the same name already
2405 o Here, in duplicate_decls, we decided to clobber newdecl.
2407 If we're going to do that, we'd better make sure that
2408 olddecl, and not newdecl, is on the list of
2409 instantiations so that if we try to do the instantiation
2410 again we won't get the clobbered declaration. */
2411 reregister_specialization (newdecl
,
2417 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2418 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2419 (char *) newdecl
+ sizeof (struct tree_common
),
2420 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2421 switch (TREE_CODE (olddecl
))
2431 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2432 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2433 size
- sizeof (struct tree_decl_common
)
2434 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2438 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2439 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2440 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2441 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2445 DECL_UID (olddecl
) = olddecl_uid
;
2447 DECL_FRIEND_P (olddecl
) = 1;
2450 DECL_ANTICIPATED (olddecl
) = 1;
2451 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2454 /* NEWDECL contains the merged attribute lists.
2455 Update OLDDECL to be the same. */
2456 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2458 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2459 so that encode_section_info has a chance to look at the new decl
2460 flags and attributes. */
2461 if (DECL_RTL_SET_P (olddecl
)
2462 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2464 && TREE_STATIC (olddecl
))))
2465 make_decl_rtl (olddecl
);
2467 /* The NEWDECL will no longer be needed. Because every out-of-class
2468 declaration of a member results in a call to duplicate_decls,
2469 freeing these nodes represents in a significant savings. */
2475 /* Return zero if the declaration NEWDECL is valid
2476 when the declaration OLDDECL (assumed to be for the same name)
2477 has already been seen.
2478 Otherwise return an error message format string with a %s
2479 where the identifier should go. */
2482 redeclaration_error_message (tree newdecl
, tree olddecl
)
2484 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2486 /* Because C++ can put things into name space for free,
2487 constructs like "typedef struct foo { ... } foo"
2488 would look like an erroneous redeclaration. */
2489 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2492 return G_("redefinition of %q#D");
2494 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2496 /* If this is a pure function, its olddecl will actually be
2497 the original initialization to `0' (which we force to call
2498 abort()). Don't complain about redefinition in this case. */
2499 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2500 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2503 /* If both functions come from different namespaces, this is not
2504 a redeclaration - this is a conflict with a used function. */
2505 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2506 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2507 && ! decls_match (olddecl
, newdecl
))
2508 return G_("%qD conflicts with used function");
2510 /* We'll complain about linkage mismatches in
2511 warn_extern_redeclared_static. */
2513 /* Defining the same name twice is no good. */
2514 if (DECL_INITIAL (olddecl
) != NULL_TREE
2515 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2517 if (DECL_NAME (olddecl
) == NULL_TREE
)
2518 return G_("%q#D not declared in class");
2519 else if (!GNU_INLINE_P (olddecl
)
2520 || GNU_INLINE_P (newdecl
))
2521 return G_("redefinition of %q#D");
2524 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2526 bool olda
= GNU_INLINE_P (olddecl
);
2527 bool newa
= GNU_INLINE_P (newdecl
);
2532 return G_("%q+D redeclared inline with "
2533 "%<gnu_inline%> attribute");
2535 return G_("%q+D redeclared inline without "
2536 "%<gnu_inline%> attribute");
2540 check_abi_tag_redeclaration
2541 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2542 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2546 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2550 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2552 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2553 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2554 return G_("redefinition of %q#D");
2558 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2559 || (DECL_TEMPLATE_RESULT (newdecl
)
2560 == DECL_TEMPLATE_RESULT (olddecl
)))
2563 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2564 if (DECL_TEMPLATE_INFO (nt
))
2565 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2566 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2567 if (DECL_TEMPLATE_INFO (ot
))
2568 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2569 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2570 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2571 return G_("redefinition of %q#D");
2573 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2575 bool olda
= GNU_INLINE_P (ot
);
2576 bool newa
= GNU_INLINE_P (nt
);
2581 return G_("%q+D redeclared inline with "
2582 "%<gnu_inline%> attribute");
2584 return G_("%q+D redeclared inline without "
2585 "%<gnu_inline%> attribute");
2589 /* Core issue #226 (C++0x):
2591 If a friend function template declaration specifies a
2592 default template-argument, that declaration shall be a
2593 definition and shall be the only declaration of the
2594 function template in the translation unit. */
2595 if ((cxx_dialect
!= cxx98
)
2596 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2597 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2598 /*is_primary=*/true,
2599 /*is_partial=*/false,
2600 /*is_friend_decl=*/2))
2601 return G_("redeclaration of friend %q#D "
2602 "may not have default template arguments");
2606 else if (VAR_P (newdecl
)
2607 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2608 && (! DECL_LANG_SPECIFIC (olddecl
)
2609 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2610 || DECL_THREAD_LOCAL_P (newdecl
)))
2612 /* Only variables can be thread-local, and all declarations must
2613 agree on this property. */
2614 if (DECL_THREAD_LOCAL_P (newdecl
))
2615 return G_("thread-local declaration of %q#D follows "
2616 "non-thread-local declaration");
2618 return G_("non-thread-local declaration of %q#D follows "
2619 "thread-local declaration");
2621 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2623 /* The objects have been declared at namespace scope. If either
2624 is a member of an anonymous union, then this is an invalid
2625 redeclaration. For example:
2631 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2632 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2633 return G_("redeclaration of %q#D");
2634 /* If at least one declaration is a reference, there is no
2635 conflict. For example:
2641 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2643 /* Reject two definitions. */
2644 return G_("redefinition of %q#D");
2648 /* Objects declared with block scope: */
2649 /* Reject two definitions, and reject a definition
2650 together with an external reference. */
2651 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2652 return G_("redeclaration of %q#D");
2657 /* Hash and equality functions for the named_label table. */
2660 named_label_entry_hash (const void *data
)
2662 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2663 return DECL_UID (ent
->label_decl
);
2667 named_label_entry_eq (const void *a
, const void *b
)
2669 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2670 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2671 return ent_a
->label_decl
== ent_b
->label_decl
;
2674 /* Create a new label, named ID. */
2677 make_label_decl (tree id
, int local_p
)
2679 struct named_label_entry
*ent
;
2683 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2685 DECL_CONTEXT (decl
) = current_function_decl
;
2686 DECL_MODE (decl
) = VOIDmode
;
2687 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2689 /* Say where one reference is to the label, for the sake of the
2690 error if it is not defined. */
2691 DECL_SOURCE_LOCATION (decl
) = input_location
;
2693 /* Record the fact that this identifier is bound to this label. */
2694 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2696 /* Create the label htab for the function on demand. */
2698 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2699 named_label_entry_eq
, NULL
);
2701 /* Record this label on the list of labels used in this function.
2702 We do this before calling make_label_decl so that we get the
2703 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2704 ent
= ggc_cleared_alloc
<named_label_entry
> ();
2705 ent
->label_decl
= decl
;
2707 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2708 gcc_assert (*slot
== NULL
);
2714 /* Look for a label named ID in the current function. If one cannot
2715 be found, create one. (We keep track of used, but undefined,
2716 labels, and complain about them at the end of a function.) */
2719 lookup_label_1 (tree id
)
2723 /* You can't use labels at global scope. */
2724 if (current_function_decl
== NULL_TREE
)
2726 error ("label %qE referenced outside of any function", id
);
2730 /* See if we've already got this label. */
2731 decl
= IDENTIFIER_LABEL_VALUE (id
);
2732 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2735 decl
= make_label_decl (id
, /*local_p=*/0);
2739 /* Wrapper for lookup_label_1. */
2742 lookup_label (tree id
)
2745 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2746 ret
= lookup_label_1 (id
);
2747 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2751 /* Declare a local label named ID. */
2754 declare_local_label (tree id
)
2757 cp_label_binding bind
;
2759 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2760 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2761 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2763 decl
= make_label_decl (id
, /*local_p=*/1);
2765 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2770 /* Returns nonzero if it is ill-formed to jump past the declaration of
2771 DECL. Returns 2 if it's also a real problem. */
2774 decl_jump_unsafe (tree decl
)
2776 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2777 with automatic storage duration is not in scope to a point where it is
2778 in scope is ill-formed unless the variable has scalar type, class type
2779 with a trivial default constructor and a trivial destructor, a
2780 cv-qualified version of one of these types, or an array of one of the
2781 preceding types and is declared without an initializer (8.5). */
2782 tree type
= TREE_TYPE (decl
);
2784 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2785 || type
== error_mark_node
)
2788 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
2789 || variably_modified_type_p (type
, NULL_TREE
))
2792 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2798 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2801 identify_goto (tree decl
, const location_t
*locus
)
2804 permerror (input_location
, "jump to label %qD", decl
);
2806 permerror (input_location
, "jump to case label");
2808 permerror (*locus
, " from here");
2811 /* Check that a single previously seen jump to a newly defined label
2812 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2813 the jump context; NAMES are the names in scope in LEVEL at the jump
2814 context; LOCUS is the source position of the jump or 0. Returns
2815 true if all is well. */
2818 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2819 bool exited_omp
, const location_t
*locus
)
2821 cp_binding_level
*b
;
2822 bool identified
= false, saw_eh
= false, saw_omp
= false;
2826 identify_goto (decl
, locus
);
2827 error (" exits OpenMP structured block");
2828 identified
= saw_omp
= true;
2831 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2833 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2835 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2836 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2837 : TREE_CHAIN (new_decls
)))
2839 int problem
= decl_jump_unsafe (new_decls
);
2845 identify_goto (decl
, locus
);
2849 error (" crosses initialization of %q+#D", new_decls
);
2851 permerror (input_location
, " enters scope of %q+#D which has "
2852 "non-trivial destructor", new_decls
);
2857 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2861 identify_goto (decl
, locus
);
2864 if (b
->kind
== sk_try
)
2865 error (" enters try block");
2867 error (" enters catch block");
2870 if (b
->kind
== sk_omp
&& !saw_omp
)
2874 identify_goto (decl
, locus
);
2877 error (" enters OpenMP structured block");
2886 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2888 check_previous_goto_1 (decl
, use
->binding_level
,
2889 use
->names_in_scope
, use
->in_omp_scope
,
2890 &use
->o_goto_locus
);
2894 check_switch_goto (cp_binding_level
* level
)
2896 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2899 /* Check that a new jump to a label DECL is OK. Called by
2900 finish_goto_stmt. */
2903 check_goto (tree decl
)
2905 struct named_label_entry
*ent
, dummy
;
2906 bool saw_catch
= false, identified
= false;
2910 /* We can't know where a computed goto is jumping.
2911 So we assume that it's OK. */
2912 if (TREE_CODE (decl
) != LABEL_DECL
)
2915 /* We didn't record any information about this label when we created it,
2916 and there's not much point since it's trivial to analyze as a return. */
2917 if (decl
== cdtor_label
)
2920 dummy
.label_decl
= decl
;
2921 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2922 gcc_assert (ent
!= NULL
);
2924 /* If the label hasn't been defined yet, defer checking. */
2925 if (! DECL_INITIAL (decl
))
2927 struct named_label_use_entry
*new_use
;
2929 /* Don't bother creating another use if the last goto had the
2930 same data, and will therefore create the same set of errors. */
2932 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2935 new_use
= ggc_alloc
<named_label_use_entry
> ();
2936 new_use
->binding_level
= current_binding_level
;
2937 new_use
->names_in_scope
= current_binding_level
->names
;
2938 new_use
->o_goto_locus
= input_location
;
2939 new_use
->in_omp_scope
= false;
2941 new_use
->next
= ent
->uses
;
2942 ent
->uses
= new_use
;
2946 if (ent
->in_try_scope
|| ent
->in_catch_scope
2947 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
2949 permerror (input_location
, "jump to label %q+D", decl
);
2950 permerror (input_location
, " from here");
2954 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
2956 int u
= decl_jump_unsafe (bad
);
2958 if (u
> 1 && DECL_ARTIFICIAL (bad
))
2960 /* Can't skip init of __exception_info. */
2961 error_at (DECL_SOURCE_LOCATION (bad
), " enters catch block");
2965 error (" skips initialization of %q+#D", bad
);
2967 permerror (input_location
, " enters scope of %q+#D which has "
2968 "non-trivial destructor", bad
);
2971 if (ent
->in_try_scope
)
2972 error (" enters try block");
2973 else if (ent
->in_catch_scope
&& !saw_catch
)
2974 error (" enters catch block");
2976 if (ent
->in_omp_scope
)
2977 error (" enters OpenMP structured block");
2978 else if (flag_openmp
)
2980 cp_binding_level
*b
;
2981 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2983 if (b
== ent
->binding_level
)
2985 if (b
->kind
== sk_omp
)
2989 permerror (input_location
, "jump to label %q+D", decl
);
2990 permerror (input_location
, " from here");
2993 error (" exits OpenMP structured block");
3000 /* Check that a return is ok wrt OpenMP structured blocks.
3001 Called by finish_return_stmt. Returns true if all is well. */
3004 check_omp_return (void)
3006 cp_binding_level
*b
;
3007 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3008 if (b
->kind
== sk_omp
)
3010 error ("invalid exit from OpenMP structured block");
3013 else if (b
->kind
== sk_function_parms
)
3018 /* Define a label, specifying the location in the source file.
3019 Return the LABEL_DECL node for the label. */
3022 define_label_1 (location_t location
, tree name
)
3024 struct named_label_entry
*ent
, dummy
;
3025 cp_binding_level
*p
;
3028 decl
= lookup_label (name
);
3030 dummy
.label_decl
= decl
;
3031 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
3032 gcc_assert (ent
!= NULL
);
3034 /* After labels, make any new cleanups in the function go into their
3035 own new (temporary) binding contour. */
3036 for (p
= current_binding_level
;
3037 p
->kind
!= sk_function_parms
;
3039 p
->more_cleanups_ok
= 0;
3041 if (name
== get_identifier ("wchar_t"))
3042 permerror (input_location
, "label named wchar_t");
3044 if (DECL_INITIAL (decl
) != NULL_TREE
)
3046 error ("duplicate label %qD", decl
);
3047 return error_mark_node
;
3051 struct named_label_use_entry
*use
;
3053 /* Mark label as having been defined. */
3054 DECL_INITIAL (decl
) = error_mark_node
;
3055 /* Say where in the source. */
3056 DECL_SOURCE_LOCATION (decl
) = location
;
3058 ent
->binding_level
= current_binding_level
;
3059 ent
->names_in_scope
= current_binding_level
->names
;
3061 for (use
= ent
->uses
; use
; use
= use
->next
)
3062 check_previous_goto (decl
, use
);
3069 /* Wrapper for define_label_1. */
3072 define_label (location_t location
, tree name
)
3075 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3076 ret
= define_label_1 (location
, name
);
3077 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3084 cp_binding_level
*level
;
3085 struct cp_switch
*next
;
3086 /* The SWITCH_STMT being built. */
3088 /* A splay-tree mapping the low element of a case range to the high
3089 element, or NULL_TREE if there is no high element. Used to
3090 determine whether or not a new case label duplicates an old case
3091 label. We need a tree, rather than simply a hash table, because
3092 of the GNU case range extension. */
3096 /* A stack of the currently active switch statements. The innermost
3097 switch statement is on the top of the stack. There is no need to
3098 mark the stack for garbage collection because it is only active
3099 during the processing of the body of a function, and we never
3100 collect at that point. */
3102 static struct cp_switch
*switch_stack
;
3104 /* Called right after a switch-statement condition is parsed.
3105 SWITCH_STMT is the switch statement being parsed. */
3108 push_switch (tree switch_stmt
)
3110 struct cp_switch
*p
= XNEW (struct cp_switch
);
3111 p
->level
= current_binding_level
;
3112 p
->next
= switch_stack
;
3113 p
->switch_stmt
= switch_stmt
;
3114 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3121 struct cp_switch
*cs
= switch_stack
;
3122 location_t switch_location
;
3124 /* Emit warnings as needed. */
3125 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3126 if (!processing_template_decl
)
3127 c_do_switch_warnings (cs
->cases
, switch_location
,
3128 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3129 SWITCH_STMT_COND (cs
->switch_stmt
));
3131 splay_tree_delete (cs
->cases
);
3132 switch_stack
= switch_stack
->next
;
3136 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3137 condition. Note that if TYPE and VALUE are already integral we don't
3138 really do the conversion because the language-independent
3139 warning/optimization code will work better that way. */
3142 case_conversion (tree type
, tree value
)
3144 if (value
== NULL_TREE
)
3147 if (cxx_dialect
>= cxx11
3148 && (SCOPED_ENUM_P (type
)
3149 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3151 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3152 type
= type_promotes_to (type
);
3153 value
= (perform_implicit_conversion_flags
3154 (type
, value
, tf_warning_or_error
,
3155 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3157 return cxx_constant_value (value
);
3160 /* Note that we've seen a definition of a case label, and complain if this
3161 is a bad place for one. */
3164 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3167 cp_binding_level
*p
;
3170 if (processing_template_decl
)
3174 /* For templates, just add the case label; we'll do semantic
3175 analysis at instantiation-time. */
3176 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3177 return add_stmt (build_case_label (low_value
, high_value
, label
));
3180 /* Find the condition on which this switch statement depends. */
3181 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3182 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3183 cond
= TREE_VALUE (cond
);
3185 if (!check_switch_goto (switch_stack
->level
))
3186 return error_mark_node
;
3188 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3190 low_value
= case_conversion (type
, low_value
);
3191 high_value
= case_conversion (type
, high_value
);
3193 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3194 low_value
, high_value
);
3196 /* After labels, make any new cleanups in the function go into their
3197 own new (temporary) binding contour. */
3198 for (p
= current_binding_level
;
3199 p
->kind
!= sk_function_parms
;
3201 p
->more_cleanups_ok
= 0;
3206 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3209 typename_hash (const void* k
)
3212 const_tree
const t
= (const_tree
) k
;
3214 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3215 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3220 typedef struct typename_info
{
3228 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3229 really of type `typename_info*' */
3232 typename_compare (const void * k1
, const void * k2
)
3234 const_tree
const t1
= (const_tree
) k1
;
3235 const typename_info
*const t2
= (const typename_info
*) k2
;
3237 return (TYPE_IDENTIFIER (t1
) == t2
->name
3238 && TYPE_CONTEXT (t1
) == t2
->scope
3239 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3240 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3241 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3244 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3245 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3247 Returns the new TYPENAME_TYPE. */
3249 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
3252 build_typename_type (tree context
, tree name
, tree fullname
,
3253 enum tag_types tag_type
)
3261 if (typename_htab
== NULL
)
3262 typename_htab
= htab_create_ggc (61, &typename_hash
,
3263 &typename_compare
, NULL
);
3265 ti
.scope
= FROB_CONTEXT (context
);
3267 ti
.template_id
= fullname
;
3268 ti
.enum_p
= tag_type
== enum_type
;
3269 ti
.class_p
= (tag_type
== class_type
3270 || tag_type
== record_type
3271 || tag_type
== union_type
);
3272 hash
= (htab_hash_pointer (ti
.scope
)
3273 ^ htab_hash_pointer (ti
.name
));
3275 /* See if we already have this type. */
3276 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
3281 /* Build the TYPENAME_TYPE. */
3282 t
= cxx_make_type (TYPENAME_TYPE
);
3283 TYPE_CONTEXT (t
) = ti
.scope
;
3284 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3285 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3286 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3288 /* Build the corresponding TYPE_DECL. */
3289 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3290 TYPE_NAME (TREE_TYPE (d
)) = d
;
3291 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3292 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3293 DECL_ARTIFICIAL (d
) = 1;
3295 /* Store it in the hash table. */
3298 /* TYPENAME_TYPEs must always be compared structurally, because
3299 they may or may not resolve down to another type depending on
3300 the currently open classes. */
3301 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3307 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3308 provided to name the type. Returns an appropriate type, unless an
3309 error occurs, in which case error_mark_node is returned. If we
3310 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3311 return that, rather than the _TYPE it corresponds to, in other
3312 cases we look through the type decl. If TF_ERROR is set, complain
3313 about errors, otherwise be quiet. */
3316 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3317 tsubst_flags_t complain
)
3323 if (name
== error_mark_node
3324 || context
== NULL_TREE
3325 || context
== error_mark_node
)
3326 return error_mark_node
;
3330 if (!(TYPE_LANG_SPECIFIC (name
)
3331 && (CLASSTYPE_IS_TEMPLATE (name
)
3332 || CLASSTYPE_USE_TEMPLATE (name
))))
3333 name
= TYPE_IDENTIFIER (name
);
3335 /* Create a TEMPLATE_ID_EXPR for the type. */
3336 name
= build_nt (TEMPLATE_ID_EXPR
,
3337 CLASSTYPE_TI_TEMPLATE (name
),
3338 CLASSTYPE_TI_ARGS (name
));
3340 else if (TREE_CODE (name
) == TYPE_DECL
)
3341 name
= DECL_NAME (name
);
3345 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3347 name
= TREE_OPERAND (name
, 0);
3348 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3349 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3350 else if (TREE_CODE (name
) == OVERLOAD
)
3352 if (complain
& tf_error
)
3353 error ("%qD is not a type", name
);
3354 return error_mark_node
;
3357 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3359 if (complain
& tf_error
)
3360 error ("%qD used without template parameters", name
);
3361 return error_mark_node
;
3363 gcc_assert (identifier_p (name
));
3364 gcc_assert (TYPE_P (context
));
3366 if (!MAYBE_CLASS_TYPE_P (context
))
3368 if (complain
& tf_error
)
3369 error ("%q#T is not a class", context
);
3370 return error_mark_node
;
3373 /* When the CONTEXT is a dependent type, NAME could refer to a
3374 dependent base class of CONTEXT. But look inside it anyway
3375 if CONTEXT is a currently open scope, in case it refers to a
3376 member of the current instantiation or a non-dependent base;
3377 lookup will stop when we hit a dependent base. */
3378 if (!dependent_scope_p (context
))
3379 /* We should only set WANT_TYPE when we're a nested typename type.
3380 Then we can give better diagnostics if we find a non-type. */
3381 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3385 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3386 return build_typename_type (context
, name
, fullname
, tag_type
);
3388 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3392 if (complain
& tf_error
)
3393 error (want_template
? G_("no class template named %q#T in %q#T")
3394 : G_("no type named %q#T in %q#T"), name
, context
);
3395 return error_mark_node
;
3398 /* Pull out the template from an injected-class-name (or multiple). */
3400 t
= maybe_get_template_decl_from_type_decl (t
);
3402 if (TREE_CODE (t
) == TREE_LIST
)
3404 if (complain
& tf_error
)
3406 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3407 print_candidates (t
);
3409 return error_mark_node
;
3412 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3414 if (complain
& tf_error
)
3415 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3417 return error_mark_node
;
3419 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3421 if (complain
& tf_error
)
3422 error ("%<typename %T::%D%> names %q#T, which is not a type",
3424 return error_mark_node
;
3427 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3428 return error_mark_node
;
3430 /* If we are currently parsing a template and if T is a typedef accessed
3431 through CONTEXT then we need to remember and check access of T at
3432 template instantiation time. */
3433 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3436 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3438 /*entering_scope=*/0,
3439 tf_warning_or_error
| tf_user
);
3441 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3444 maybe_record_typedef_use (t
);
3449 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3450 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3451 in which case error_mark_node is returned.
3453 If PARM_LIST is non-NULL, also make sure that the template parameter
3454 list of TEMPLATE_DECL matches.
3456 If COMPLAIN zero, don't complain about any errors that occur. */
3459 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3460 tsubst_flags_t complain
)
3466 name
= TYPE_IDENTIFIER (name
);
3467 else if (DECL_P (name
))
3468 name
= DECL_NAME (name
);
3469 gcc_assert (identifier_p (name
));
3471 if (!dependent_type_p (context
)
3472 || currently_open_class (context
))
3474 tree tmpl
= NULL_TREE
;
3476 if (MAYBE_CLASS_TYPE_P (context
))
3477 tmpl
= lookup_field (context
, name
, 0, false);
3479 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3480 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3482 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3484 if (complain
& tf_error
)
3485 error ("no class template named %q#T in %q#T", name
, context
);
3486 return error_mark_node
;
3490 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3492 if (complain
& tf_error
)
3494 error ("template parameters do not match template %qD", tmpl
);
3495 inform (DECL_SOURCE_LOCATION (tmpl
),
3496 "%qD declared here", tmpl
);
3498 return error_mark_node
;
3501 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3503 return error_mark_node
;
3508 /* Build the UNBOUND_CLASS_TEMPLATE. */
3509 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3510 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3511 TREE_TYPE (t
) = NULL_TREE
;
3512 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3514 /* Build the corresponding TEMPLATE_DECL. */
3515 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3516 TYPE_NAME (TREE_TYPE (d
)) = d
;
3517 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3518 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3519 DECL_ARTIFICIAL (d
) = 1;
3520 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3527 /* Push the declarations of builtin types into the namespace.
3528 RID_INDEX is the index of the builtin type in the array
3529 RID_POINTERS. NAME is the name used when looking up the builtin
3530 type. TYPE is the _TYPE node for the builtin type. */
3533 record_builtin_type (enum rid rid_index
,
3537 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3538 tree tdecl
= NULL_TREE
;
3540 if ((int) rid_index
< (int) RID_MAX
)
3541 rname
= ridpointers
[(int) rid_index
];
3543 tname
= get_identifier (name
);
3545 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3546 eliminated. Built-in types should not be looked up name; their
3547 names are keywords that the parser can recognize. However, there
3548 is code in c-common.c that uses identifier_global_value to look
3549 up built-in types by name. */
3552 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3553 DECL_ARTIFICIAL (tdecl
) = 1;
3554 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3560 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3561 DECL_ARTIFICIAL (tdecl
) = 1;
3563 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3566 if (!TYPE_NAME (type
))
3567 TYPE_NAME (type
) = tdecl
;
3570 debug_hooks
->type_decl (tdecl
, 0);
3573 /* Record one of the standard Java types.
3574 * Declare it as having the given NAME.
3575 * If SIZE > 0, it is the size of one of the integral types;
3576 * otherwise it is the negative of the size of one of the other types. */
3579 record_builtin_java_type (const char* name
, int size
)
3584 type
= build_nonstandard_integer_type (size
, 0);
3585 type
= build_distinct_type_copy (type
);
3587 else if (size
> -32)
3590 /* "__java_char" or ""__java_boolean". */
3591 type
= build_nonstandard_integer_type (-size
, 1);
3592 type
= build_distinct_type_copy (type
);
3593 /* Get the signed type cached and attached to the unsigned type,
3594 so it doesn't get garbage-collected at "random" times,
3595 causing potential codegen differences out of different UIDs
3596 and different alias set numbers. */
3597 stype
= build_nonstandard_integer_type (-size
, 0);
3598 stype
= build_distinct_type_copy (stype
);
3599 TREE_CHAIN (type
) = stype
;
3600 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3603 { /* "__java_float" or ""__java_double". */
3604 type
= make_node (REAL_TYPE
);
3605 TYPE_PRECISION (type
) = - size
;
3608 record_builtin_type (RID_MAX
, name
, type
);
3609 decl
= TYPE_NAME (type
);
3611 /* Suppress generate debug symbol entries for these types,
3612 since for normal C++ they are just clutter.
3613 However, push_lang_context undoes this if extern "Java" is seen. */
3614 DECL_IGNORED_P (decl
) = 1;
3616 TYPE_FOR_JAVA (type
) = 1;
3620 /* Push a type into the namespace so that the back ends ignore it. */
3623 record_unknown_type (tree type
, const char* name
)
3625 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3626 TYPE_DECL
, get_identifier (name
), type
));
3627 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3628 DECL_IGNORED_P (decl
) = 1;
3629 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3630 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3631 TYPE_ALIGN (type
) = 1;
3632 TYPE_USER_ALIGN (type
) = 0;
3633 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3636 /* A string for which we should create an IDENTIFIER_NODE at
3639 typedef struct predefined_identifier
3641 /* The name of the identifier. */
3642 const char *const name
;
3643 /* The place where the IDENTIFIER_NODE should be stored. */
3645 /* Nonzero if this is the name of a constructor or destructor. */
3646 const int ctor_or_dtor_p
;
3647 } predefined_identifier
;
3649 /* Create all the predefined identifiers. */
3652 initialize_predefined_identifiers (void)
3654 const predefined_identifier
*pid
;
3656 /* A table of identifiers to create at startup. */
3657 static const predefined_identifier predefined_identifiers
[] = {
3658 { "C++", &lang_name_cplusplus
, 0 },
3659 { "C", &lang_name_c
, 0 },
3660 { "Java", &lang_name_java
, 0 },
3661 /* Some of these names have a trailing space so that it is
3662 impossible for them to conflict with names written by users. */
3663 { "__ct ", &ctor_identifier
, 1 },
3664 { "__base_ctor ", &base_ctor_identifier
, 1 },
3665 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3666 { "__dt ", &dtor_identifier
, 1 },
3667 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3668 { "__base_dtor ", &base_dtor_identifier
, 1 },
3669 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3670 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3671 { "nelts", &nelts_identifier
, 0 },
3672 { THIS_NAME
, &this_identifier
, 0 },
3673 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3674 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3675 { "_vptr", &vptr_identifier
, 0 },
3676 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3677 { "::", &global_scope_name
, 0 },
3678 { "std", &std_identifier
, 0 },
3682 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3684 *pid
->node
= get_identifier (pid
->name
);
3685 if (pid
->ctor_or_dtor_p
)
3686 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3690 /* Create the predefined scalar types of C,
3691 and some nodes representing standard constants (0, 1, (void *)0).
3692 Initialize the global binding level.
3693 Make definitions for built-in primitive functions. */
3696 cxx_init_decl_processing (void)
3699 tree void_ftype_ptr
;
3701 /* Create all the identifiers we need. */
3702 initialize_predefined_identifiers ();
3704 /* Create the global variables. */
3705 push_to_top_level ();
3707 current_function_decl
= NULL_TREE
;
3708 current_binding_level
= NULL
;
3709 /* Enter the global namespace. */
3710 gcc_assert (global_namespace
== NULL_TREE
);
3711 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3713 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3714 TREE_PUBLIC (global_namespace
) = 1;
3715 begin_scope (sk_namespace
, global_namespace
);
3717 if (flag_visibility_ms_compat
)
3718 default_visibility
= VISIBILITY_HIDDEN
;
3721 current_lang_name
= lang_name_c
;
3723 /* Create the `std' namespace. */
3724 push_namespace (std_identifier
);
3725 std_node
= current_namespace
;
3728 c_common_nodes_and_builtins ();
3730 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3731 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3732 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3733 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3734 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3735 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3736 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3737 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3739 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3741 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3742 truthvalue_type_node
= boolean_type_node
;
3743 truthvalue_false_node
= boolean_false_node
;
3744 truthvalue_true_node
= boolean_true_node
;
3746 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3747 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3748 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3751 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3754 delta_type_node
= ptrdiff_type_node
;
3755 vtable_index_type
= ptrdiff_type_node
;
3757 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3758 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3759 void_ftype_ptr
= build_function_type_list (void_type_node
,
3760 ptr_type_node
, NULL_TREE
);
3762 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3764 /* C++ extensions */
3766 unknown_type_node
= make_node (LANG_TYPE
);
3767 record_unknown_type (unknown_type_node
, "unknown type");
3769 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3770 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3772 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3774 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3775 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3777 init_list_type_node
= make_node (LANG_TYPE
);
3778 record_unknown_type (init_list_type_node
, "init list");
3781 /* Make sure we get a unique function type, so we can give
3782 its pointer type a name. (This wins for gdb.) */
3783 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3784 TREE_TYPE (vfunc_type
) = integer_type_node
;
3785 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3786 layout_type (vfunc_type
);
3788 vtable_entry_type
= build_pointer_type (vfunc_type
);
3790 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3793 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3794 layout_type (vtbl_type_node
);
3795 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3796 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3797 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3798 layout_type (vtbl_ptr_type_node
);
3799 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3801 push_namespace (get_identifier ("__cxxabiv1"));
3802 abi_node
= current_namespace
;
3805 global_type_node
= make_node (LANG_TYPE
);
3806 record_unknown_type (global_type_node
, "global type");
3809 current_lang_name
= lang_name_cplusplus
;
3812 tree newattrs
, extvisattr
;
3813 tree newtype
, deltype
;
3814 tree ptr_ftype_sizetype
;
3818 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3819 if (cxx_dialect
== cxx98
)
3822 tree bad_alloc_type_node
;
3823 tree bad_alloc_decl
;
3825 push_namespace (std_identifier
);
3826 bad_alloc_id
= get_identifier ("bad_alloc");
3827 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3828 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3830 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3831 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3835 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3838 new_eh_spec
= noexcept_false_spec
;
3840 /* Ensure attribs.c is initialized. */
3842 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3844 newattrs
= tree_cons (get_identifier ("alloc_size"),
3845 build_tree_list (NULL_TREE
, integer_one_node
),
3847 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3848 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3849 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3850 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3851 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
3852 DECL_IS_MALLOC (opnew
) = 1;
3853 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3854 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
3855 DECL_IS_MALLOC (opnew
) = 1;
3856 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3857 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3858 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3860 nullptr_type_node
= make_node (NULLPTR_TYPE
);
3861 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
3862 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
3863 TYPE_UNSIGNED (nullptr_type_node
) = 1;
3864 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
3865 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
3866 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
3867 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
3871 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
3872 ECF_NORETURN
| ECF_NOTHROW
);
3874 /* Perform other language dependent initializations. */
3875 init_class_processing ();
3876 init_rtti_processing ();
3877 init_template_processing ();
3879 if (flag_exceptions
)
3880 init_exception_processing ();
3882 if (! supports_one_only ())
3885 make_fname_decl
= cp_make_fname_decl
;
3886 start_fname_decls ();
3888 /* Show we use EH for cleanups. */
3889 if (flag_exceptions
)
3890 using_eh_for_cleanups ();
3893 /* Generate an initializer for a function naming variable from
3894 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3895 filled in with the type of the init. */
3898 cp_fname_init (const char* name
, tree
*type_p
)
3900 tree domain
= NULL_TREE
;
3902 tree init
= NULL_TREE
;
3907 length
= strlen (name
);
3908 domain
= build_index_type (size_int (length
));
3909 init
= build_string (length
+ 1, name
);
3912 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3913 type
= build_cplus_array_type (type
, domain
);
3918 TREE_TYPE (init
) = type
;
3920 init
= error_mark_node
;
3925 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3926 the decl, LOC is the location to give the decl, NAME is the
3927 initialization string and TYPE_DEP indicates whether NAME depended
3928 on the type of the function. We make use of that to detect
3929 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3930 at the point of first use, so we mustn't push the decl now. */
3933 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3935 const char *const name
= (type_dep
&& processing_template_decl
3936 ? NULL
: fname_as_string (type_dep
));
3938 tree init
= cp_fname_init (name
, &type
);
3939 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3942 free (CONST_CAST (char *, name
));
3944 /* As we're using pushdecl_with_scope, we must set the context. */
3945 DECL_CONTEXT (decl
) = current_function_decl
;
3947 TREE_STATIC (decl
) = 1;
3948 TREE_READONLY (decl
) = 1;
3949 DECL_ARTIFICIAL (decl
) = 1;
3951 TREE_USED (decl
) = 1;
3953 if (current_function_decl
)
3955 cp_binding_level
*b
= current_binding_level
;
3956 if (b
->kind
== sk_function_parms
)
3957 return error_mark_node
;
3958 while (b
->level_chain
->kind
!= sk_function_parms
)
3960 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3961 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3962 LOOKUP_ONLYCONVERTING
);
3966 DECL_THIS_STATIC (decl
) = true;
3967 pushdecl_top_level_and_finish (decl
, init
);
3974 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3976 tree id
= DECL_NAME (decl
);
3977 const char *name
= IDENTIFIER_POINTER (id
);
3979 retrofit_lang_decl (decl
);
3981 DECL_ARTIFICIAL (decl
) = 1;
3982 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3983 SET_DECL_LANGUAGE (decl
, lang_c
);
3984 /* Runtime library routines are, by definition, available in an
3985 external shared object. */
3986 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3987 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3989 DECL_CONTEXT (decl
) = context
;
3992 pushdecl_top_level (decl
);
3996 /* A function in the user's namespace should have an explicit
3997 declaration before it is used. Mark the built-in function as
3998 anticipated but not actually declared. */
3999 if (name
[0] != '_' || name
[1] != '_')
4000 DECL_ANTICIPATED (decl
) = 1;
4001 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4003 size_t len
= strlen (name
);
4005 /* Treat __*_chk fortification functions as anticipated as well,
4006 unless they are __builtin_*. */
4007 if (len
> strlen ("___chk")
4008 && memcmp (name
+ len
- strlen ("_chk"),
4009 "_chk", strlen ("_chk") + 1) == 0)
4010 DECL_ANTICIPATED (decl
) = 1;
4017 cxx_builtin_function (tree decl
)
4019 tree id
= DECL_NAME (decl
);
4020 const char *name
= IDENTIFIER_POINTER (id
);
4021 /* All builtins that don't begin with an '_' should additionally
4022 go in the 'std' namespace. */
4025 tree decl2
= copy_node(decl
);
4026 push_namespace (std_identifier
);
4027 builtin_function_1 (decl2
, std_node
, false);
4031 return builtin_function_1 (decl
, NULL_TREE
, false);
4034 /* Like cxx_builtin_function, but guarantee the function is added to the global
4035 scope. This is to allow function specific options to add new machine
4036 dependent builtins when the target ISA changes via attribute((target(...)))
4037 which saves space on program startup if the program does not use non-generic
4041 cxx_builtin_function_ext_scope (tree decl
)
4044 tree id
= DECL_NAME (decl
);
4045 const char *name
= IDENTIFIER_POINTER (id
);
4046 /* All builtins that don't begin with an '_' should additionally
4047 go in the 'std' namespace. */
4050 tree decl2
= copy_node(decl
);
4051 push_namespace (std_identifier
);
4052 builtin_function_1 (decl2
, std_node
, true);
4056 return builtin_function_1 (decl
, NULL_TREE
, true);
4059 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4060 function. Not called directly. */
4063 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4066 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4067 DECL_EXTERNAL (fn
) = 1;
4068 TREE_PUBLIC (fn
) = 1;
4069 DECL_ARTIFICIAL (fn
) = 1;
4070 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4071 SET_DECL_LANGUAGE (fn
, lang_c
);
4072 /* Runtime library routines are, by definition, available in an
4073 external shared object. */
4074 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4075 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4076 set_call_expr_flags (fn
, ecf_flags
);
4080 /* Returns the _DECL for a library function with C++ linkage. */
4083 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4086 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4087 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4088 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4092 /* Like build_library_fn, but takes a C string instead of an
4096 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4098 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4101 /* Like build_cp_library_fn, but takes a C string instead of an
4105 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4107 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4111 /* Like build_library_fn, but also pushes the function so that we will
4112 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4113 may throw exceptions listed in RAISES. */
4116 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4121 type
= build_exception_variant (type
, raises
);
4123 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4124 pushdecl_top_level (fn
);
4128 /* Like build_cp_library_fn, but also pushes the function so that it
4129 will be found by normal lookup. */
4132 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4135 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4140 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4144 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4148 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4150 tree type
= build_function_type (void_type_node
, parmtypes
);
4151 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4154 /* Like push_library_fn, but also note that this function throws
4155 and does not return. Used for __throw_foo and the like. */
4158 push_throw_library_fn (tree name
, tree type
)
4160 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4164 /* When we call finish_struct for an anonymous union, we create
4165 default copy constructors and such. But, an anonymous union
4166 shouldn't have such things; this function undoes the damage to the
4167 anonymous union type T.
4169 (The reason that we create the synthesized methods is that we don't
4170 distinguish `union { int i; }' from `typedef union { int i; } U'.
4171 The first is an anonymous union; the second is just an ordinary
4175 fixup_anonymous_aggr (tree t
)
4179 /* Wipe out memory of synthesized methods. */
4180 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4181 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4182 TYPE_HAS_COPY_CTOR (t
) = 0;
4183 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4184 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4185 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4187 /* Splice the implicitly generated functions out of the TYPE_METHODS
4189 q
= &TYPE_METHODS (t
);
4192 if (DECL_ARTIFICIAL (*q
))
4193 *q
= TREE_CHAIN (*q
);
4195 q
= &DECL_CHAIN (*q
);
4198 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4199 if (TYPE_METHODS (t
))
4201 tree decl
= TYPE_MAIN_DECL (t
);
4203 if (TREE_CODE (t
) != UNION_TYPE
)
4204 error_at (DECL_SOURCE_LOCATION (decl
),
4205 "an anonymous struct cannot have function members");
4207 error_at (DECL_SOURCE_LOCATION (decl
),
4208 "an anonymous union cannot have function members");
4211 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4212 assignment operators (because they cannot have these methods themselves).
4213 For anonymous unions this is already checked because they are not allowed
4214 in any union, otherwise we have to check it. */
4215 if (TREE_CODE (t
) != UNION_TYPE
)
4219 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4220 if (TREE_CODE (field
) == FIELD_DECL
)
4222 type
= TREE_TYPE (field
);
4223 if (CLASS_TYPE_P (type
))
4225 if (TYPE_NEEDS_CONSTRUCTING (type
))
4226 error ("member %q+#D with constructor not allowed "
4227 "in anonymous aggregate", field
);
4228 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4229 error ("member %q+#D with destructor not allowed "
4230 "in anonymous aggregate", field
);
4231 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4232 error ("member %q+#D with copy assignment operator "
4233 "not allowed in anonymous aggregate", field
);
4239 /* Warn for an attribute located at LOCATION that appertains to the
4240 class type CLASS_TYPE that has not been properly placed after its
4241 class-key, in it class-specifier. */
4244 warn_misplaced_attr_for_class_type (source_location location
,
4247 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4249 if (warning_at (location
, OPT_Wattributes
,
4250 "attribute ignored in declaration "
4251 "of %q#T", class_type
))
4253 "attribute for %q#T must follow the %qs keyword",
4254 class_type
, class_key_or_enum_as_string (class_type
));
4257 /* Make sure that a declaration with no declarator is well-formed, i.e.
4258 just declares a tagged type or anonymous union.
4260 Returns the type declared; or NULL_TREE if none. */
4263 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4264 bool explicit_type_instantiation_p
)
4266 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4267 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4268 /* If a class, struct, or enum type is declared by the DECLSPECS
4269 (i.e, if a class-specifier, enum-specifier, or non-typename
4270 elaborated-type-specifier appears in the DECLSPECS),
4271 DECLARED_TYPE is set to the corresponding type. */
4272 tree declared_type
= NULL_TREE
;
4273 bool error_p
= false;
4275 if (declspecs
->multiple_types_p
)
4276 error ("multiple types in one declaration");
4277 else if (declspecs
->redefined_builtin_type
)
4279 if (!in_system_header_at (input_location
))
4280 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4281 "redeclaration of C++ built-in type %qT",
4282 declspecs
->redefined_builtin_type
);
4287 && TYPE_P (declspecs
->type
)
4288 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4289 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4290 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4291 declared_type
= declspecs
->type
;
4292 else if (declspecs
->type
== error_mark_node
)
4294 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4295 permerror (input_location
, "declaration does not declare anything");
4296 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4298 error ("%<auto%> can only be specified for variables "
4299 "or function declarations");
4300 return error_mark_node
;
4302 /* Check for an anonymous union. */
4303 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4304 && TYPE_ANONYMOUS_P (declared_type
))
4306 /* 7/3 In a simple-declaration, the optional init-declarator-list
4307 can be omitted only when declaring a class (clause 9) or
4308 enumeration (7.2), that is, when the decl-specifier-seq contains
4309 either a class-specifier, an elaborated-type-specifier with
4310 a class-key (9.1), or an enum-specifier. In these cases and
4311 whenever a class-specifier or enum-specifier is present in the
4312 decl-specifier-seq, the identifiers in these specifiers are among
4313 the names being declared by the declaration (as class-name,
4314 enum-names, or enumerators, depending on the syntax). In such
4315 cases, and except for the declaration of an unnamed bit-field (9.6),
4316 the decl-specifier-seq shall introduce one or more names into the
4317 program, or shall redeclare a name introduced by a previous
4318 declaration. [Example:
4319 enum { }; // ill-formed
4320 typedef class { }; // ill-formed
4324 error ("missing type-name in typedef-declaration");
4327 /* Anonymous unions are objects, so they can have specifiers. */;
4328 SET_ANON_AGGR_TYPE_P (declared_type
);
4330 if (TREE_CODE (declared_type
) != UNION_TYPE
4331 && !in_system_header_at (input_location
))
4332 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4337 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4338 || decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4339 error ("%qs can only be specified for functions",
4340 decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4341 ? "inline" : "virtual");
4343 && (!current_class_type
4344 || current_scope () != current_class_type
))
4345 error ("%<friend%> can only be specified inside a class");
4346 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4347 error ("%<explicit%> can only be specified for constructors");
4348 else if (declspecs
->storage_class
)
4349 error ("a storage class can only be specified for objects "
4351 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
)
4352 || decl_spec_seq_has_spec_p (declspecs
, ds_volatile
)
4353 || decl_spec_seq_has_spec_p (declspecs
, ds_restrict
)
4354 || decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4355 error ("qualifiers can only be specified for objects "
4357 else if (saw_typedef
)
4358 warning (0, "%<typedef%> was ignored in this declaration");
4359 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4360 error ("%<constexpr%> cannot be used for type declarations");
4363 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4366 if (!CLASS_TYPE_P (declared_type
)
4367 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4368 /* For a non-template class, use the name location. */
4369 loc
= location_of (declared_type
);
4371 /* For a template class (an explicit instantiation), use the
4372 current location. */
4373 loc
= input_location
;
4375 if (explicit_type_instantiation_p
)
4376 /* [dcl.attr.grammar]/4:
4378 No attribute-specifier-seq shall appertain to an explicit
4381 if (warning_at (loc
, OPT_Wattributes
,
4382 "attribute ignored in explicit instantiation %q#T",
4385 "no attribute can be applied to "
4386 "an explicit instantiation");
4389 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4392 return declared_type
;
4395 /* Called when a declaration is seen that contains no names to declare.
4396 If its type is a reference to a structure, union or enum inherited
4397 from a containing scope, shadow that tag name for the current scope
4398 with a forward reference.
4399 If its type defines a new named structure or union
4400 or defines an enum, it is valid but we need not do anything here.
4401 Otherwise, it is an error.
4403 C++: may have to grok the declspecs to learn about static,
4404 complain for anonymous unions.
4406 Returns the TYPE declared -- or NULL_TREE if none. */
4409 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4411 tree t
= check_tag_decl (declspecs
,
4412 /*explicit_type_instantiation_p=*/false);
4417 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4420 /* This is where the variables in an anonymous union are
4421 declared. An anonymous union declaration looks like:
4423 because there is no declarator after the union, the parser
4424 sends that declaration here. */
4425 if (ANON_AGGR_TYPE_P (t
))
4427 fixup_anonymous_aggr (t
);
4429 if (TYPE_FIELDS (t
))
4431 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4432 declspecs
, NORMAL
, 0, NULL
);
4433 finish_anon_union (decl
);
4440 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4443 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4444 const cp_declarator
*declarator
,
4445 bool is_template_arg
)
4449 enum decl_context context
4450 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4451 attrs
= type_specifiers
->attributes
;
4452 type_specifiers
->attributes
= NULL_TREE
;
4453 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4454 if (attrs
&& type
!= error_mark_node
)
4456 if (CLASS_TYPE_P (type
))
4457 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4458 "outside of definition", type
);
4459 else if (MAYBE_CLASS_TYPE_P (type
))
4460 /* A template type parameter or other dependent type. */
4461 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4462 "type %qT without an associated declaration", type
);
4464 cplus_decl_attributes (&type
, attrs
, 0);
4469 /* Process a DECLARATOR for a function-scope variable declaration,
4470 namespace-scope variable declaration, or function declaration.
4471 (Function definitions go through start_function; class member
4472 declarations appearing in the body of the class go through
4473 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4474 If an error occurs, the error_mark_node is returned instead.
4476 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4477 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4478 for an explicitly defaulted function, or SD_DELETED for an explicitly
4479 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4480 implicitly initialized via a default constructor. ATTRIBUTES and
4481 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4483 The scope represented by the context of the returned DECL is pushed
4484 (if it is not the global namespace) and is assigned to
4485 *PUSHED_SCOPE_P. The caller is then responsible for calling
4486 pop_scope on *PUSHED_SCOPE_P if it is set. */
4489 start_decl (const cp_declarator
*declarator
,
4490 cp_decl_specifier_seq
*declspecs
,
4493 tree prefix_attributes
,
4494 tree
*pushed_scope_p
)
4502 *pushed_scope_p
= NULL_TREE
;
4504 /* An object declared as __attribute__((deprecated)) suppresses
4505 warnings of uses of other deprecated items. */
4506 if (lookup_attribute ("deprecated", attributes
))
4507 deprecated_state
= DEPRECATED_SUPPRESS
;
4509 attributes
= chainon (attributes
, prefix_attributes
);
4511 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4514 deprecated_state
= DEPRECATED_NORMAL
;
4516 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4517 || decl
== error_mark_node
)
4518 return error_mark_node
;
4520 context
= CP_DECL_CONTEXT (decl
);
4521 if (context
!= global_namespace
)
4522 *pushed_scope_p
= push_scope (context
);
4525 /* Is it valid for this decl to have an initializer at all?
4526 If not, set INITIALIZED to zero, which will indirectly
4527 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4528 switch (TREE_CODE (decl
))
4531 error ("typedef %qD is initialized (use decltype instead)", decl
);
4532 return error_mark_node
;
4535 if (initialized
== SD_DELETED
)
4536 /* We'll handle the rest of the semantics later, but we need to
4537 set this now so it's visible to duplicate_decls. */
4538 DECL_DELETED_FN (decl
) = 1;
4547 if (! toplevel_bindings_p ()
4548 && DECL_EXTERNAL (decl
))
4549 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4551 DECL_EXTERNAL (decl
) = 0;
4552 if (toplevel_bindings_p ())
4553 TREE_STATIC (decl
) = 1;
4555 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4557 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4558 record_key_method_defined (decl
);
4560 /* If this is a typedef that names the class for linkage purposes
4561 (7.1.3p8), apply any attributes directly to the type. */
4562 if (TREE_CODE (decl
) == TYPE_DECL
4563 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4564 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4565 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4569 /* Set attributes here so if duplicate decl, will have proper attributes. */
4570 cplus_decl_attributes (&decl
, attributes
, flags
);
4572 /* Dllimported symbols cannot be defined. Static data members (which
4573 can be initialized in-class and dllimported) go through grokfield,
4574 not here, so we don't need to exclude those decls when checking for
4576 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4578 error ("definition of %q#D is marked %<dllimport%>", decl
);
4579 DECL_DLLIMPORT_P (decl
) = 0;
4582 /* If #pragma weak was used, mark the decl weak now. */
4583 if (!processing_template_decl
)
4584 maybe_apply_pragma_weak (decl
);
4586 if (TREE_CODE (decl
) == FUNCTION_DECL
4587 && DECL_DECLARED_INLINE_P (decl
)
4588 && DECL_UNINLINABLE (decl
)
4589 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4590 warning (0, "inline function %q+D given attribute noinline", decl
);
4592 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4596 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4597 if (field
== NULL_TREE
|| !VAR_P (field
))
4598 error ("%q#D is not a static member of %q#T", decl
, context
);
4601 if (DECL_CONTEXT (field
) != context
)
4603 if (!same_type_p (DECL_CONTEXT (field
), context
))
4604 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4605 "to be defined as %<%T::%D%>",
4606 DECL_CONTEXT (field
), DECL_NAME (decl
),
4607 context
, DECL_NAME (decl
));
4608 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4610 /* Static data member are tricky; an in-class initialization
4611 still doesn't provide a definition, so the in-class
4612 declaration will have DECL_EXTERNAL set, but will have an
4613 initialization. Thus, duplicate_decls won't warn
4614 about this situation, and so we check here. */
4615 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4616 error ("duplicate initialization of %qD", decl
);
4617 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4619 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4620 && !DECL_DECLARED_CONSTEXPR_P (field
))
4621 error ("%qD declared %<constexpr%> outside its class", field
);
4626 tree field
= check_classfn (context
, decl
,
4627 (processing_template_decl
4628 > template_class_depth (context
))
4629 ? current_template_parms
4631 if (field
&& field
!= error_mark_node
4632 && duplicate_decls (decl
, field
,
4633 /*newdecl_is_friend=*/false))
4637 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4638 DECL_IN_AGGR_P (decl
) = 0;
4639 /* Do not mark DECL as an explicit specialization if it was not
4640 already marked as an instantiation; a declaration should
4641 never be marked as a specialization unless we know what
4642 template is being specialized. */
4643 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4645 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4647 /* [temp.expl.spec] An explicit specialization of a static data
4648 member of a template is a definition if the declaration
4649 includes an initializer; otherwise, it is a declaration.
4651 We check for processing_specialization so this only applies
4652 to the new specialization syntax. */
4653 if (!initialized
&& processing_specialization
)
4654 DECL_EXTERNAL (decl
) = 1;
4657 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4658 /* Aliases are definitions. */
4660 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4664 was_public
= TREE_PUBLIC (decl
);
4666 /* Enter this declaration into the symbol table. */
4667 decl
= maybe_push_decl (decl
);
4669 if (processing_template_decl
)
4670 decl
= push_template_decl (decl
);
4671 if (decl
== error_mark_node
)
4672 return error_mark_node
;
4675 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4676 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4678 /* This is a const variable with implicit 'static'. Set
4679 DECL_THIS_STATIC so we can tell it from variables that are
4680 !TREE_PUBLIC because of the anonymous namespace. */
4681 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4682 DECL_THIS_STATIC (decl
) = 1;
4685 if (!processing_template_decl
&& VAR_P (decl
))
4686 start_decl_1 (decl
, initialized
);
4691 /* Process the declaration of a variable DECL. INITIALIZED is true
4692 iff DECL is explicitly initialized. (INITIALIZED is false if the
4693 variable is initialized via an implicitly-called constructor.)
4694 This function must be called for ordinary variables (including, for
4695 example, implicit instantiations of templates), but must not be
4696 called for template declarations. */
4699 start_decl_1 (tree decl
, bool initialized
)
4703 bool aggregate_definition_p
;
4705 gcc_assert (!processing_template_decl
);
4707 if (error_operand_p (decl
))
4710 gcc_assert (VAR_P (decl
));
4712 type
= TREE_TYPE (decl
);
4713 complete_p
= COMPLETE_TYPE_P (type
);
4714 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4716 /* If an explicit initializer is present, or if this is a definition
4717 of an aggregate, then we need a complete type at this point.
4718 (Scalars are always complete types, so there is nothing to
4719 check.) This code just sets COMPLETE_P; errors (if necessary)
4720 are issued below. */
4721 if ((initialized
|| aggregate_definition_p
)
4723 && COMPLETE_TYPE_P (complete_type (type
)))
4726 /* We will not yet have set TREE_READONLY on DECL if the type
4727 was "const", but incomplete, before this point. But, now, we
4728 have a complete type, so we can try again. */
4729 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4733 /* Is it valid for this decl to have an initializer at all? */
4735 /* Don't allow initializations for incomplete types except for
4736 arrays which might be completed by the initialization. */
4738 ; /* A complete type is ok. */
4739 else if (type_uses_auto (type
))
4740 ; /* An auto type is ok. */
4741 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4743 error ("variable %q#D has initializer but incomplete type", decl
);
4744 type
= TREE_TYPE (decl
) = error_mark_node
;
4746 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4748 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4749 error ("elements of array %q#D have incomplete type", decl
);
4750 /* else we already gave an error in start_decl. */
4753 else if (aggregate_definition_p
&& !complete_p
)
4755 if (type_uses_auto (type
))
4756 error ("declaration of %q#D has no initializer", decl
);
4758 error ("aggregate %q#D has incomplete type and cannot be defined",
4760 /* Change the type so that assemble_variable will give
4761 DECL an rtl we can live with: (mem (const_int 0)). */
4762 type
= TREE_TYPE (decl
) = error_mark_node
;
4765 /* Create a new scope to hold this declaration if necessary.
4766 Whether or not a new scope is necessary cannot be determined
4767 until after the type has been completed; if the type is a
4768 specialization of a class template it is not until after
4769 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4770 will be set correctly. */
4771 maybe_push_cleanup_level (type
);
4774 /* Handle initialization of references. DECL, TYPE, and INIT have the
4775 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4776 but will be set to a new CLEANUP_STMT if a temporary is created
4777 that must be destroyed subsequently.
4779 Returns an initializer expression to use to initialize DECL, or
4780 NULL if the initialization can be performed statically.
4782 Quotes on semantics can be found in ARM 8.4.3. */
4785 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4787 if (init
== NULL_TREE
)
4789 if ((DECL_LANG_SPECIFIC (decl
) == 0
4790 || DECL_IN_AGGR_P (decl
) == 0)
4791 && ! DECL_THIS_EXTERN (decl
))
4792 error ("%qD declared as reference but not initialized", decl
);
4796 if (TREE_CODE (init
) == TREE_LIST
)
4797 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4798 tf_warning_or_error
);
4800 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4801 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4802 /* Note: default conversion is only called in very special cases. */
4803 init
= decay_conversion (init
, tf_warning_or_error
);
4805 /* Convert INIT to the reference type TYPE. This may involve the
4806 creation of a temporary, whose lifetime must be the same as that
4807 of the reference. If so, a DECL_EXPR for the temporary will be
4808 added just after the DECL_EXPR for DECL. That's why we don't set
4809 DECL_INITIAL for local references (instead assigning to them
4810 explicitly); we need to allow the temporary to be initialized
4812 return initialize_reference (type
, init
, flags
,
4813 tf_warning_or_error
);
4816 /* Designated initializers in arrays are not supported in GNU C++.
4817 The parser cannot detect this error since it does not know whether
4818 a given brace-enclosed initializer is for a class type or for an
4819 array. This function checks that CE does not use a designated
4820 initializer. If it does, an error is issued. Returns true if CE
4821 is valid, i.e., does not have a designated initializer. */
4824 check_array_designated_initializer (constructor_elt
*ce
,
4825 unsigned HOST_WIDE_INT index
)
4827 /* Designated initializers for array elements are not supported. */
4830 /* The parser only allows identifiers as designated
4832 if (ce
->index
== error_mark_node
)
4834 error ("name used in a GNU-style designated "
4835 "initializer for an array");
4838 else if (identifier_p (ce
->index
))
4840 error ("name %qD used in a GNU-style designated "
4841 "initializer for an array", ce
->index
);
4845 ce
->index
= cxx_constant_value (ce
->index
);
4847 if (TREE_CODE (ce
->index
) == INTEGER_CST
)
4849 /* A C99 designator is OK if it matches the current index. */
4850 if (wi::eq_p (ce
->index
, index
))
4853 sorry ("non-trivial designated initializers not supported");
4864 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4865 array until we finish parsing the initializer. If that's the
4866 situation we're in, update DECL accordingly. */
4869 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4871 tree type
= TREE_TYPE (decl
);
4873 if (TREE_CODE (type
) == ARRAY_TYPE
4874 && TYPE_DOMAIN (type
) == NULL_TREE
4875 && TREE_CODE (decl
) != TYPE_DECL
)
4877 /* do_default is really a C-ism to deal with tentative definitions.
4878 But let's leave it here to ease the eventual merge. */
4879 int do_default
= !DECL_EXTERNAL (decl
);
4880 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4883 /* Check that there are no designated initializers in INIT, as
4884 those are not supported in GNU C++, and as the middle-end
4885 will crash if presented with a non-numeric designated
4887 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
4889 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
4890 constructor_elt
*ce
;
4892 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
4893 if (!check_array_designated_initializer (ce
, i
))
4899 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4903 error ("initializer fails to determine size of %qD", decl
);
4905 else if (failure
== 2)
4909 error ("array size missing in %qD", decl
);
4911 /* If a `static' var's size isn't known, make it extern as
4912 well as static, so it does not get allocated. If it's not
4913 `static', then don't mark it extern; finish_incomplete_decl
4914 will give it a default size and it will get allocated. */
4915 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4916 DECL_EXTERNAL (decl
) = 1;
4918 else if (failure
== 3)
4920 error ("zero-size array %qD", decl
);
4924 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4926 relayout_decl (decl
);
4930 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4931 any appropriate error messages regarding the layout. */
4934 layout_var_decl (tree decl
)
4938 type
= TREE_TYPE (decl
);
4939 if (type
== error_mark_node
)
4942 /* If we haven't already laid out this declaration, do so now.
4943 Note that we must not call complete type for an external object
4944 because it's type might involve templates that we are not
4945 supposed to instantiate yet. (And it's perfectly valid to say
4946 `extern X x' for some incomplete type `X'.) */
4947 if (!DECL_EXTERNAL (decl
))
4948 complete_type (type
);
4949 if (!DECL_SIZE (decl
)
4950 && TREE_TYPE (decl
) != error_mark_node
4951 && (COMPLETE_TYPE_P (type
)
4952 || (TREE_CODE (type
) == ARRAY_TYPE
4953 && !TYPE_DOMAIN (type
)
4954 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4955 layout_decl (decl
, 0);
4957 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4959 /* An automatic variable with an incomplete type: that is an error.
4960 Don't talk about array types here, since we took care of that
4961 message in grokdeclarator. */
4962 error ("storage size of %qD isn%'t known", decl
);
4963 TREE_TYPE (decl
) = error_mark_node
;
4966 /* Keep this code around in case we later want to control debug info
4967 based on whether a type is "used". (jason 1999-11-11) */
4969 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4970 /* Let debugger know it should output info for this type. */
4971 note_debug_info_needed (ttype
);
4973 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4974 note_debug_info_needed (DECL_CONTEXT (decl
));
4977 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4978 && DECL_SIZE (decl
) != NULL_TREE
4979 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4981 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4982 constant_expression_warning (DECL_SIZE (decl
));
4985 error ("storage size of %qD isn%'t constant", decl
);
4986 TREE_TYPE (decl
) = error_mark_node
;
4991 /* If a local static variable is declared in an inline function, or if
4992 we have a weak definition, we must endeavor to create only one
4993 instance of the variable at link-time. */
4996 maybe_commonize_var (tree decl
)
4998 /* Static data in a function with comdat linkage also has comdat
5000 if (TREE_STATIC (decl
)
5001 /* Don't mess with __FUNCTION__. */
5002 && ! DECL_ARTIFICIAL (decl
)
5003 && DECL_FUNCTION_SCOPE_P (decl
)
5004 && vague_linkage_p (DECL_CONTEXT (decl
)))
5008 /* With weak symbols, we simply make the variable COMDAT;
5009 that will cause copies in multiple translations units to
5011 comdat_linkage (decl
);
5015 if (DECL_INITIAL (decl
) == NULL_TREE
5016 || DECL_INITIAL (decl
) == error_mark_node
)
5018 /* Without weak symbols, we can use COMMON to merge
5019 uninitialized variables. */
5020 TREE_PUBLIC (decl
) = 1;
5021 DECL_COMMON (decl
) = 1;
5025 /* While for initialized variables, we must use internal
5026 linkage -- which means that multiple copies will not
5028 TREE_PUBLIC (decl
) = 0;
5029 DECL_COMMON (decl
) = 0;
5030 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5031 "sorry: semantics of inline function static "
5032 "data %q#D are wrong (you%'ll wind up "
5033 "with multiple copies)", decl
))
5034 inform (DECL_SOURCE_LOCATION (decl
),
5035 "you can work around this by removing the initializer");
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
10590 || !COMPLETE_TYPE_P (TREE_TYPE (type
))
10591 || initialized
== 0))
10593 if (unqualified_id
)
10595 error ("field %qD has incomplete type %qT",
10596 unqualified_id
, type
);
10597 cxx_incomplete_type_inform (strip_array_types (type
));
10600 error ("name %qT has incomplete type", type
);
10602 type
= error_mark_node
;
10609 error ("%qE is neither function nor member function; "
10610 "cannot be declared friend", unqualified_id
);
10618 /* Friends are treated specially. */
10619 if (ctype
== current_class_type
)
10620 ; /* We already issued a permerror. */
10621 else if (decl
&& DECL_NAME (decl
))
10623 if (template_class_depth (current_class_type
) == 0)
10625 decl
= check_explicit_specialization
10626 (unqualified_id
, decl
, template_count
,
10627 2 * funcdef_flag
+ 4);
10628 if (decl
== error_mark_node
)
10629 return error_mark_node
;
10632 decl
= do_friend (ctype
, unqualified_id
, decl
,
10638 return error_mark_node
;
10641 /* Structure field. It may not be a function, except for C++. */
10643 if (decl
== NULL_TREE
)
10647 /* C++ allows static class members. All other work
10648 for this is done by grokfield. */
10649 decl
= build_lang_decl_loc (declarator
10650 ? declarator
->id_loc
10652 VAR_DECL
, unqualified_id
, type
);
10653 set_linkage_for_static_data_member (decl
);
10654 /* Even if there is an in-class initialization, DECL
10655 is considered undefined until an out-of-class
10656 definition is provided. */
10657 DECL_EXTERNAL (decl
) = 1;
10661 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
10662 if (declspecs
->gnu_thread_keyword_p
)
10663 DECL_GNU_TLS_P (decl
) = true;
10666 if (constexpr_p
&& !initialized
)
10668 error ("constexpr static data member %qD must have an "
10669 "initializer", decl
);
10670 constexpr_p
= false;
10677 error ("non-static data member %qE declared %<constexpr%>",
10679 constexpr_p
= false;
10681 decl
= build_decl (input_location
,
10682 FIELD_DECL
, unqualified_id
, type
);
10683 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10684 if (bitfield
&& !unqualified_id
)
10685 TREE_NO_WARNING (decl
) = 1;
10687 if (storage_class
== sc_mutable
)
10689 DECL_MUTABLE_P (decl
) = 1;
10690 storage_class
= sc_none
;
10695 /* An attempt is being made to initialize a non-static
10696 member. This is new in C++11. */
10697 maybe_warn_cpp0x (CPP0X_NSDMI
);
10699 /* If this has been parsed with static storage class, but
10700 errors forced staticp to be cleared, ensure NSDMI is
10702 if (declspecs
->storage_class
== sc_static
)
10703 DECL_INITIAL (decl
) = error_mark_node
;
10707 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10708 memfn_quals
!= TYPE_UNQUALIFIED
,
10709 inlinep
, friendp
, raises
!= NULL_TREE
);
10712 else if (TREE_CODE (type
) == FUNCTION_TYPE
10713 || TREE_CODE (type
) == METHOD_TYPE
)
10715 tree original_name
;
10718 if (!unqualified_id
)
10719 return error_mark_node
;
10721 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10722 original_name
= dname
;
10724 original_name
= unqualified_id
;
10726 if (storage_class
== sc_auto
)
10727 error ("storage class %<auto%> invalid for function %qs", name
);
10728 else if (storage_class
== sc_register
)
10729 error ("storage class %<register%> invalid for function %qs", name
);
10732 if (declspecs
->gnu_thread_keyword_p
)
10733 error ("storage class %<__thread%> invalid for function %qs",
10736 error ("storage class %<thread_local%> invalid for function %qs",
10740 if (virt_specifiers
)
10741 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10742 /* Function declaration not at top level.
10743 Storage classes other than `extern' are not allowed
10744 and `extern' makes no difference. */
10745 if (! toplevel_bindings_p ()
10746 && (storage_class
== sc_static
10747 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10750 if (storage_class
== sc_static
)
10751 pedwarn (input_location
, OPT_Wpedantic
,
10752 "%<static%> specified invalid for function %qs "
10753 "declared out of global scope", name
);
10755 pedwarn (input_location
, OPT_Wpedantic
,
10756 "%<inline%> specifier invalid for function %qs "
10757 "declared out of global scope", name
);
10760 if (ctype
== NULL_TREE
)
10764 error ("virtual non-class function %qs", name
);
10767 else if (sfk
== sfk_constructor
10768 || sfk
== sfk_destructor
)
10770 error (funcdef_flag
10771 ? G_("%qs defined in a non-class scope")
10772 : G_("%qs declared in a non-class scope"), name
);
10777 /* Record whether the function is public. */
10778 publicp
= (ctype
!= NULL_TREE
10779 || storage_class
!= sc_static
);
10781 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10782 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10784 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10786 template_count
, in_namespace
, attrlist
,
10787 declarator
->id_loc
);
10788 if (decl
== NULL_TREE
)
10789 return error_mark_node
;
10793 int invalid_static
= 0;
10795 /* Don't allow a static member function in a class, and forbid
10796 declaring main to be static. */
10797 if (TREE_CODE (type
) == METHOD_TYPE
)
10799 permerror (input_location
, "cannot declare member function %qD to have "
10800 "static linkage", decl
);
10801 invalid_static
= 1;
10803 else if (current_function_decl
)
10805 /* FIXME need arm citation */
10806 error ("cannot declare static function inside another function");
10807 invalid_static
= 1;
10810 if (invalid_static
)
10813 storage_class
= sc_none
;
10819 /* It's a variable. */
10821 /* An uninitialized decl with `extern' is a reference. */
10822 decl
= grokvardecl (type
, unqualified_id
,
10825 (type_quals
& TYPE_QUAL_CONST
) != 0,
10826 ctype
? ctype
: in_namespace
);
10827 bad_specifiers (decl
, BSP_VAR
, virtualp
,
10828 memfn_quals
!= TYPE_UNQUALIFIED
,
10829 inlinep
, friendp
, raises
!= NULL_TREE
);
10833 DECL_CONTEXT (decl
) = ctype
;
10836 permerror (input_location
, "%<static%> may not be used when defining "
10837 "(as opposed to declaring) a static data member");
10839 storage_class
= sc_none
;
10841 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
10843 error ("static member %qD declared %<register%>", decl
);
10844 storage_class
= sc_none
;
10846 if (storage_class
== sc_extern
&& pedantic
)
10848 pedwarn (input_location
, OPT_Wpedantic
,
10849 "cannot explicitly declare member %q#D to have "
10850 "extern linkage", decl
);
10851 storage_class
= sc_none
;
10854 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
10856 error ("declaration of constexpr variable %qD is not a definition",
10858 constexpr_p
= false;
10862 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
10864 if (toplevel_bindings_p ())
10866 /* It's common practice (and completely valid) to have a const
10867 be initialized and declared extern. */
10868 if (!(type_quals
& TYPE_QUAL_CONST
))
10869 warning (0, "%qs initialized and declared %<extern%>", name
);
10873 error ("%qs has both %<extern%> and initializer", name
);
10874 return error_mark_node
;
10878 /* Record `register' declaration for warnings on &
10879 and in case doing stupid register allocation. */
10881 if (storage_class
== sc_register
)
10882 DECL_REGISTER (decl
) = 1;
10883 else if (storage_class
== sc_extern
)
10884 DECL_THIS_EXTERN (decl
) = 1;
10885 else if (storage_class
== sc_static
)
10886 DECL_THIS_STATIC (decl
) = 1;
10888 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10889 if (constexpr_p
&& VAR_P (decl
))
10890 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
10892 /* Record constancy and volatility on the DECL itself . There's
10893 no need to do this when processing a template; we'll do this
10894 for the instantiated declaration based on the type of DECL. */
10895 if (!processing_template_decl
)
10896 cp_apply_type_quals_to_decl (type_quals
, decl
);
10902 /* Subroutine of start_function. Ensure that each of the parameter
10903 types (as listed in PARMS) is complete, as is required for a
10904 function definition. */
10907 require_complete_types_for_parms (tree parms
)
10909 for (; parms
; parms
= DECL_CHAIN (parms
))
10911 if (dependent_type_p (TREE_TYPE (parms
)))
10913 if (!VOID_TYPE_P (TREE_TYPE (parms
))
10914 && complete_type_or_else (TREE_TYPE (parms
), parms
))
10916 relayout_decl (parms
);
10917 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
10920 /* grokparms or complete_type_or_else will have already issued
10922 TREE_TYPE (parms
) = error_mark_node
;
10926 /* Returns nonzero if T is a local variable. */
10929 local_variable_p (const_tree t
)
10932 /* A VAR_DECL with a context that is a _TYPE is a static data
10934 && !TYPE_P (CP_DECL_CONTEXT (t
))
10935 /* Any other non-local variable must be at namespace scope. */
10936 && !DECL_NAMESPACE_SCOPE_P (t
))
10937 || (TREE_CODE (t
) == PARM_DECL
))
10943 /* Like local_variable_p, but suitable for use as a tree-walking
10947 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
10950 if (local_variable_p (*tp
)
10951 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
10953 else if (TYPE_P (*tp
))
10954 *walk_subtrees
= 0;
10959 /* Check that ARG, which is a default-argument expression for a
10960 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10961 something goes wrong. DECL may also be a _TYPE node, rather than a
10962 DECL, if there is no DECL available. */
10965 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
10970 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10971 /* We get a DEFAULT_ARG when looking at an in-class declaration
10972 with a default argument. Ignore the argument for now; we'll
10973 deal with it after the class is complete. */
10982 decl_type
= TREE_TYPE (decl
);
10984 if (arg
== error_mark_node
10985 || decl
== error_mark_node
10986 || TREE_TYPE (arg
) == error_mark_node
10987 || decl_type
== error_mark_node
)
10988 /* Something already went wrong. There's no need to check
10990 return error_mark_node
;
10992 /* [dcl.fct.default]
10994 A default argument expression is implicitly converted to the
10996 ++cp_unevaluated_operand
;
10997 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
10999 --cp_unevaluated_operand
;
11001 if (warn_zero_as_null_pointer_constant
11002 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
11003 && null_ptr_cst_p (arg
)
11004 && (complain
& tf_warning
)
11005 && maybe_warn_zero_as_null_pointer_constant (arg
, input_location
))
11006 return nullptr_node
;
11008 /* [dcl.fct.default]
11010 Local variables shall not be used in default argument
11013 The keyword `this' shall not be used in a default argument of a
11014 member function. */
11015 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11018 if (complain
& tf_warning_or_error
)
11020 if (DECL_NAME (var
) == this_identifier
)
11021 permerror (input_location
, "default argument %qE uses %qD",
11024 error ("default argument %qE uses local variable %qD", arg
, var
);
11026 return error_mark_node
;
11033 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11036 type_is_deprecated (tree type
)
11038 enum tree_code code
;
11039 if (TREE_DEPRECATED (type
))
11041 if (TYPE_NAME (type
)
11042 && TREE_DEPRECATED (TYPE_NAME (type
)))
11045 /* Do warn about using typedefs to a deprecated class. */
11046 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11047 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11049 code
= TREE_CODE (type
);
11051 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11052 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11053 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11054 return type_is_deprecated (TREE_TYPE (type
));
11056 if (TYPE_PTRMEMFUNC_P (type
))
11057 return type_is_deprecated
11058 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11063 /* Decode the list of parameter types for a function type.
11064 Given the list of things declared inside the parens,
11065 return a list of types.
11067 If this parameter does not end with an ellipsis, we append
11070 *PARMS is set to the chain of PARM_DECLs created. */
11073 grokparms (tree parmlist
, tree
*parms
)
11075 tree result
= NULL_TREE
;
11076 tree decls
= NULL_TREE
;
11080 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11082 tree type
= NULL_TREE
;
11083 tree init
= TREE_PURPOSE (parm
);
11084 tree decl
= TREE_VALUE (parm
);
11085 const char *errmsg
;
11087 if (parm
== void_list_node
)
11090 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11093 type
= TREE_TYPE (decl
);
11094 if (VOID_TYPE_P (type
))
11096 if (same_type_p (type
, void_type_node
)
11097 && DECL_SELF_REFERENCE_P (type
)
11098 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
11099 /* this is a parmlist of `(void)', which is ok. */
11101 cxx_incomplete_type_error (decl
, type
);
11102 /* It's not a good idea to actually create parameters of
11103 type `void'; other parts of the compiler assume that a
11104 void type terminates the parameter list. */
11105 type
= error_mark_node
;
11106 TREE_TYPE (decl
) = error_mark_node
;
11109 if (type
!= error_mark_node
11110 && TYPE_FOR_JAVA (type
)
11111 && MAYBE_CLASS_TYPE_P (type
))
11113 error ("parameter %qD has Java class type", decl
);
11114 type
= error_mark_node
;
11115 TREE_TYPE (decl
) = error_mark_node
;
11119 if (type
!= error_mark_node
11120 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11123 type
= error_mark_node
;
11124 TREE_TYPE (decl
) = error_mark_node
;
11127 if (type
!= error_mark_node
)
11129 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11131 tree deptype
= type_is_deprecated (type
);
11133 warn_deprecated_use (deptype
, NULL_TREE
);
11136 /* Top-level qualifiers on the parameters are
11137 ignored for function types. */
11138 type
= cp_build_qualified_type (type
, 0);
11139 if (TREE_CODE (type
) == METHOD_TYPE
)
11141 error ("parameter %qD invalidly declared method type", decl
);
11142 type
= build_pointer_type (type
);
11143 TREE_TYPE (decl
) = type
;
11145 else if (abstract_virtuals_error (decl
, type
))
11146 any_error
= 1; /* Seems like a good idea. */
11147 else if (POINTER_TYPE_P (type
))
11149 /* [dcl.fct]/6, parameter types cannot contain pointers
11150 (references) to arrays of unknown bound. */
11151 tree t
= TREE_TYPE (type
);
11152 int ptr
= TYPE_PTR_P (type
);
11156 if (TYPE_PTR_P (t
))
11158 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11160 else if (!TYPE_DOMAIN (t
))
11164 if (TREE_CODE (t
) == ARRAY_TYPE
)
11166 ? G_("parameter %qD includes pointer to array of "
11167 "unknown bound %qT")
11168 : G_("parameter %qD includes reference to array of "
11169 "unknown bound %qT"),
11175 else if (init
&& !processing_template_decl
)
11176 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11179 DECL_CHAIN (decl
) = decls
;
11181 result
= tree_cons (init
, type
, result
);
11183 decls
= nreverse (decls
);
11184 result
= nreverse (result
);
11186 result
= chainon (result
, void_list_node
);
11193 /* D is a constructor or overloaded `operator='.
11195 Let T be the class in which D is declared. Then, this function
11198 -1 if D's is an ill-formed constructor or copy assignment operator
11199 whose first parameter is of type `T'.
11200 0 if D is not a copy constructor or copy assignment
11202 1 if D is a copy constructor or copy assignment operator whose
11203 first parameter is a reference to non-const qualified T.
11204 2 if D is a copy constructor or copy assignment operator whose
11205 first parameter is a reference to const qualified T.
11207 This function can be used as a predicate. Positive values indicate
11208 a copy constructor and nonzero values indicate a copy assignment
11212 copy_fn_p (const_tree d
)
11218 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11220 if (TREE_CODE (d
) == TEMPLATE_DECL
11221 || (DECL_TEMPLATE_INFO (d
)
11222 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11223 /* Instantiations of template member functions are never copy
11224 functions. Note that member functions of templated classes are
11225 represented as template functions internally, and we must
11226 accept those as copy functions. */
11229 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11233 arg_type
= TREE_VALUE (args
);
11234 if (arg_type
== error_mark_node
)
11237 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11239 /* Pass by value copy assignment operator. */
11242 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11243 && !TYPE_REF_IS_RVALUE (arg_type
)
11244 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11246 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11252 args
= TREE_CHAIN (args
);
11254 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11255 /* There are more non-optional args. */
11261 /* D is a constructor or overloaded `operator='.
11263 Let T be the class in which D is declared. Then, this function
11264 returns true when D is a move constructor or move assignment
11265 operator, false otherwise. */
11268 move_fn_p (const_tree d
)
11270 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11272 if (cxx_dialect
== cxx98
)
11273 /* There are no move constructors if we are in C++98 mode. */
11276 if (TREE_CODE (d
) == TEMPLATE_DECL
11277 || (DECL_TEMPLATE_INFO (d
)
11278 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11279 /* Instantiations of template member functions are never move
11280 functions. Note that member functions of templated classes are
11281 represented as template functions internally, and we must
11282 accept those as move functions. */
11285 return move_signature_fn_p (d
);
11288 /* D is a constructor or overloaded `operator='.
11290 Then, this function returns true when D has the same signature as a move
11291 constructor or move assignment operator (because either it is such a
11292 ctor/op= or it is a template specialization with the same signature),
11293 false otherwise. */
11296 move_signature_fn_p (const_tree d
)
11300 bool result
= false;
11302 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11306 arg_type
= TREE_VALUE (args
);
11307 if (arg_type
== error_mark_node
)
11310 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11311 && TYPE_REF_IS_RVALUE (arg_type
)
11312 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11316 args
= TREE_CHAIN (args
);
11318 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11319 /* There are more non-optional args. */
11325 /* Remember any special properties of member function DECL. */
11328 grok_special_member_properties (tree decl
)
11332 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11335 class_type
= DECL_CONTEXT (decl
);
11336 if (DECL_CONSTRUCTOR_P (decl
))
11338 int ctor
= copy_fn_p (decl
);
11340 if (!DECL_ARTIFICIAL (decl
))
11341 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11347 A non-template constructor for class X is a copy
11348 constructor if its first parameter is of type X&, const
11349 X&, volatile X& or const volatile X&, and either there
11350 are no other parameters or else all other parameters have
11351 default arguments. */
11352 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11353 if (user_provided_p (decl
))
11354 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11356 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11358 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11360 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11361 if (user_provided_p (decl
))
11362 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
11364 else if (move_fn_p (decl
) && user_provided_p (decl
))
11365 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11366 else if (is_list_ctor (decl
))
11367 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11369 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11370 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11371 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11373 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11377 A non-template assignment operator for class X is a copy
11378 assignment operator if its parameter is of type X, X&, const
11379 X&, volatile X& or const volatile X&. */
11381 int assop
= copy_fn_p (decl
);
11385 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11386 if (user_provided_p (decl
))
11387 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11389 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11391 else if (move_fn_p (decl
) && user_provided_p (decl
))
11392 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11394 /* Destructors are handled in check_methods. */
11397 /* Check a constructor DECL has the correct form. Complains
11398 if the class has a constructor of the form X(X). */
11401 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11403 int ctor_parm
= copy_fn_p (decl
);
11409 A declaration of a constructor for a class X is ill-formed if
11410 its first parameter is of type (optionally cv-qualified) X
11411 and either there are no other parameters or else all other
11412 parameters have default arguments.
11414 We *don't* complain about member template instantiations that
11415 have this form, though; they can occur as we try to decide
11416 what constructor to use during overload resolution. Since
11417 overload resolution will never prefer such a constructor to
11418 the non-template copy constructor (which is either explicitly
11419 or implicitly defined), there's no need to worry about their
11420 existence. Theoretically, they should never even be
11421 instantiated, but that's hard to forestall. */
11422 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11430 /* An operator with this code is unary, but can also be binary. */
11433 ambi_op_p (enum tree_code code
)
11435 return (code
== INDIRECT_REF
11436 || code
== ADDR_EXPR
11437 || code
== UNARY_PLUS_EXPR
11438 || code
== NEGATE_EXPR
11439 || code
== PREINCREMENT_EXPR
11440 || code
== PREDECREMENT_EXPR
);
11443 /* An operator with this name can only be unary. */
11446 unary_op_p (enum tree_code code
)
11448 return (code
== TRUTH_NOT_EXPR
11449 || code
== BIT_NOT_EXPR
11450 || code
== COMPONENT_REF
11451 || code
== TYPE_EXPR
);
11454 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11455 errors are issued for invalid declarations. */
11458 grok_op_properties (tree decl
, bool complain
)
11460 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11462 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11463 tree name
= DECL_NAME (decl
);
11464 enum tree_code operator_code
;
11469 /* Count the number of arguments and check for ellipsis. */
11470 for (argtype
= argtypes
, arity
= 0;
11471 argtype
&& argtype
!= void_list_node
;
11472 argtype
= TREE_CHAIN (argtype
))
11474 ellipsis_p
= !argtype
;
11476 class_type
= DECL_CONTEXT (decl
);
11477 if (class_type
&& !CLASS_TYPE_P (class_type
))
11478 class_type
= NULL_TREE
;
11480 if (DECL_CONV_FN_P (decl
))
11481 operator_code
= TYPE_EXPR
;
11485 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11486 if (ansi_opname (CODE) == name) \
11488 operator_code = (CODE); \
11491 else if (ansi_assopname (CODE) == name) \
11493 operator_code = (CODE); \
11494 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11498 #include "operators.def"
11499 #undef DEF_OPERATOR
11501 gcc_unreachable ();
11504 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11505 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11508 switch (operator_code
)
11511 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11515 TYPE_GETS_DELETE (class_type
) |= 1;
11519 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11522 case VEC_DELETE_EXPR
:
11523 TYPE_GETS_DELETE (class_type
) |= 2;
11530 /* [basic.std.dynamic.allocation]/1:
11532 A program is ill-formed if an allocation function is declared
11533 in a namespace scope other than global scope or declared static
11536 The same also holds true for deallocation functions. */
11537 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11538 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11540 if (DECL_NAMESPACE_SCOPE_P (decl
))
11542 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11544 error ("%qD may not be declared within a namespace", decl
);
11547 else if (!TREE_PUBLIC (decl
))
11549 error ("%qD may not be declared as static", decl
);
11555 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11557 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11558 DECL_IS_OPERATOR_NEW (decl
) = 1;
11560 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11561 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11564 /* An operator function must either be a non-static member function
11565 or have at least one parameter of a class, a reference to a class,
11566 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11567 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11569 if (operator_code
== TYPE_EXPR
11570 || operator_code
== CALL_EXPR
11571 || operator_code
== COMPONENT_REF
11572 || operator_code
== ARRAY_REF
11573 || operator_code
== NOP_EXPR
)
11575 error ("%qD must be a nonstatic member function", decl
);
11582 if (DECL_STATIC_FUNCTION_P (decl
))
11584 error ("%qD must be either a non-static member "
11585 "function or a non-member function", decl
);
11589 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11591 tree arg
= non_reference (TREE_VALUE (p
));
11592 if (arg
== error_mark_node
)
11595 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11596 because these checks are performed even on
11597 template functions. */
11598 if (MAYBE_CLASS_TYPE_P (arg
)
11599 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11603 if (!p
|| p
== void_list_node
)
11606 error ("%qD must have an argument of class or "
11607 "enumerated type", decl
);
11613 /* There are no restrictions on the arguments to an overloaded
11615 if (operator_code
== CALL_EXPR
)
11618 /* Warn about conversion operators that will never be used. */
11619 if (IDENTIFIER_TYPENAME_P (name
)
11620 && ! DECL_TEMPLATE_INFO (decl
)
11622 /* Warn only declaring the function; there is no need to
11623 warn again about out-of-class definitions. */
11624 && class_type
== current_class_type
)
11626 tree t
= TREE_TYPE (name
);
11627 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11630 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11632 if (VOID_TYPE_P (t
))
11633 warning (OPT_Wconversion
,
11635 ? G_("conversion to a reference to void "
11636 "will never use a type conversion operator")
11637 : G_("conversion to void "
11638 "will never use a type conversion operator"));
11639 else if (class_type
)
11641 if (t
== class_type
)
11642 warning (OPT_Wconversion
,
11644 ? G_("conversion to a reference to the same type "
11645 "will never use a type conversion operator")
11646 : G_("conversion to the same type "
11647 "will never use a type conversion operator"));
11648 /* Don't force t to be complete here. */
11649 else if (MAYBE_CLASS_TYPE_P (t
)
11650 && COMPLETE_TYPE_P (t
)
11651 && DERIVED_FROM_P (t
, class_type
))
11652 warning (OPT_Wconversion
,
11654 ? G_("conversion to a reference to a base class "
11655 "will never use a type conversion operator")
11656 : G_("conversion to a base class "
11657 "will never use a type conversion operator"));
11662 if (operator_code
== COND_EXPR
)
11665 error ("ISO C++ prohibits overloading operator ?:");
11668 else if (ellipsis_p
)
11670 error ("%qD must not have variable number of arguments", decl
);
11673 else if (ambi_op_p (operator_code
))
11676 /* We pick the one-argument operator codes by default, so
11677 we don't have to change anything. */
11679 else if (arity
== 2)
11681 /* If we thought this was a unary operator, we now know
11682 it to be a binary operator. */
11683 switch (operator_code
)
11686 operator_code
= MULT_EXPR
;
11690 operator_code
= BIT_AND_EXPR
;
11693 case UNARY_PLUS_EXPR
:
11694 operator_code
= PLUS_EXPR
;
11698 operator_code
= MINUS_EXPR
;
11701 case PREINCREMENT_EXPR
:
11702 operator_code
= POSTINCREMENT_EXPR
;
11705 case PREDECREMENT_EXPR
:
11706 operator_code
= POSTDECREMENT_EXPR
;
11710 gcc_unreachable ();
11713 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11715 if ((operator_code
== POSTINCREMENT_EXPR
11716 || operator_code
== POSTDECREMENT_EXPR
)
11717 && ! processing_template_decl
11718 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11721 error ("postfix %qD must take %<int%> as its argument",
11724 error ("postfix %qD must take %<int%> as its second "
11732 error ("%qD must take either zero or one argument", decl
);
11734 error ("%qD must take either one or two arguments", decl
);
11738 /* More Effective C++ rule 6. */
11740 && (operator_code
== POSTINCREMENT_EXPR
11741 || operator_code
== POSTDECREMENT_EXPR
11742 || operator_code
== PREINCREMENT_EXPR
11743 || operator_code
== PREDECREMENT_EXPR
))
11745 tree arg
= TREE_VALUE (argtypes
);
11746 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11747 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11748 arg
= TREE_TYPE (arg
);
11749 arg
= TYPE_MAIN_VARIANT (arg
);
11750 if (operator_code
== PREINCREMENT_EXPR
11751 || operator_code
== PREDECREMENT_EXPR
)
11753 if (TREE_CODE (ret
) != REFERENCE_TYPE
11754 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11756 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11757 build_reference_type (arg
));
11761 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11762 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11766 else if (unary_op_p (operator_code
))
11771 error ("%qD must take %<void%>", decl
);
11773 error ("%qD must take exactly one argument", decl
);
11777 else /* if (binary_op_p (operator_code)) */
11782 error ("%qD must take exactly one argument", decl
);
11784 error ("%qD must take exactly two arguments", decl
);
11788 /* More Effective C++ rule 7. */
11790 && (operator_code
== TRUTH_ANDIF_EXPR
11791 || operator_code
== TRUTH_ORIF_EXPR
11792 || operator_code
== COMPOUND_EXPR
))
11793 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11797 /* Effective C++ rule 23. */
11800 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11801 && (operator_code
== PLUS_EXPR
11802 || operator_code
== MINUS_EXPR
11803 || operator_code
== TRUNC_DIV_EXPR
11804 || operator_code
== MULT_EXPR
11805 || operator_code
== TRUNC_MOD_EXPR
)
11806 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11807 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11809 /* [over.oper]/8 */
11810 for (; argtypes
&& argtypes
!= void_list_node
;
11811 argtypes
= TREE_CHAIN (argtypes
))
11812 if (TREE_PURPOSE (argtypes
))
11814 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11815 if (operator_code
== POSTINCREMENT_EXPR
11816 || operator_code
== POSTDECREMENT_EXPR
)
11818 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
11823 error ("%qD cannot have default arguments", decl
);
11831 /* Return a string giving the keyword associate with CODE. */
11833 static const char *
11834 tag_name (enum tag_types code
)
11846 case typename_type
:
11849 gcc_unreachable ();
11853 /* Name lookup in an elaborated-type-specifier (after the keyword
11854 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11855 elaborated-type-specifier is invalid, issue a diagnostic and return
11856 error_mark_node; otherwise, return the *_TYPE to which it referred.
11857 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11860 check_elaborated_type_specifier (enum tag_types tag_code
,
11862 bool allow_template_p
)
11868 struct S { struct S *p; };
11870 name lookup will find the TYPE_DECL for the implicit "S::S"
11871 typedef. Adjust for that here. */
11872 if (DECL_SELF_REFERENCE_P (decl
))
11873 decl
= TYPE_NAME (TREE_TYPE (decl
));
11875 type
= TREE_TYPE (decl
);
11877 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11878 is false for this case as well. */
11879 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11881 error ("using template type parameter %qT after %qs",
11882 type
, tag_name (tag_code
));
11883 return error_mark_node
;
11885 /* Accept template template parameters. */
11886 else if (allow_template_p
11887 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
11888 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
11892 If the identifier resolves to a typedef-name or the
11893 simple-template-id resolves to an alias template
11894 specialization, the elaborated-type-specifier is ill-formed.
11896 In other words, the only legitimate declaration to use in the
11897 elaborated type specifier is the implicit typedef created when
11898 the type is declared. */
11899 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
11900 && !DECL_SELF_REFERENCE_P (decl
)
11901 && tag_code
!= typename_type
)
11903 if (alias_template_specialization_p (type
))
11904 error ("using alias template specialization %qT after %qs",
11905 type
, tag_name (tag_code
));
11907 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
11908 inform (DECL_SOURCE_LOCATION (decl
),
11909 "%qD has a previous declaration here", decl
);
11910 return error_mark_node
;
11912 else if (TREE_CODE (type
) != RECORD_TYPE
11913 && TREE_CODE (type
) != UNION_TYPE
11914 && tag_code
!= enum_type
11915 && tag_code
!= typename_type
)
11917 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
11918 inform (input_location
, "%q+T has a previous declaration here", type
);
11919 return error_mark_node
;
11921 else if (TREE_CODE (type
) != ENUMERAL_TYPE
11922 && tag_code
== enum_type
)
11924 error ("%qT referred to as enum", type
);
11925 inform (input_location
, "%q+T has a previous declaration here", type
);
11926 return error_mark_node
;
11928 else if (!allow_template_p
11929 && TREE_CODE (type
) == RECORD_TYPE
11930 && CLASSTYPE_IS_TEMPLATE (type
))
11932 /* If a class template appears as elaborated type specifier
11933 without a template header such as:
11935 template <class T> class C {};
11936 void f(class C); // No template header here
11938 then the required template argument is missing. */
11939 error ("template argument required for %<%s %T%>",
11940 tag_name (tag_code
),
11941 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
11942 return error_mark_node
;
11948 /* Lookup NAME in elaborate type specifier in scope according to
11949 SCOPE and issue diagnostics if necessary.
11950 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11951 found, and ERROR_MARK_NODE for type error. */
11954 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
11955 tag_scope scope
, bool template_header_p
)
11959 if (scope
== ts_global
)
11961 /* First try ordinary name lookup, ignoring hidden class name
11962 injected via friend declaration. */
11963 decl
= lookup_name_prefer_type (name
, 2);
11964 /* If that fails, the name will be placed in the smallest
11965 non-class, non-function-prototype scope according to 3.3.1/5.
11966 We may already have a hidden name declared as friend in this
11967 scope. So lookup again but not ignoring hidden names.
11968 If we find one, that name will be made visible rather than
11969 creating a new tag. */
11971 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
11974 decl
= lookup_type_scope (name
, scope
);
11977 && (DECL_CLASS_TEMPLATE_P (decl
)
11978 /* If scope is ts_current we're defining a class, so ignore a
11979 template template parameter. */
11980 || (scope
!= ts_current
11981 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
11982 decl
= DECL_TEMPLATE_RESULT (decl
);
11984 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
11986 /* Look for invalid nested type:
11990 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
11992 error ("%qD has the same name as the class in which it is "
11995 return error_mark_node
;
11998 /* Two cases we need to consider when deciding if a class
11999 template is allowed as an elaborated type specifier:
12000 1. It is a self reference to its own class.
12001 2. It comes with a template header.
12005 template <class T> class C {
12006 class C *c1; // DECL_SELF_REFERENCE_P is true
12009 template <class U> class C; // template_header_p is true
12010 template <class T> class C<T>::D {
12011 class C *c2; // DECL_SELF_REFERENCE_P is true
12014 t
= check_elaborated_type_specifier (tag_code
,
12017 | DECL_SELF_REFERENCE_P (decl
));
12020 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12022 error ("reference to %qD is ambiguous", name
);
12023 print_candidates (decl
);
12024 return error_mark_node
;
12030 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12031 Define the tag as a forward-reference if it is not defined.
12033 If a declaration is given, process it here, and report an error if
12034 multiple declarations are not identical.
12036 SCOPE is TS_CURRENT when this is also a definition. Only look in
12037 the current frame for the name (since C++ allows new names in any
12038 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12039 declaration. Only look beginning from the current scope outward up
12040 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12042 TEMPLATE_HEADER_P is true when this declaration is preceded by
12043 a set of template parameters. */
12046 xref_tag_1 (enum tag_types tag_code
, tree name
,
12047 tag_scope orig_scope
, bool template_header_p
)
12049 enum tree_code code
;
12051 tree context
= NULL_TREE
;
12054 gcc_assert (identifier_p (name
));
12060 code
= RECORD_TYPE
;
12066 code
= ENUMERAL_TYPE
;
12069 gcc_unreachable ();
12072 if (orig_scope
== ts_lambda
)
12073 scope
= ts_current
;
12075 scope
= orig_scope
;
12077 /* In case of anonymous name, xref_tag is only called to
12078 make type node and push name. Name lookup is not required. */
12079 if (ANON_AGGRNAME_P (name
))
12082 t
= lookup_and_check_tag (tag_code
, name
,
12083 scope
, template_header_p
);
12085 if (t
== error_mark_node
)
12086 return error_mark_node
;
12088 if (scope
!= ts_current
&& t
&& current_class_type
12089 && template_class_depth (current_class_type
)
12090 && template_header_p
)
12092 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12095 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12096 definition of this tag. Since, in addition, we are currently
12097 processing a (member) template declaration of a template
12098 class, we must be very careful; consider:
12105 { template <class V>
12106 friend struct S1; };
12108 Here, the S2::S1 declaration should not be confused with the
12109 outer declaration. In particular, the inner version should
12110 have a template parameter of level 2, not level 1. This
12111 would be particularly important if the member declaration
12114 template <class V = U> friend struct S1;
12116 say, when we should tsubst into `U' when instantiating
12117 S2. On the other hand, when presented with:
12127 we must find the inner binding eventually. We
12128 accomplish this by making sure that the new type we
12129 create to represent this declaration has the right
12131 context
= TYPE_CONTEXT (t
);
12137 /* If no such tag is yet defined, create a forward-reference node
12138 and record it as the "definition".
12139 When a real declaration of this type is found,
12140 the forward-reference will be altered into a real type. */
12141 if (code
== ENUMERAL_TYPE
)
12143 error ("use of enum %q#D without previous declaration", name
);
12144 return error_mark_node
;
12148 t
= make_class_type (code
);
12149 TYPE_CONTEXT (t
) = context
;
12150 if (orig_scope
== ts_lambda
)
12151 /* Remember that we're declaring a lambda to avoid bogus errors
12152 in push_template_decl. */
12153 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12154 t
= pushtag (name
, t
, scope
);
12159 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12161 if (!redeclare_class_template (t
, current_template_parms
))
12162 return error_mark_node
;
12164 else if (!processing_template_decl
12165 && CLASS_TYPE_P (t
)
12166 && CLASSTYPE_IS_TEMPLATE (t
))
12168 error ("redeclaration of %qT as a non-template", t
);
12169 error ("previous declaration %q+D", t
);
12170 return error_mark_node
;
12173 /* Make injected friend class visible. */
12174 if (scope
!= ts_within_enclosing_non_class
12175 && hidden_name_p (TYPE_NAME (t
)))
12177 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12178 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12180 if (TYPE_TEMPLATE_INFO (t
))
12182 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12183 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12191 /* Wrapper for xref_tag_1. */
12194 xref_tag (enum tag_types tag_code
, tree name
,
12195 tag_scope scope
, bool template_header_p
)
12199 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12200 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12201 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12207 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12209 enum tag_types tag_kind
;
12211 if (TREE_CODE (old
) == RECORD_TYPE
)
12212 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12214 tag_kind
= union_type
;
12216 if (id
== NULL_TREE
)
12217 id
= TYPE_IDENTIFIER (old
);
12219 return xref_tag (tag_kind
, id
, scope
, false);
12222 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12223 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12224 access_* node, and the TREE_VALUE is the type of the base-class.
12225 Non-NULL TREE_TYPE indicates virtual inheritance.
12227 Returns true if the binfo hierarchy was successfully created,
12228 false if an error was detected. */
12231 xref_basetypes (tree ref
, tree base_list
)
12234 tree binfo
, base_binfo
;
12235 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12236 unsigned max_bases
= 0; /* Maximum direct bases. */
12238 tree default_access
;
12239 tree igo_prev
; /* Track Inheritance Graph Order. */
12241 if (ref
== error_mark_node
)
12244 /* The base of a derived class is private by default, all others are
12246 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12247 && CLASSTYPE_DECLARED_CLASS (ref
)
12248 ? access_private_node
: access_public_node
);
12250 /* First, make sure that any templates in base-classes are
12251 instantiated. This ensures that if we call ourselves recursively
12252 we do not get confused about which classes are marked and which
12254 basep
= &base_list
;
12257 tree basetype
= TREE_VALUE (*basep
);
12259 /* The dependent_type_p call below should really be dependent_scope_p
12260 so that we give a hard error about using an incomplete type as a
12261 base, but we allow it with a pedwarn for backward
12263 if (processing_template_decl
12264 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12265 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12266 if (!dependent_type_p (basetype
)
12267 && !complete_type_or_else (basetype
, NULL
))
12268 /* An incomplete type. Remove it from the list. */
12269 *basep
= TREE_CHAIN (*basep
);
12273 if (TREE_TYPE (*basep
))
12275 if (CLASS_TYPE_P (basetype
))
12276 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12277 basep
= &TREE_CHAIN (*basep
);
12281 TYPE_MARKED_P (ref
) = 1;
12283 /* The binfo slot should be empty, unless this is an (ill-formed)
12285 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12287 error ("redefinition of %q#T", ref
);
12291 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12293 binfo
= make_tree_binfo (max_bases
);
12295 TYPE_BINFO (ref
) = binfo
;
12296 BINFO_OFFSET (binfo
) = size_zero_node
;
12297 BINFO_TYPE (binfo
) = ref
;
12299 /* Apply base-class info set up to the variants of this type. */
12300 fixup_type_variants (ref
);
12304 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12305 /* An aggregate cannot have baseclasses. */
12306 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12308 if (TREE_CODE (ref
) == UNION_TYPE
)
12310 error ("derived union %qT invalid", ref
);
12317 if (TYPE_FOR_JAVA (ref
))
12319 error ("Java class %qT cannot have multiple bases", ref
);
12326 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12328 if (TYPE_FOR_JAVA (ref
))
12330 error ("Java class %qT cannot have virtual bases", ref
);
12335 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12337 tree access
= TREE_PURPOSE (base_list
);
12338 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12339 tree basetype
= TREE_VALUE (base_list
);
12341 if (access
== access_default_node
)
12342 access
= default_access
;
12344 if (PACK_EXPANSION_P (basetype
))
12345 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12346 if (TREE_CODE (basetype
) == TYPE_DECL
)
12347 basetype
= TREE_TYPE (basetype
);
12348 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12350 error ("base type %qT fails to be a struct or class type",
12355 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12356 TYPE_FOR_JAVA (ref
) = 1;
12358 base_binfo
= NULL_TREE
;
12359 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12361 base_binfo
= TYPE_BINFO (basetype
);
12362 /* The original basetype could have been a typedef'd type. */
12363 basetype
= BINFO_TYPE (base_binfo
);
12365 /* Inherit flags from the base. */
12366 TYPE_HAS_NEW_OPERATOR (ref
)
12367 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12368 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12369 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12370 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12371 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12372 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12373 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12374 CLASSTYPE_REPEATED_BASE_P (ref
)
12375 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12378 /* We must do this test after we've seen through a typedef
12380 if (TYPE_MARKED_P (basetype
))
12382 if (basetype
== ref
)
12383 error ("recursive type %qT undefined", basetype
);
12385 error ("duplicate base type %qT invalid", basetype
);
12389 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12390 /* Regenerate the pack expansion for the bases. */
12391 basetype
= make_pack_expansion (basetype
);
12393 TYPE_MARKED_P (basetype
) = 1;
12395 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12396 &igo_prev
, via_virtual
);
12397 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12398 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12400 BINFO_BASE_APPEND (binfo
, base_binfo
);
12401 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12404 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12405 /* If we didn't get max_vbases vbases, we must have shared at
12406 least one of them, and are therefore diamond shaped. */
12407 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12409 /* Unmark all the types. */
12410 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12411 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12412 TYPE_MARKED_P (ref
) = 0;
12414 /* Now see if we have a repeated base type. */
12415 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12417 for (base_binfo
= binfo
; base_binfo
;
12418 base_binfo
= TREE_CHAIN (base_binfo
))
12420 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12422 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12425 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12427 for (base_binfo
= binfo
; base_binfo
;
12428 base_binfo
= TREE_CHAIN (base_binfo
))
12429 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12430 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12439 /* Copies the enum-related properties from type SRC to type DST.
12440 Used with the underlying type of an enum and the enum itself. */
12442 copy_type_enum (tree dst
, tree src
)
12445 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12447 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12448 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12449 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12450 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12451 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12452 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12453 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12454 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12455 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12459 /* Begin compiling the definition of an enumeration type.
12462 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12464 UNDERLYING_TYPE is the type that will be used as the storage for
12465 the enumeration type. This should be NULL_TREE if no storage type
12468 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12470 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12472 Returns the type object, as yet incomplete.
12473 Also records info about it so that build_enumerator
12474 may be used to declare the individual values as they are read. */
12477 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12478 bool scoped_enum_p
, bool *is_new
)
12480 tree prevtype
= NULL_TREE
;
12481 gcc_assert (identifier_p (name
));
12485 /* [C++0x dcl.enum]p5:
12487 If not explicitly specified, the underlying type of a scoped
12488 enumeration type is int. */
12489 if (!underlying_type
&& scoped_enum_p
)
12490 underlying_type
= integer_type_node
;
12492 if (underlying_type
)
12493 underlying_type
= cv_unqualified (underlying_type
);
12495 /* If this is the real definition for a previous forward reference,
12496 fill in the contents in the same object that used to be the
12497 forward reference. */
12499 enumtype
= lookup_and_check_tag (enum_type
, name
,
12500 /*tag_scope=*/ts_current
,
12501 /*template_header_p=*/false);
12503 /* In case of a template_decl, the only check that should be deferred
12504 to instantiation time is the comparison of underlying types. */
12505 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12507 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12509 error_at (input_location
, "scoped/unscoped mismatch "
12510 "in enum %q#T", enumtype
);
12511 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12512 "previous definition here");
12513 enumtype
= error_mark_node
;
12515 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12517 error_at (input_location
, "underlying type mismatch "
12518 "in enum %q#T", enumtype
);
12519 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12520 "previous definition here");
12521 enumtype
= error_mark_node
;
12523 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12524 && !dependent_type_p (underlying_type
)
12525 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12526 && !same_type_p (underlying_type
,
12527 ENUM_UNDERLYING_TYPE (enumtype
)))
12529 error_at (input_location
, "different underlying type "
12530 "in enum %q#T", enumtype
);
12531 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12532 "previous definition here");
12533 underlying_type
= NULL_TREE
;
12537 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12538 || processing_template_decl
)
12540 /* In case of error, make a dummy enum to allow parsing to
12542 if (enumtype
== error_mark_node
)
12544 name
= make_anon_name ();
12545 enumtype
= NULL_TREE
;
12548 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12549 of an opaque enum, or an opaque enum of an already defined
12550 enumeration (C++0x only).
12551 In any other case, it'll be NULL_TREE. */
12557 prevtype
= enumtype
;
12559 /* Do not push the decl more than once, unless we need to
12560 compare underlying types at instantiation time */
12562 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12563 || (underlying_type
12564 && dependent_type_p (underlying_type
))
12565 || (ENUM_UNDERLYING_TYPE (enumtype
)
12566 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12568 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12569 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12572 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12575 if (enumtype
== error_mark_node
)
12576 return error_mark_node
;
12578 /* The enum is considered opaque until the opening '{' of the
12579 enumerator list. */
12580 SET_OPAQUE_ENUM_P (enumtype
, true);
12581 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12584 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12586 if (underlying_type
)
12588 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12590 copy_type_enum (enumtype
, underlying_type
);
12591 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12593 else if (dependent_type_p (underlying_type
))
12594 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12596 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12597 underlying_type
, enumtype
);
12600 /* If into a template class, the returned enum is always the first
12601 declaration (opaque or not) seen. This way all the references to
12602 this type will be to the same declaration. The following ones are used
12603 only to check for definition errors. */
12604 if (prevtype
&& processing_template_decl
)
12610 /* After processing and defining all the values of an enumeration type,
12611 install their decls in the enumeration type.
12612 ENUMTYPE is the type object. */
12615 finish_enum_value_list (tree enumtype
)
12618 tree underlying_type
;
12621 tree minnode
, maxnode
;
12624 bool fixed_underlying_type_p
12625 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12627 /* We built up the VALUES in reverse order. */
12628 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12630 /* For an enum defined in a template, just set the type of the values;
12631 all further processing is postponed until the template is
12632 instantiated. We need to set the type so that tsubst of a CONST_DECL
12634 if (processing_template_decl
)
12636 for (values
= TYPE_VALUES (enumtype
);
12638 values
= TREE_CHAIN (values
))
12639 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12643 /* Determine the minimum and maximum values of the enumerators. */
12644 if (TYPE_VALUES (enumtype
))
12646 minnode
= maxnode
= NULL_TREE
;
12648 for (values
= TYPE_VALUES (enumtype
);
12650 values
= TREE_CHAIN (values
))
12652 decl
= TREE_VALUE (values
);
12654 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12655 each enumerator has the type of its enumeration. Prior to the
12656 closing brace, the type of each enumerator is the type of its
12657 initializing value. */
12658 TREE_TYPE (decl
) = enumtype
;
12660 /* Update the minimum and maximum values, if appropriate. */
12661 value
= DECL_INITIAL (decl
);
12662 if (value
== error_mark_node
)
12663 value
= integer_zero_node
;
12664 /* Figure out what the minimum and maximum values of the
12665 enumerators are. */
12667 minnode
= maxnode
= value
;
12668 else if (tree_int_cst_lt (maxnode
, value
))
12670 else if (tree_int_cst_lt (value
, minnode
))
12677 If the enumerator-list is empty, the underlying type is as if
12678 the enumeration had a single enumerator with value 0. */
12679 minnode
= maxnode
= integer_zero_node
;
12681 if (!fixed_underlying_type_p
)
12683 /* Compute the number of bits require to represent all values of the
12684 enumeration. We must do this before the type of MINNODE and
12685 MAXNODE are transformed, since tree_int_cst_min_precision relies
12686 on the TREE_TYPE of the value it is passed. */
12687 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
12688 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
12689 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
12690 int precision
= MAX (lowprec
, highprec
);
12692 bool use_short_enum
;
12694 /* Determine the underlying type of the enumeration.
12698 The underlying type of an enumeration is an integral type that
12699 can represent all the enumerator values defined in the
12700 enumeration. It is implementation-defined which integral type is
12701 used as the underlying type for an enumeration except that the
12702 underlying type shall not be larger than int unless the value of
12703 an enumerator cannot fit in an int or unsigned int.
12705 We use "int" or an "unsigned int" as the underlying type, even if
12706 a smaller integral type would work, unless the user has
12707 explicitly requested that we use the smallest possible type. The
12708 user can request that for all enumerations with a command line
12709 flag, or for just one enumeration with an attribute. */
12711 use_short_enum
= flag_short_enums
12712 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12714 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12718 underlying_type
= integer_types
[itk
];
12719 if (underlying_type
!= NULL_TREE
12720 && TYPE_PRECISION (underlying_type
) >= precision
12721 && TYPE_SIGN (underlying_type
) == sgn
)
12724 if (itk
== itk_none
)
12728 IF no integral type can represent all the enumerator values, the
12729 enumeration is ill-formed. */
12730 error ("no integral type can represent all of the enumerator values "
12731 "for %qT", enumtype
);
12732 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12733 underlying_type
= integer_types
[itk_unsigned_long_long
];
12738 The value of sizeof() applied to an enumeration type, an object
12739 of an enumeration type, or an enumerator, is the value of sizeof()
12740 applied to the underlying type. */
12741 copy_type_enum (enumtype
, underlying_type
);
12743 /* Compute the minimum and maximum values for the type.
12747 For an enumeration where emin is the smallest enumerator and emax
12748 is the largest, the values of the enumeration are the values of the
12749 underlying type in the range bmin to bmax, where bmin and bmax are,
12750 respectively, the smallest and largest values of the smallest bit-
12751 field that can store emin and emax. */
12753 /* The middle-end currently assumes that types with TYPE_PRECISION
12754 narrower than their underlying type are suitably zero or sign
12755 extended to fill their mode. Similarly, it assumes that the front
12756 end assures that a value of a particular type must be within
12757 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12759 We used to set these fields based on bmin and bmax, but that led
12760 to invalid assumptions like optimizing away bounds checking. So
12761 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12762 TYPE_MAX_VALUE to the values for the mode above and only restrict
12763 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12764 ENUM_UNDERLYING_TYPE (enumtype
)
12765 = build_distinct_type_copy (underlying_type
);
12766 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12767 set_min_and_max_values_for_integral_type
12768 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
12770 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12771 if (flag_strict_enums
)
12772 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
12775 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12777 /* Convert each of the enumerators to the type of the underlying
12778 type of the enumeration. */
12779 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12781 location_t saved_location
;
12783 decl
= TREE_VALUE (values
);
12784 saved_location
= input_location
;
12785 input_location
= DECL_SOURCE_LOCATION (decl
);
12786 if (fixed_underlying_type_p
)
12787 /* If the enumeration type has a fixed underlying type, we
12788 already checked all of the enumerator values. */
12789 value
= DECL_INITIAL (decl
);
12791 value
= perform_implicit_conversion (underlying_type
,
12792 DECL_INITIAL (decl
),
12793 tf_warning_or_error
);
12794 input_location
= saved_location
;
12796 /* Do not clobber shared ints. */
12797 value
= copy_node (value
);
12799 TREE_TYPE (value
) = enumtype
;
12800 DECL_INITIAL (decl
) = value
;
12803 /* Fix up all variant types of this enum type. */
12804 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12805 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12807 if (at_class_scope_p ()
12808 && COMPLETE_TYPE_P (current_class_type
)
12809 && UNSCOPED_ENUM_P (enumtype
))
12810 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
12811 current_class_type
);
12813 /* Finish debugging output for this type. */
12814 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12817 /* Finishes the enum type. This is called only the first time an
12818 enumeration is seen, be it opaque or odinary.
12819 ENUMTYPE is the type object. */
12822 finish_enum (tree enumtype
)
12824 if (processing_template_decl
)
12826 if (at_function_scope_p ())
12827 add_stmt (build_min (TAG_DEFN
, enumtype
));
12831 /* If this is a forward declaration, there should not be any variants,
12832 though we can get a variant in the middle of an enum-specifier with
12833 wacky code like 'enum E { e = sizeof(const E*) };' */
12834 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
12835 && (TYPE_VALUES (enumtype
)
12836 || !TYPE_NEXT_VARIANT (enumtype
)));
12839 /* Build and install a CONST_DECL for an enumeration constant of the
12840 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12841 LOC is the location of NAME.
12842 Assignment of sequential values by default is handled here. */
12845 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
12851 /* If the VALUE was erroneous, pretend it wasn't there; that will
12852 result in the enum being assigned the next value in sequence. */
12853 if (value
== error_mark_node
)
12856 /* Remove no-op casts from the value. */
12858 STRIP_TYPE_NOPS (value
);
12860 if (! processing_template_decl
)
12862 /* Validate and default VALUE. */
12863 if (value
!= NULL_TREE
)
12865 value
= cxx_constant_value (value
);
12867 if (TREE_CODE (value
) != INTEGER_CST
12868 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
12870 error ("enumerator value for %qD is not an integer constant",
12876 /* Default based on previous value. */
12877 if (value
== NULL_TREE
)
12879 if (TYPE_VALUES (enumtype
))
12884 /* C++03 7.2/4: If no initializer is specified for the first
12885 enumerator, the type is an unspecified integral
12886 type. Otherwise the type is the same as the type of the
12887 initializing value of the preceding enumerator unless the
12888 incremented value is not representable in that type, in
12889 which case the type is an unspecified integral type
12890 sufficient to contain the incremented value. */
12891 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12892 if (error_operand_p (prev_value
))
12893 value
= error_mark_node
;
12896 tree type
= TREE_TYPE (prev_value
);
12897 signop sgn
= TYPE_SIGN (type
);
12898 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
12902 bool pos
= !wi::neg_p (wi
, sgn
);
12903 if (!wi::fits_to_tree_p (wi
, type
))
12906 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
12908 type
= integer_types
[itk
];
12909 if (type
!= NULL_TREE
12910 && (pos
|| !TYPE_UNSIGNED (type
))
12911 && wi::fits_to_tree_p (wi
, type
))
12914 if (type
&& cxx_dialect
< cxx11
12915 && itk
> itk_unsigned_long
)
12916 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
12917 incremented enumerator value is too large for %<unsigned long%>" : "\
12918 incremented enumerator value is too large for %<long%>");
12920 if (type
== NULL_TREE
)
12923 value
= wide_int_to_tree (type
, wi
);
12928 error ("overflow in enumeration values at %qD", name
);
12929 value
= error_mark_node
;
12934 value
= integer_zero_node
;
12937 /* Remove no-op casts from the value. */
12938 STRIP_TYPE_NOPS (value
);
12940 /* If the underlying type of the enum is fixed, check whether
12941 the enumerator values fits in the underlying type. If it
12942 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12943 if (ENUM_UNDERLYING_TYPE (enumtype
)
12945 && TREE_CODE (value
) == INTEGER_CST
)
12947 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
12948 error ("enumerator value %E is outside the range of underlying "
12949 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
12951 /* Convert the value to the appropriate type. */
12952 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
12956 /* C++ associates enums with global, function, or class declarations. */
12957 context
= current_scope ();
12959 /* Build the actual enumeration constant. Note that the enumeration
12960 constants have the underlying type of the enum (if it is fixed)
12961 or the type of their initializer (if the underlying type of the
12962 enum is not fixed):
12966 If the underlying type is fixed, the type of each enumerator
12967 prior to the closing brace is the underlying type; if the
12968 initializing value of an enumerator cannot be represented by
12969 the underlying type, the program is ill-formed. If the
12970 underlying type is not fixed, the type of each enumerator is
12971 the type of its initializing value.
12973 If the underlying type is not fixed, it will be computed by
12974 finish_enum and we will reset the type of this enumerator. Of
12975 course, if we're processing a template, there may be no value. */
12976 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12978 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
12980 DECL_CONTEXT (decl
) = enumtype
;
12981 TREE_CONSTANT (decl
) = 1;
12982 TREE_READONLY (decl
) = 1;
12983 DECL_INITIAL (decl
) = value
;
12985 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
12986 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12987 on the TYPE_FIELDS list for `S'. (That's so that you can say
12988 things like `S::i' later.) */
12989 finish_member_declaration (decl
);
12993 /* Add this enumeration constant to the list for this type. */
12994 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12997 /* Look for an enumerator with the given NAME within the enumeration
12998 type ENUMTYPE. This routine is used primarily for qualified name
12999 lookup into an enumerator in C++0x, e.g.,
13001 enum class Color { Red, Green, Blue };
13003 Color color = Color::Red;
13005 Returns the value corresponding to the enumerator, or
13006 NULL_TREE if no such enumerator was found. */
13008 lookup_enumerator (tree enumtype
, tree name
)
13011 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13013 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13014 return e
? TREE_VALUE (e
) : NULL_TREE
;
13018 /* We're defining DECL. Make sure that its type is OK. */
13021 check_function_type (tree decl
, tree current_function_parms
)
13023 tree fntype
= TREE_TYPE (decl
);
13024 tree return_type
= complete_type (TREE_TYPE (fntype
));
13026 /* In a function definition, arg types must be complete. */
13027 require_complete_types_for_parms (current_function_parms
);
13029 if (dependent_type_p (return_type
)
13030 || type_uses_auto (return_type
))
13032 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13033 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13035 tree args
= TYPE_ARG_TYPES (fntype
);
13037 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13038 error ("return type %q#T is incomplete", return_type
);
13040 error ("return type has Java class type %q#T", return_type
);
13042 /* Make it return void instead. */
13043 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13044 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13046 TREE_CHAIN (args
));
13048 fntype
= build_function_type (void_type_node
, args
);
13050 = build_exception_variant (fntype
,
13051 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13052 fntype
= (cp_build_type_attribute_variant
13053 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13054 TREE_TYPE (decl
) = fntype
;
13057 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13060 /* Create the FUNCTION_DECL for a function definition.
13061 DECLSPECS and DECLARATOR are the parts of the declaration;
13062 they describe the function's name and the type it returns,
13063 but twisted together in a fashion that parallels the syntax of C.
13065 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13066 DECLARATOR is really the DECL for the function we are about to
13067 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13068 indicating that the function is an inline defined in-class.
13070 This function creates a binding context for the function body
13071 as well as setting up the FUNCTION_DECL in current_function_decl.
13073 For C++, we must first check whether that datum makes any sense.
13074 For example, "class A local_a(1,2);" means that variable local_a
13075 is an aggregate of type A, which should have a constructor
13076 applied to it with the argument list [1, 2].
13078 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13079 or may be a BLOCK if the function has been defined previously
13080 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13081 error_mark_node if the function has never been defined, or
13082 a BLOCK if the function has been defined somewhere. */
13085 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13087 tree ctype
= NULL_TREE
;
13090 int doing_friend
= 0;
13091 cp_binding_level
*bl
;
13092 tree current_function_parms
;
13093 struct c_fileinfo
*finfo
13094 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13095 bool honor_interface
;
13097 /* Sanity check. */
13098 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13099 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13101 fntype
= TREE_TYPE (decl1
);
13102 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13103 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13105 /* ISO C++ 11.4/5. A friend function defined in a class is in
13106 the (lexical) scope of the class in which it is defined. */
13107 if (!ctype
&& DECL_FRIEND_P (decl1
))
13109 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13111 /* CTYPE could be null here if we're dealing with a template;
13112 for example, `inline friend float foo()' inside a template
13113 will have no CTYPE set. */
13114 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13120 if (DECL_DECLARED_INLINE_P (decl1
)
13121 && lookup_attribute ("noinline", attrs
))
13122 warning (0, "inline function %q+D given attribute noinline", decl1
);
13124 /* Handle gnu_inline attribute. */
13125 if (GNU_INLINE_P (decl1
))
13127 DECL_EXTERNAL (decl1
) = 1;
13128 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13129 DECL_INTERFACE_KNOWN (decl1
) = 1;
13130 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13133 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13134 /* This is a constructor, we must ensure that any default args
13135 introduced by this definition are propagated to the clones
13136 now. The clones are used directly in overload resolution. */
13137 adjust_clone_args (decl1
);
13139 /* Sometimes we don't notice that a function is a static member, and
13140 build a METHOD_TYPE for it. Fix that up now. */
13141 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13142 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13144 /* Set up current_class_type, and enter the scope of the class, if
13147 push_nested_class (ctype
);
13148 else if (DECL_STATIC_FUNCTION_P (decl1
))
13149 push_nested_class (DECL_CONTEXT (decl1
));
13151 /* Now that we have entered the scope of the class, we must restore
13152 the bindings for any template parameters surrounding DECL1, if it
13153 is an inline member template. (Order is important; consider the
13154 case where a template parameter has the same name as a field of
13155 the class.) It is not until after this point that
13156 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13157 if (flags
& SF_INCLASS_INLINE
)
13158 maybe_begin_member_template_processing (decl1
);
13160 /* Effective C++ rule 15. */
13162 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13163 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13164 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13166 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13167 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13168 if (!DECL_INITIAL (decl1
))
13169 DECL_INITIAL (decl1
) = error_mark_node
;
13171 /* This function exists in static storage.
13172 (This does not mean `static' in the C sense!) */
13173 TREE_STATIC (decl1
) = 1;
13175 /* We must call push_template_decl after current_class_type is set
13176 up. (If we are processing inline definitions after exiting a
13177 class scope, current_class_type will be NULL_TREE until set above
13178 by push_nested_class.) */
13179 if (processing_template_decl
)
13181 tree newdecl1
= push_template_decl (decl1
);
13182 if (newdecl1
== error_mark_node
)
13184 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13185 pop_nested_class ();
13191 /* We are now in the scope of the function being defined. */
13192 current_function_decl
= decl1
;
13194 /* Save the parm names or decls from this function's declarator
13195 where store_parm_decls will find them. */
13196 current_function_parms
= DECL_ARGUMENTS (decl1
);
13198 /* Make sure the parameter and return types are reasonable. When
13199 you declare a function, these types can be incomplete, but they
13200 must be complete when you define the function. */
13201 check_function_type (decl1
, current_function_parms
);
13203 /* Build the return declaration for the function. */
13204 restype
= TREE_TYPE (fntype
);
13206 if (DECL_RESULT (decl1
) == NULL_TREE
)
13210 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13211 DECL_ARTIFICIAL (resdecl
) = 1;
13212 DECL_IGNORED_P (resdecl
) = 1;
13213 DECL_RESULT (decl1
) = resdecl
;
13215 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13218 /* Let the user know we're compiling this function. */
13219 announce_function (decl1
);
13221 /* Record the decl so that the function name is defined.
13222 If we already have a decl for this name, and it is a FUNCTION_DECL,
13223 use the old decl. */
13224 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13226 /* A specialization is not used to guide overload resolution. */
13227 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13228 && !(DECL_USE_TEMPLATE (decl1
) &&
13229 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13231 tree olddecl
= pushdecl (decl1
);
13233 if (olddecl
== error_mark_node
)
13234 /* If something went wrong when registering the declaration,
13235 use DECL1; we have to have a FUNCTION_DECL to use when
13236 parsing the body of the function. */
13240 /* Otherwise, OLDDECL is either a previous declaration
13241 of the same function or DECL1 itself. */
13243 if (warn_missing_declarations
13244 && olddecl
== decl1
13245 && !DECL_MAIN_P (decl1
)
13246 && TREE_PUBLIC (decl1
)
13247 && !DECL_DECLARED_INLINE_P (decl1
))
13251 /* Check whether DECL1 is in an anonymous
13253 for (context
= DECL_CONTEXT (decl1
);
13255 context
= DECL_CONTEXT (context
))
13257 if (TREE_CODE (context
) == NAMESPACE_DECL
13258 && DECL_NAME (context
) == NULL_TREE
)
13262 if (context
== NULL
)
13263 warning (OPT_Wmissing_declarations
,
13264 "no previous declaration for %q+D", decl1
);
13272 /* We need to set the DECL_CONTEXT. */
13273 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13274 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13276 fntype
= TREE_TYPE (decl1
);
13277 restype
= TREE_TYPE (fntype
);
13279 /* If #pragma weak applies, mark the decl appropriately now.
13280 The pragma only applies to global functions. Because
13281 determining whether or not the #pragma applies involves
13282 computing the mangled name for the declaration, we cannot
13283 apply the pragma until after we have merged this declaration
13284 with any previous declarations; if the original declaration
13285 has a linkage specification, that specification applies to
13286 the definition as well, and may affect the mangled name. */
13287 if (DECL_FILE_SCOPE_P (decl1
))
13288 maybe_apply_pragma_weak (decl1
);
13291 /* Reset this in case the call to pushdecl changed it. */
13292 current_function_decl
= decl1
;
13294 gcc_assert (DECL_INITIAL (decl1
));
13296 /* This function may already have been parsed, in which case just
13297 return; our caller will skip over the body without parsing. */
13298 if (DECL_INITIAL (decl1
) != error_mark_node
)
13301 /* Initialize RTL machinery. We cannot do this until
13302 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13303 even when processing a template; this is how we get
13304 CFUN set up, and our per-function variables initialized.
13305 FIXME factor out the non-RTL stuff. */
13306 bl
= current_binding_level
;
13307 allocate_struct_function (decl1
, processing_template_decl
);
13309 /* Initialize the language data structures. Whenever we start
13310 a new function, we destroy temporaries in the usual way. */
13311 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
13312 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13313 current_binding_level
= bl
;
13315 if (!processing_template_decl
&& type_uses_auto (restype
))
13317 FNDECL_USED_AUTO (decl1
) = true;
13318 current_function_auto_return_pattern
= restype
;
13321 /* Start the statement-tree, start the tree now. */
13322 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13324 /* If we are (erroneously) defining a function that we have already
13325 defined before, wipe out what we knew before. */
13326 if (!DECL_PENDING_INLINE_P (decl1
))
13327 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13329 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13331 /* We know that this was set up by `grokclassfn'. We do not
13332 wait until `store_parm_decls', since evil parse errors may
13333 never get us to that point. Here we keep the consistency
13334 between `current_class_type' and `current_class_ptr'. */
13335 tree t
= DECL_ARGUMENTS (decl1
);
13337 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13338 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13340 cp_function_chain
->x_current_class_ref
13341 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13342 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13343 cp_function_chain
->x_current_class_ptr
= t
;
13345 /* Constructors and destructors need to know whether they're "in
13346 charge" of initializing virtual base classes. */
13347 t
= DECL_CHAIN (t
);
13348 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13350 current_in_charge_parm
= t
;
13351 t
= DECL_CHAIN (t
);
13353 if (DECL_HAS_VTT_PARM_P (decl1
))
13355 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13356 current_vtt_parm
= t
;
13360 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13361 /* Implicitly-defined methods (like the
13362 destructor for a class in which no destructor
13363 is explicitly declared) must not be defined
13364 until their definition is needed. So, we
13365 ignore interface specifications for
13366 compiler-generated functions. */
13367 && !DECL_ARTIFICIAL (decl1
));
13369 if (processing_template_decl
)
13370 /* Don't mess with interface flags. */;
13371 else if (DECL_INTERFACE_KNOWN (decl1
))
13373 tree ctx
= decl_function_context (decl1
);
13375 if (DECL_NOT_REALLY_EXTERN (decl1
))
13376 DECL_EXTERNAL (decl1
) = 0;
13378 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13379 /* This is a function in a local class in an extern inline
13380 or template function. */
13381 comdat_linkage (decl1
);
13383 /* If this function belongs to an interface, it is public.
13384 If it belongs to someone else's interface, it is also external.
13385 This only affects inlines and template instantiations. */
13386 else if (!finfo
->interface_unknown
&& honor_interface
)
13388 if (DECL_DECLARED_INLINE_P (decl1
)
13389 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13391 DECL_EXTERNAL (decl1
)
13392 = (finfo
->interface_only
13393 || (DECL_DECLARED_INLINE_P (decl1
)
13394 && ! flag_implement_inlines
13395 && !DECL_VINDEX (decl1
)));
13397 /* For WIN32 we also want to put these in linkonce sections. */
13398 maybe_make_one_only (decl1
);
13401 DECL_EXTERNAL (decl1
) = 0;
13402 DECL_INTERFACE_KNOWN (decl1
) = 1;
13403 /* If this function is in an interface implemented in this file,
13404 make sure that the back end knows to emit this function
13406 if (!DECL_EXTERNAL (decl1
))
13407 mark_needed (decl1
);
13409 else if (finfo
->interface_unknown
&& finfo
->interface_only
13410 && honor_interface
)
13412 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13413 interface, we will have both finfo->interface_unknown and
13414 finfo->interface_only set. In that case, we don't want to
13415 use the normal heuristics because someone will supply a
13416 #pragma implementation elsewhere, and deducing it here would
13417 produce a conflict. */
13418 comdat_linkage (decl1
);
13419 DECL_EXTERNAL (decl1
) = 0;
13420 DECL_INTERFACE_KNOWN (decl1
) = 1;
13421 DECL_DEFER_OUTPUT (decl1
) = 1;
13425 /* This is a definition, not a reference.
13426 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13427 if (!GNU_INLINE_P (decl1
))
13428 DECL_EXTERNAL (decl1
) = 0;
13430 if ((DECL_DECLARED_INLINE_P (decl1
)
13431 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13432 && ! DECL_INTERFACE_KNOWN (decl1
))
13433 DECL_DEFER_OUTPUT (decl1
) = 1;
13435 DECL_INTERFACE_KNOWN (decl1
) = 1;
13438 /* Determine the ELF visibility attribute for the function. We must not
13439 do this before calling "pushdecl", as we must allow "duplicate_decls"
13440 to merge any attributes appropriately. We also need to wait until
13442 if (!DECL_CLONED_FUNCTION_P (decl1
))
13443 determine_visibility (decl1
);
13445 if (!processing_template_decl
)
13446 maybe_instantiate_noexcept (decl1
);
13448 begin_scope (sk_function_parms
, decl1
);
13452 if (DECL_DESTRUCTOR_P (decl1
)
13453 || (DECL_CONSTRUCTOR_P (decl1
)
13454 && targetm
.cxx
.cdtor_returns_this ()))
13456 cdtor_label
= build_decl (input_location
,
13457 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13458 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13461 start_fname_decls ();
13463 store_parm_decls (current_function_parms
);
13469 /* Like start_preparsed_function, except that instead of a
13470 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13472 Returns true on success. If the DECLARATOR is not suitable
13473 for a function, we return false, which tells the parser to
13474 skip the entire function. */
13477 start_function (cp_decl_specifier_seq
*declspecs
,
13478 const cp_declarator
*declarator
,
13483 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13484 if (decl1
== error_mark_node
)
13486 /* If the declarator is not suitable for a function definition,
13487 cause a syntax error. */
13488 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13490 error ("invalid function declaration");
13494 if (DECL_MAIN_P (decl1
))
13495 /* main must return int. grokfndecl should have corrected it
13496 (and issued a diagnostic) if the user got it wrong. */
13497 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13498 integer_type_node
));
13500 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13503 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13507 use_eh_spec_block (tree fn
)
13509 return (flag_exceptions
&& flag_enforce_eh_specs
13510 && !processing_template_decl
13511 && !type_throw_all_p (TREE_TYPE (fn
))
13512 /* We insert the EH_SPEC_BLOCK only in the original
13513 function; then, it is copied automatically to the
13515 && !DECL_CLONED_FUNCTION_P (fn
)
13516 /* Implicitly-generated constructors and destructors have
13517 exception specifications. However, those specifications
13518 are the union of the possible exceptions specified by the
13519 constructors/destructors for bases and members, so no
13520 unallowed exception will ever reach this function. By
13521 not creating the EH_SPEC_BLOCK we save a little memory,
13522 and we avoid spurious warnings about unreachable
13524 && !DECL_DEFAULTED_FN (fn
));
13527 /* Store the parameter declarations into the current function declaration.
13528 This is called after parsing the parameter declarations, before
13529 digesting the body of the function.
13531 Also install to binding contour return value identifier, if any. */
13534 store_parm_decls (tree current_function_parms
)
13536 tree fndecl
= current_function_decl
;
13539 /* This is a chain of any other decls that came in among the parm
13540 declarations. If a parm is declared with enum {foo, bar} x;
13541 then CONST_DECLs for foo and bar are put here. */
13542 tree nonparms
= NULL_TREE
;
13544 if (current_function_parms
)
13546 /* This case is when the function was defined with an ANSI prototype.
13547 The parms already have decls, so we need not do anything here
13548 except record them as in effect
13549 and complain if any redundant old-style parm decls were written. */
13551 tree specparms
= current_function_parms
;
13554 /* Must clear this because it might contain TYPE_DECLs declared
13556 current_binding_level
->names
= NULL
;
13558 /* If we're doing semantic analysis, then we'll call pushdecl
13559 for each of these. We must do them in reverse order so that
13560 they end in the correct forward order. */
13561 specparms
= nreverse (specparms
);
13563 for (parm
= specparms
; parm
; parm
= next
)
13565 next
= DECL_CHAIN (parm
);
13566 if (TREE_CODE (parm
) == PARM_DECL
)
13568 if (DECL_NAME (parm
) == NULL_TREE
13569 || !VOID_TYPE_P (parm
))
13572 error ("parameter %qD declared void", parm
);
13576 /* If we find an enum constant or a type tag,
13577 put it aside for the moment. */
13578 TREE_CHAIN (parm
) = NULL_TREE
;
13579 nonparms
= chainon (nonparms
, parm
);
13583 /* Get the decls in their original chain order and record in the
13584 function. This is all and only the PARM_DECLs that were
13585 pushed into scope by the loop above. */
13586 DECL_ARGUMENTS (fndecl
) = getdecls ();
13589 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13591 /* Now store the final chain of decls for the arguments
13592 as the decl-chain of the current lexical scope.
13593 Put the enumerators in as well, at the front so that
13594 DECL_ARGUMENTS is not modified. */
13595 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13597 if (use_eh_spec_block (current_function_decl
))
13598 current_eh_spec_block
= begin_eh_spec_block ();
13602 /* We have finished doing semantic analysis on DECL, but have not yet
13603 generated RTL for its body. Save away our current state, so that
13604 when we want to generate RTL later we know what to do. */
13607 save_function_data (tree decl
)
13609 struct language_function
*f
;
13611 /* Save the language-specific per-function data so that we can
13612 get it back when we really expand this function. */
13613 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13616 f
= ggc_alloc
<language_function
> ();
13617 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13618 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13620 /* Clear out the bits we don't need. */
13621 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13622 f
->bindings
= NULL
;
13623 f
->x_local_names
= NULL
;
13624 f
->base
.local_typedefs
= NULL
;
13628 /* Set the return value of the constructor (if present). */
13631 finish_constructor_body (void)
13636 if (targetm
.cxx
.cdtor_returns_this ()
13637 && (! TYPE_FOR_JAVA (current_class_type
)))
13639 /* Any return from a constructor will end up here. */
13640 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13642 val
= DECL_ARGUMENTS (current_function_decl
);
13643 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13644 DECL_RESULT (current_function_decl
), val
);
13645 /* Return the address of the object. */
13646 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13647 add_stmt (exprstmt
);
13651 /* Do all the processing for the beginning of a destructor; set up the
13652 vtable pointers and cleanups for bases and members. */
13655 begin_destructor_body (void)
13657 tree compound_stmt
;
13659 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13660 issued an error message. We still want to try to process the
13661 body of the function, but initialize_vtbl_ptrs will crash if
13662 TYPE_BINFO is NULL. */
13663 if (COMPLETE_TYPE_P (current_class_type
))
13665 compound_stmt
= begin_compound_stmt (0);
13666 /* Make all virtual function table pointers in non-virtual base
13667 classes point to CURRENT_CLASS_TYPE's virtual function
13669 initialize_vtbl_ptrs (current_class_ptr
);
13670 finish_compound_stmt (compound_stmt
);
13672 /* Insert a cleanup to let the back end know that the object is dead
13673 when we exit the destructor, either normally or via exception. */
13674 tree clobber
= build_constructor (current_class_type
, NULL
);
13675 TREE_THIS_VOLATILE (clobber
) = true;
13676 tree exprstmt
= build2 (MODIFY_EXPR
, current_class_type
,
13677 current_class_ref
, clobber
);
13678 finish_decl_cleanup (NULL_TREE
, exprstmt
);
13680 /* And insert cleanups for our bases and members so that they
13681 will be properly destroyed if we throw. */
13682 push_base_cleanups ();
13686 /* At the end of every destructor we generate code to delete the object if
13687 necessary. Do that now. */
13690 finish_destructor_body (void)
13694 /* Any return from a destructor will end up here; that way all base
13695 and member cleanups will be run when the function returns. */
13696 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13698 /* In a virtual destructor, we must call delete. */
13699 if (DECL_VIRTUAL_P (current_function_decl
))
13702 tree virtual_size
= cxx_sizeof (current_class_type
);
13706 At the point of definition of a virtual destructor (including
13707 an implicit definition), non-placement operator delete shall
13708 be looked up in the scope of the destructor's class and if
13709 found shall be accessible and unambiguous. */
13710 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13712 /*global_p=*/false,
13713 /*placement=*/NULL_TREE
,
13714 /*alloc_fn=*/NULL_TREE
,
13715 tf_warning_or_error
);
13717 if_stmt
= begin_if_stmt ();
13718 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13719 current_in_charge_parm
,
13722 finish_expr_stmt (exprstmt
);
13723 finish_then_clause (if_stmt
);
13724 finish_if_stmt (if_stmt
);
13727 if (targetm
.cxx
.cdtor_returns_this ())
13731 val
= DECL_ARGUMENTS (current_function_decl
);
13732 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13733 DECL_RESULT (current_function_decl
), val
);
13734 /* Return the address of the object. */
13735 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13736 add_stmt (exprstmt
);
13740 /* Do the necessary processing for the beginning of a function body, which
13741 in this case includes member-initializers, but not the catch clauses of
13742 a function-try-block. Currently, this means opening a binding level
13743 for the member-initializers (in a ctor), member cleanups (in a dtor),
13744 and capture proxies (in a lambda operator()). */
13747 begin_function_body (void)
13751 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13754 if (processing_template_decl
)
13755 /* Do nothing now. */;
13757 /* Always keep the BLOCK node associated with the outermost pair of
13758 curly braces of a function. These are needed for correct
13759 operation of dwarfout.c. */
13760 keep_next_level (true);
13762 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13764 if (processing_template_decl
)
13765 /* Do nothing now. */;
13766 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13767 begin_destructor_body ();
13772 /* Do the processing for the end of a function body. Currently, this means
13773 closing out the cleanups for fully-constructed bases and members, and in
13774 the case of the destructor, deleting the object if desired. Again, this
13775 is only meaningful for [cd]tors, since they are the only functions where
13776 there is a significant distinction between the main body and any
13777 function catch clauses. Handling, say, main() return semantics here
13778 would be wrong, as flowing off the end of a function catch clause for
13779 main() would also need to return 0. */
13782 finish_function_body (tree compstmt
)
13784 if (compstmt
== NULL_TREE
)
13787 /* Close the block. */
13788 finish_compound_stmt (compstmt
);
13790 if (processing_template_decl
)
13791 /* Do nothing now. */;
13792 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
13793 finish_constructor_body ();
13794 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13795 finish_destructor_body ();
13798 /* Given a function, returns the BLOCK corresponding to the outermost level
13799 of curly braces, skipping the artificial block created for constructor
13803 outer_curly_brace_block (tree fndecl
)
13805 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
13806 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13807 /* Skip the artificial function body block. */
13808 block
= BLOCK_SUBBLOCKS (block
);
13812 /* If FNDECL is a class's key method, add the class to the list of
13813 keyed classes that should be emitted. */
13816 record_key_method_defined (tree fndecl
)
13818 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
13819 && DECL_VIRTUAL_P (fndecl
)
13820 && !processing_template_decl
)
13822 tree fnclass
= DECL_CONTEXT (fndecl
);
13823 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
13824 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
13828 /* Subroutine of finish_function.
13829 Save the body of constexpr functions for possible
13830 future compile time evaluation. */
13833 maybe_save_function_definition (tree fun
)
13835 if (!processing_template_decl
13836 && DECL_DECLARED_CONSTEXPR_P (fun
)
13837 && !DECL_CLONED_FUNCTION_P (fun
))
13838 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
13841 /* Finish up a function declaration and compile that function
13842 all the way to assembler language output. The free the storage
13843 for the function definition.
13845 FLAGS is a bitwise or of the following values:
13847 We just finished processing the body of an in-class inline
13848 function definition. (This processing will have taken place
13849 after the class definition is complete.) */
13852 finish_function (int flags
)
13854 tree fndecl
= current_function_decl
;
13855 tree fntype
, ctype
= NULL_TREE
;
13856 int inclass_inline
= (flags
& 2) != 0;
13858 /* When we get some parse errors, we can end up without a
13859 current_function_decl, so cope. */
13860 if (fndecl
== NULL_TREE
)
13861 return error_mark_node
;
13863 if (c_dialect_objc ())
13864 objc_finish_function ();
13866 gcc_assert (!defer_mark_used_calls
);
13867 defer_mark_used_calls
= true;
13869 record_key_method_defined (fndecl
);
13871 fntype
= TREE_TYPE (fndecl
);
13873 /* TREE_READONLY (fndecl) = 1;
13874 This caused &foo to be of type ptr-to-const-function
13875 which then got a warning when stored in a ptr-to-function variable. */
13877 gcc_assert (building_stmt_list_p ());
13878 /* The current function is being defined, so its DECL_INITIAL should
13879 be set, and unless there's a multiple definition, it should be
13880 error_mark_node. */
13881 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
13883 /* For a cloned function, we've already got all the code we need;
13884 there's no need to add any extra bits. */
13885 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13887 /* Make it so that `main' always returns 0 by default. */
13888 if (DECL_MAIN_P (current_function_decl
))
13889 finish_return_stmt (integer_zero_node
);
13891 if (use_eh_spec_block (current_function_decl
))
13892 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13893 (TREE_TYPE (current_function_decl
)),
13894 current_eh_spec_block
);
13897 /* If we're saving up tree structure, tie off the function now. */
13898 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
13900 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
13901 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
13903 finish_fname_decls ();
13905 /* If this function can't throw any exceptions, remember that. */
13906 if (!processing_template_decl
13907 && !cp_function_chain
->can_throw
13908 && !flag_non_call_exceptions
13909 && !decl_replaceable_p (fndecl
))
13910 TREE_NOTHROW (fndecl
) = 1;
13912 /* This must come after expand_function_end because cleanups might
13913 have declarations (from inline functions) that need to go into
13914 this function's blocks. */
13916 /* If the current binding level isn't the outermost binding level
13917 for this function, either there is a bug, or we have experienced
13918 syntax errors and the statement tree is malformed. */
13919 if (current_binding_level
->kind
!= sk_function_parms
)
13921 /* Make sure we have already experienced errors. */
13922 gcc_assert (errorcount
);
13924 /* Throw away the broken statement tree and extra binding
13926 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
13928 while (current_binding_level
->kind
!= sk_function_parms
)
13930 if (current_binding_level
->kind
== sk_class
)
13931 pop_nested_class ();
13933 poplevel (0, 0, 0);
13936 poplevel (1, 0, 1);
13938 /* Statements should always be full-expressions at the outermost set
13939 of curly braces for a function. */
13940 gcc_assert (stmts_are_full_exprs_p ());
13942 /* If there are no return statements in a function with auto return type,
13943 the return type is void. But if the declared type is something like
13944 auto*, this is an error. */
13945 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
13946 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
13948 if (!is_auto (current_function_auto_return_pattern
)
13949 && !current_function_returns_value
&& !current_function_returns_null
)
13951 error ("no return statements in function returning %qT",
13952 current_function_auto_return_pattern
);
13953 inform (input_location
, "only plain %<auto%> return type can be "
13954 "deduced to %<void%>");
13956 apply_deduced_return_type (fndecl
, void_type_node
);
13957 fntype
= TREE_TYPE (fndecl
);
13960 /* Save constexpr function body before it gets munged by
13961 the NRV transformation. */
13962 maybe_save_function_definition (fndecl
);
13964 /* Set up the named return value optimization, if we can. Candidate
13965 variables are selected in check_return_expr. */
13966 if (current_function_return_value
)
13968 tree r
= current_function_return_value
;
13971 if (r
!= error_mark_node
13972 /* This is only worth doing for fns that return in memory--and
13973 simpler, since we don't have to worry about promoted modes. */
13974 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
13975 /* Only allow this for variables declared in the outer scope of
13976 the function so we know that their lifetime always ends with a
13977 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13978 we were to do this optimization in tree-ssa. */
13979 && (outer
= outer_curly_brace_block (fndecl
))
13980 && chain_member (r
, BLOCK_VARS (outer
)))
13981 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
13983 current_function_return_value
= NULL_TREE
;
13986 /* Remember that we were in class scope. */
13987 if (current_class_name
)
13988 ctype
= current_class_type
;
13990 /* Must mark the RESULT_DECL as being in this function. */
13991 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13993 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13994 to the FUNCTION_DECL node itself. */
13995 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13997 /* Save away current state, if appropriate. */
13998 if (!processing_template_decl
)
13999 save_function_data (fndecl
);
14001 /* Complain if there's just no return statement. */
14002 if (warn_return_type
14003 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14004 && !dependent_type_p (TREE_TYPE (fntype
))
14005 && !current_function_returns_value
&& !current_function_returns_null
14006 /* Don't complain if we abort or throw. */
14007 && !current_function_returns_abnormally
14008 /* Don't complain if there's an infinite loop. */
14009 && !current_function_infinite_loop
14010 /* Don't complain if we are declared noreturn. */
14011 && !TREE_THIS_VOLATILE (fndecl
)
14012 && !DECL_NAME (DECL_RESULT (fndecl
))
14013 && !TREE_NO_WARNING (fndecl
)
14014 /* Structor return values (if any) are set by the compiler. */
14015 && !DECL_CONSTRUCTOR_P (fndecl
)
14016 && !DECL_DESTRUCTOR_P (fndecl
)
14017 && targetm
.warn_func_return (fndecl
))
14019 warning (OPT_Wreturn_type
,
14020 "no return statement in function returning non-void");
14021 TREE_NO_WARNING (fndecl
) = 1;
14024 /* Store the end of the function, so that we get good line number
14025 info for the epilogue. */
14026 cfun
->function_end_locus
= input_location
;
14028 /* Complain about parameters that are only set, but never otherwise used. */
14029 if (warn_unused_but_set_parameter
14030 && !processing_template_decl
14031 && errorcount
== unused_but_set_errorcount
14032 && !DECL_CLONED_FUNCTION_P (fndecl
))
14036 for (decl
= DECL_ARGUMENTS (fndecl
);
14038 decl
= DECL_CHAIN (decl
))
14039 if (TREE_USED (decl
)
14040 && TREE_CODE (decl
) == PARM_DECL
14041 && !DECL_READ_P (decl
)
14042 && DECL_NAME (decl
)
14043 && !DECL_ARTIFICIAL (decl
)
14044 && !TREE_NO_WARNING (decl
)
14045 && !DECL_IN_SYSTEM_HEADER (decl
)
14046 && TREE_TYPE (decl
) != error_mark_node
14047 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14048 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14049 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14050 warning (OPT_Wunused_but_set_parameter
,
14051 "parameter %q+D set but not used", decl
);
14052 unused_but_set_errorcount
= errorcount
;
14055 /* Complain about locally defined typedefs that are not used in this
14057 maybe_warn_unused_local_typedefs ();
14059 /* Genericize before inlining. */
14060 if (!processing_template_decl
)
14062 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14063 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14064 cp_genericize (fndecl
);
14065 /* Clear out the bits we don't need. */
14066 f
->x_current_class_ptr
= NULL
;
14067 f
->x_current_class_ref
= NULL
;
14068 f
->x_eh_spec_block
= NULL
;
14069 f
->x_in_charge_parm
= NULL
;
14070 f
->x_vtt_parm
= NULL
;
14071 f
->x_return_value
= NULL
;
14072 f
->bindings
= NULL
;
14073 f
->extern_decl_map
= NULL
;
14074 f
->infinite_loops
= NULL
;
14076 /* Clear out the bits we don't need. */
14077 local_names
= NULL
;
14079 /* We're leaving the context of this function, so zap cfun. It's still in
14080 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14082 current_function_decl
= NULL
;
14084 /* If this is an in-class inline definition, we may have to pop the
14085 bindings for the template parameters that we added in
14086 maybe_begin_member_template_processing when start_function was
14088 if (inclass_inline
)
14089 maybe_end_member_template_processing ();
14091 /* Leave the scope of the class. */
14093 pop_nested_class ();
14098 current_function_decl
= NULL_TREE
;
14100 defer_mark_used_calls
= false;
14101 if (deferred_mark_used_calls
)
14106 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14108 vec_free (deferred_mark_used_calls
);
14114 /* Create the FUNCTION_DECL for a function definition.
14115 DECLSPECS and DECLARATOR are the parts of the declaration;
14116 they describe the return type and the name of the function,
14117 but twisted together in a fashion that parallels the syntax of C.
14119 This function creates a binding context for the function body
14120 as well as setting up the FUNCTION_DECL in current_function_decl.
14122 Returns a FUNCTION_DECL on success.
14124 If the DECLARATOR is not suitable for a function (it defines a datum
14125 instead), we return 0, which tells yyparse to report a parse error.
14127 May return void_type_node indicating that this method is actually
14128 a friend. See grokfield for more details.
14130 Came here with a `.pushlevel' .
14132 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14133 CHANGES TO CODE IN `grokfield'. */
14136 grokmethod (cp_decl_specifier_seq
*declspecs
,
14137 const cp_declarator
*declarator
, tree attrlist
)
14139 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14142 if (fndecl
== error_mark_node
)
14143 return error_mark_node
;
14145 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14147 error ("invalid member function declaration");
14148 return error_mark_node
;
14152 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14154 /* Pass friends other than inline friend functions back. */
14155 if (fndecl
== void_type_node
)
14158 if (DECL_IN_AGGR_P (fndecl
))
14160 if (DECL_CLASS_SCOPE_P (fndecl
))
14161 error ("%qD is already defined in class %qT", fndecl
,
14162 DECL_CONTEXT (fndecl
));
14163 return error_mark_node
;
14166 check_template_shadow (fndecl
);
14168 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14169 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14171 /* We process method specializations in finish_struct_1. */
14172 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14174 fndecl
= push_template_decl (fndecl
);
14175 if (fndecl
== error_mark_node
)
14179 if (! DECL_FRIEND_P (fndecl
))
14181 if (DECL_CHAIN (fndecl
))
14183 fndecl
= copy_node (fndecl
);
14184 TREE_CHAIN (fndecl
) = NULL_TREE
;
14188 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14190 DECL_IN_AGGR_P (fndecl
) = 1;
14195 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14196 we can lay it out later, when and if its type becomes complete.
14198 Also handle constexpr pointer to member variables where the initializer
14199 is an unlowered PTRMEM_CST because the class isn't complete yet. */
14202 maybe_register_incomplete_var (tree var
)
14204 gcc_assert (VAR_P (var
));
14206 /* Keep track of variables with incomplete types. */
14207 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14208 && DECL_EXTERNAL (var
))
14210 tree inner_type
= TREE_TYPE (var
);
14212 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14213 inner_type
= TREE_TYPE (inner_type
);
14214 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14216 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14217 /* RTTI TD entries are created while defining the type_info. */
14218 || (TYPE_LANG_SPECIFIC (inner_type
)
14219 && TYPE_BEING_DEFINED (inner_type
)))
14221 incomplete_var iv
= {var
, inner_type
};
14222 vec_safe_push (incomplete_vars
, iv
);
14224 else if (TYPE_PTRMEM_P (inner_type
)
14225 && DECL_INITIAL (var
)
14226 && TREE_CODE (DECL_INITIAL (var
)) == PTRMEM_CST
)
14228 tree context
= TYPE_PTRMEM_CLASS_TYPE (inner_type
);
14229 gcc_assert (TYPE_BEING_DEFINED (context
));
14230 incomplete_var iv
= {var
, context
};
14231 vec_safe_push (incomplete_vars
, iv
);
14236 /* Called when a class type (given by TYPE) is defined. If there are
14237 any existing VAR_DECLs whose type has been completed by this
14238 declaration, update them now. */
14241 complete_vars (tree type
)
14244 incomplete_var
*iv
;
14246 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14248 if (same_type_p (type
, iv
->incomplete_type
))
14250 tree var
= iv
->decl
;
14251 tree type
= TREE_TYPE (var
);
14253 if (TYPE_PTRMEM_P (type
))
14254 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14257 /* Complete the type of the variable. The VAR_DECL itself
14258 will be laid out in expand_expr. */
14259 complete_type (type
);
14260 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14263 /* Remove this entry from the list. */
14264 incomplete_vars
->unordered_remove (ix
);
14270 /* Check for pending declarations which may have abstract type. */
14271 complete_type_check_abstract (type
);
14274 /* If DECL is of a type which needs a cleanup, build and return an
14275 expression to perform that cleanup here. Return NULL_TREE if no
14276 cleanup need be done. */
14279 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14285 /* Assume no cleanup is required. */
14286 cleanup
= NULL_TREE
;
14288 if (error_operand_p (decl
))
14291 /* Handle "__attribute__((cleanup))". We run the cleanup function
14292 before the destructor since the destructor is what actually
14293 terminates the lifetime of the object. */
14294 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14301 /* Get the name specified by the user for the cleanup function. */
14302 id
= TREE_VALUE (TREE_VALUE (attr
));
14303 /* Look up the name to find the cleanup function to call. It is
14304 important to use lookup_name here because that is what is
14305 used in c-common.c:handle_cleanup_attribute when performing
14306 initial checks on the attribute. Note that those checks
14307 include ensuring that the function found is not an overloaded
14308 function, or an object with an overloaded call operator,
14309 etc.; we can rely on the fact that the function found is an
14310 ordinary FUNCTION_DECL. */
14311 fn
= lookup_name (id
);
14312 arg
= build_address (decl
);
14314 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14315 if (cleanup
== error_mark_node
)
14316 return error_mark_node
;
14318 /* Handle ordinary C++ destructors. */
14319 type
= TREE_TYPE (decl
);
14320 if (type_build_dtor_call (type
))
14322 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14326 if (TREE_CODE (type
) == ARRAY_TYPE
)
14329 addr
= build_address (decl
);
14331 call
= build_delete (TREE_TYPE (addr
), addr
,
14332 sfk_complete_destructor
, flags
, 0, complain
);
14333 if (call
== error_mark_node
)
14334 cleanup
= error_mark_node
;
14335 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14336 /* Discard the call. */;
14338 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14343 /* build_delete sets the location of the destructor call to the
14344 current location, even though the destructor is going to be
14345 called later, at the end of the current scope. This can lead to
14346 a "jumpy" behaviour for users of debuggers when they step around
14347 the end of the block. So let's unset the location of the
14348 destructor call instead. */
14349 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14350 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14353 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
))))
14354 /* Treat objects with destructors as used; the destructor may do
14355 something substantive. */
14362 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14363 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14364 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14367 static_fn_type (tree memfntype
)
14372 if (TYPE_PTRMEMFUNC_P (memfntype
))
14373 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14374 if (POINTER_TYPE_P (memfntype
)
14375 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14376 memfntype
= TREE_TYPE (memfntype
);
14377 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14379 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14380 args
= TYPE_ARG_TYPES (memfntype
);
14381 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14382 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14383 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14384 fntype
= (cp_build_type_attribute_variant
14385 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14386 fntype
= (build_exception_variant
14387 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14391 /* DECL was originally constructed as a non-static member function,
14392 but turned out to be static. Update it accordingly. */
14395 revert_static_member_fn (tree decl
)
14397 tree stype
= static_fn_type (decl
);
14398 cp_cv_quals quals
= type_memfn_quals (stype
);
14399 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14401 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14402 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14404 TREE_TYPE (decl
) = stype
;
14406 if (DECL_ARGUMENTS (decl
))
14407 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14408 DECL_STATIC_FUNCTION_P (decl
) = 1;
14411 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14412 one of the language-independent trees. */
14414 enum cp_tree_node_structure_enum
14415 cp_tree_node_structure (union lang_tree_node
* t
)
14417 switch (TREE_CODE (&t
->generic
))
14419 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14420 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14421 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14422 case OVERLOAD
: return TS_CP_OVERLOAD
;
14423 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14424 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14425 case BASELINK
: return TS_CP_BASELINK
;
14426 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14427 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14428 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14429 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14430 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14431 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14432 default: return TS_CP_GENERIC
;
14436 /* Build the void_list_node (void_type_node having been created). */
14438 build_void_list_node (void)
14440 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14445 cp_missing_noreturn_ok_p (tree decl
)
14447 /* A missing noreturn is ok for the `main' function. */
14448 return DECL_MAIN_P (decl
);
14451 /* Return the COMDAT group into which DECL should be placed. */
14454 cxx_comdat_group (tree decl
)
14458 /* Virtual tables, construction virtual tables, and virtual table
14459 tables all go in a single COMDAT group, named after the primary
14461 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14462 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
14463 /* For all other DECLs, the COMDAT group is the mangled name of the
14464 declaration itself. */
14467 while (DECL_THUNK_P (decl
))
14469 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14470 into the same section as the target function. In that case
14471 we must return target's name. */
14472 tree target
= THUNK_TARGET (decl
);
14473 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14474 && DECL_SECTION_NAME (target
) != NULL
14475 && DECL_ONE_ONLY (target
))
14480 name
= DECL_ASSEMBLER_NAME (decl
);
14486 /* Returns the return type for FN as written by the user, which may include
14487 a placeholder for a deduced return type. */
14490 fndecl_declared_return_type (tree fn
)
14492 fn
= STRIP_TEMPLATE (fn
);
14493 if (FNDECL_USED_AUTO (fn
))
14495 struct language_function
*f
= NULL
;
14496 if (DECL_STRUCT_FUNCTION (fn
))
14497 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
14499 f
= DECL_SAVED_FUNCTION_DATA (fn
);
14500 return f
->x_auto_return_pattern
;
14502 return TREE_TYPE (TREE_TYPE (fn
));
14505 /* Returns true iff DECL was declared with an auto return type and it has
14506 not yet been deduced to a real type. */
14509 undeduced_auto_decl (tree decl
)
14511 if (cxx_dialect
< cxx1y
)
14513 return type_uses_auto (TREE_TYPE (decl
));
14516 /* Complain if DECL has an undeduced return type. */
14519 require_deduced_type (tree decl
)
14521 if (undeduced_auto_decl (decl
))
14522 error ("use of %qD before deduction of %<auto%>", decl
);
14525 #include "gt-cp-decl.h"