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 "tree-hasher.h"
35 #include "stringpool.h"
36 #include "stor-layout.h"
42 #include "tree-iterator.h"
43 #include "tree-inline.h"
50 #include "c-family/c-common.h"
51 #include "c-family/c-objc.h"
52 #include "c-family/c-pragma.h"
53 #include "c-family/c-target.h"
54 #include "c-family/c-ubsan.h"
55 #include "diagnostic.h"
59 #include "splay-tree.h"
63 #include "plugin-api.h"
67 #include "hard-reg-set.h"
76 /* Possible cases of bad specifiers type used by bad_specifiers. */
78 BSP_VAR
, /* variable */
79 BSP_PARM
, /* parameter */
84 static tree
grokparms (tree parmlist
, tree
*);
85 static const char *redeclaration_error_message (tree
, tree
);
87 static int decl_jump_unsafe (tree
);
88 static void require_complete_types_for_parms (tree
);
89 static int ambi_op_p (enum tree_code
);
90 static int unary_op_p (enum tree_code
);
91 static void push_local_name (tree
);
92 static tree
grok_reference_init (tree
, tree
, tree
, int);
93 static tree
grokvardecl (tree
, tree
, tree
, const cp_decl_specifier_seq
*,
95 static int check_static_variable_definition (tree
, tree
);
96 static void record_unknown_type (tree
, const char *);
97 static tree
builtin_function_1 (tree
, tree
, bool);
98 static int member_function_or_else (tree
, tree
, enum overload_flags
);
99 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
101 static void check_for_uninitialized_const_var (tree
);
102 static tree
local_variable_p_walkfn (tree
*, int *, void *);
103 static tree
record_builtin_java_type (const char *, int);
104 static const char *tag_name (enum tag_types
);
105 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
106 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
107 static void maybe_deduce_size_from_array_init (tree
, tree
);
108 static void layout_var_decl (tree
);
109 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
110 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
111 static void save_function_data (tree
);
112 static void copy_type_enum (tree
, tree
);
113 static void check_function_type (tree
, tree
);
114 static void finish_constructor_body (void);
115 static void begin_destructor_body (void);
116 static void finish_destructor_body (void);
117 static void record_key_method_defined (tree
);
118 static tree
create_array_type_for_decl (tree
, tree
, tree
);
119 static tree
get_atexit_node (void);
120 static tree
get_dso_handle_node (void);
121 static tree
start_cleanup_fn (void);
122 static void end_cleanup_fn (void);
123 static tree
cp_make_fname_decl (location_t
, tree
, int);
124 static void initialize_predefined_identifiers (void);
125 static tree check_special_function_return_type
126 (special_function_kind
, tree
, tree
);
127 static tree
push_cp_library_fn (enum tree_code
, tree
, int);
128 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
, int);
129 static void store_parm_decls (tree
);
130 static void initialize_local_var (tree
, tree
);
131 static void expand_static_init (tree
, tree
);
133 /* The following symbols are subsumed in the cp_global_trees array, and
134 listed here individually for documentation purposes.
137 tree wchar_decl_node;
139 tree vtable_entry_type;
140 tree delta_type_node;
141 tree __t_desc_type_node;
143 tree class_type_node;
144 tree unknown_type_node;
146 Array type `vtable_entry_type[]'
149 tree vtbl_ptr_type_node;
156 A FUNCTION_DECL which can call `abort'. Not necessarily the
157 one that the user will declare, but sufficient to be called
158 by routines that want to abort the program.
162 The FUNCTION_DECL for the default `::operator delete'.
164 tree global_delete_fndecl;
167 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
168 tree tinfo_var_id; */
170 tree cp_global_trees
[CPTI_MAX
];
172 /* Indicates that there is a type value in some namespace, although
173 that is not necessarily in scope at the moment. */
175 tree global_type_node
;
177 /* The node that holds the "name" of the global scope. */
178 tree global_scope_name
;
180 #define local_names cp_function_chain->x_local_names
182 /* A list of objects which have constructors or destructors
183 which reside in the global scope. The decl is stored in
184 the TREE_VALUE slot and the initializer is stored
185 in the TREE_PURPOSE slot. */
186 tree static_aggregates
;
188 /* Like static_aggregates, but for thread_local variables. */
193 /* A node for the integer constant 2. */
195 tree integer_two_node
;
197 /* Used only for jumps to as-yet undefined labels, since jumps to
198 defined labels can have their validity checked immediately. */
200 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
201 struct named_label_use_entry
*next
;
202 /* The binding level to which this entry is *currently* attached.
203 This is initially the binding level in which the goto appeared,
204 but is modified as scopes are closed. */
205 cp_binding_level
*binding_level
;
206 /* The head of the names list that was current when the goto appeared,
207 or the inner scope popped. These are the decls that will *not* be
208 skipped when jumping to the label. */
210 /* The location of the goto, for error reporting. */
211 location_t o_goto_locus
;
212 /* True if an OpenMP structured block scope has been closed since
213 the goto appeared. This means that the branch from the label will
214 illegally exit an OpenMP scope. */
218 /* A list of all LABEL_DECLs in the function that have names. Here so
219 we can clear out their names' definitions at the end of the
220 function, and so we can check the validity of jumps to these labels. */
222 struct GTY((for_user
)) named_label_entry
{
223 /* The decl itself. */
226 /* The binding level to which the label is *currently* attached.
227 This is initially set to the binding level in which the label
228 is defined, but is modified as scopes are closed. */
229 cp_binding_level
*binding_level
;
230 /* The head of the names list that was current when the label was
231 defined, or the inner scope popped. These are the decls that will
232 be skipped when jumping to the label. */
234 /* A vector of all decls from all binding levels that would be
235 crossed by a backward branch to the label. */
236 vec
<tree
, va_gc
> *bad_decls
;
238 /* A list of uses of the label, before the label is defined. */
239 struct named_label_use_entry
*uses
;
241 /* The following bits are set after the label is defined, and are
242 updated as scopes are popped. They indicate that a backward jump
243 to the label will illegally enter a scope of the given flavor. */
249 #define named_labels cp_function_chain->x_named_labels
251 /* The number of function bodies which we are currently processing.
252 (Zero if we are at namespace scope, one inside the body of a
253 function, two inside the body of a function in a local class, etc.) */
256 /* To avoid unwanted recursion, finish_function defers all mark_used calls
257 encountered during its execution until it finishes. */
258 bool defer_mark_used_calls
;
259 vec
<tree
, va_gc
> *deferred_mark_used_calls
;
261 /* States indicating how grokdeclarator() should handle declspecs marked
262 with __attribute__((deprecated)). An object declared as
263 __attribute__((deprecated)) suppresses warnings of uses of other
265 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
268 /* A list of VAR_DECLs whose type was incomplete at the time the
269 variable was declared. */
271 typedef struct GTY(()) incomplete_var_d
{
273 tree incomplete_type
;
277 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
279 /* Returns the kind of template specialization we are currently
280 processing, given that it's declaration contained N_CLASS_SCOPES
281 explicit scope qualifications. */
284 current_tmpl_spec_kind (int n_class_scopes
)
286 int n_template_parm_scopes
= 0;
287 int seen_specialization_p
= 0;
288 int innermost_specialization_p
= 0;
291 /* Scan through the template parameter scopes. */
292 for (b
= current_binding_level
;
293 b
->kind
== sk_template_parms
;
296 /* If we see a specialization scope inside a parameter scope,
297 then something is wrong. That corresponds to a declaration
300 template <class T> template <> ...
302 which is always invalid since [temp.expl.spec] forbids the
303 specialization of a class member template if the enclosing
304 class templates are not explicitly specialized as well. */
305 if (b
->explicit_spec_p
)
307 if (n_template_parm_scopes
== 0)
308 innermost_specialization_p
= 1;
310 seen_specialization_p
= 1;
312 else if (seen_specialization_p
== 1)
313 return tsk_invalid_member_spec
;
315 ++n_template_parm_scopes
;
318 /* Handle explicit instantiations. */
319 if (processing_explicit_instantiation
)
321 if (n_template_parm_scopes
!= 0)
322 /* We've seen a template parameter list during an explicit
323 instantiation. For example:
325 template <class T> template void f(int);
327 This is erroneous. */
328 return tsk_invalid_expl_inst
;
330 return tsk_expl_inst
;
333 if (n_template_parm_scopes
< n_class_scopes
)
334 /* We've not seen enough template headers to match all the
335 specialized classes present. For example:
337 template <class T> void R<T>::S<T>::f(int);
339 This is invalid; there needs to be one set of template
340 parameters for each class. */
341 return tsk_insufficient_parms
;
342 else if (n_template_parm_scopes
== n_class_scopes
)
343 /* We're processing a non-template declaration (even though it may
344 be a member of a template class.) For example:
346 template <class T> void S<T>::f(int);
348 The `class T' matches the `S<T>', leaving no template headers
349 corresponding to the `f'. */
351 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
352 /* We've got too many template headers. For example:
354 template <> template <class T> void f (T);
356 There need to be more enclosing classes. */
357 return tsk_excessive_parms
;
359 /* This must be a template. It's of the form:
361 template <class T> template <class U> void S<T>::f(U);
363 This is a specialization if the innermost level was a
364 specialization; otherwise it's just a definition of the
366 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
369 /* Exit the current scope. */
377 /* When a label goes out of scope, check to see if that label was used
378 in a valid manner, and issue any appropriate warnings or errors. */
381 pop_label (tree label
, tree old_value
)
383 if (!processing_template_decl
)
385 if (DECL_INITIAL (label
) == NULL_TREE
)
389 error ("label %q+D used but not defined", label
);
390 location
= input_location
;
391 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
392 /* Avoid crashing later. */
393 define_label (location
, DECL_NAME (label
));
396 warn_for_unused_label (label
);
399 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
402 /* At the end of a function, all labels declared within the function
403 go out of scope. BLOCK is the top-level block for the
407 pop_labels_1 (named_label_entry
**slot
, tree block
)
409 struct named_label_entry
*ent
= *slot
;
411 pop_label (ent
->label_decl
, NULL_TREE
);
413 /* Put the labels into the "variables" of the top-level block,
414 so debugger can see them. */
415 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
416 BLOCK_VARS (block
) = ent
->label_decl
;
418 named_labels
->clear_slot (slot
);
424 pop_labels (tree block
)
428 named_labels
->traverse
<tree
, pop_labels_1
> (block
);
433 /* At the end of a block with local labels, restore the outer definition. */
436 pop_local_label (tree label
, tree old_value
)
438 struct named_label_entry dummy
;
440 pop_label (label
, old_value
);
442 dummy
.label_decl
= label
;
443 named_label_entry
**slot
= named_labels
->find_slot (&dummy
, NO_INSERT
);
444 named_labels
->clear_slot (slot
);
447 /* The following two routines are used to interface to Objective-C++.
448 The binding level is purposely treated as an opaque type. */
451 objc_get_current_scope (void)
453 return current_binding_level
;
456 /* The following routine is used by the NeXT-style SJLJ exceptions;
457 variables get marked 'volatile' so as to not be clobbered by
458 _setjmp()/_longjmp() calls. All variables in the current scope,
459 as well as parent scopes up to (but not including) ENCLOSING_BLK
460 shall be thusly marked. */
463 objc_mark_locals_volatile (void *enclosing_blk
)
465 cp_binding_level
*scope
;
467 for (scope
= current_binding_level
;
468 scope
&& scope
!= enclosing_blk
;
469 scope
= scope
->level_chain
)
473 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
474 objc_volatilize_decl (decl
);
476 /* Do not climb up past the current function. */
477 if (scope
->kind
== sk_function_parms
)
482 /* Update data for defined and undefined labels when leaving a scope. */
485 poplevel_named_label_1 (named_label_entry
**slot
, cp_binding_level
*bl
)
487 named_label_entry
*ent
= *slot
;
488 cp_binding_level
*obl
= bl
->level_chain
;
490 if (ent
->binding_level
== bl
)
494 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
495 TREE_LISTs representing OVERLOADs, so be careful. */
496 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
498 : TREE_CHAIN (decl
)))
499 if (decl_jump_unsafe (decl
))
500 vec_safe_push (ent
->bad_decls
, decl
);
502 ent
->binding_level
= obl
;
503 ent
->names_in_scope
= obl
->names
;
507 ent
->in_try_scope
= true;
510 ent
->in_catch_scope
= true;
513 ent
->in_omp_scope
= true;
521 struct named_label_use_entry
*use
;
523 for (use
= ent
->uses
; use
; use
= use
->next
)
524 if (use
->binding_level
== bl
)
526 use
->binding_level
= obl
;
527 use
->names_in_scope
= obl
->names
;
528 if (bl
->kind
== sk_omp
)
529 use
->in_omp_scope
= true;
536 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
537 when errors were reported, except for -Werror-unused-but-set-*. */
538 static int unused_but_set_errorcount
;
540 /* Exit a binding level.
541 Pop the level off, and restore the state of the identifier-decl mappings
542 that were in effect when this level was entered.
544 If KEEP == 1, this level had explicit declarations, so
545 and create a "block" (a BLOCK node) for the level
546 to record its declarations and subblocks for symbol table output.
548 If FUNCTIONBODY is nonzero, this level is the body of a function,
549 so create a block as if KEEP were set and also clear out all
552 If REVERSE is nonzero, reverse the order of decls before putting
553 them into the BLOCK. */
556 poplevel (int keep
, int reverse
, int functionbody
)
559 /* The chain of decls was accumulated in reverse order.
560 Put it into forward order, just for cleanliness. */
565 int leaving_for_scope
;
568 cp_label_binding
*label_bind
;
570 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
575 gcc_assert (current_binding_level
->kind
!= sk_class
);
577 if (current_binding_level
->kind
== sk_cleanup
)
579 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
581 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
583 /* We used to use KEEP == 2 to indicate that the new block should go
584 at the beginning of the list of blocks at this binding level,
585 rather than the end. This hack is no longer used. */
586 gcc_assert (keep
== 0 || keep
== 1);
588 if (current_binding_level
->keep
)
591 /* Any uses of undefined labels, and any defined labels, now operate
592 under constraints of next binding contour. */
593 if (cfun
&& !functionbody
&& named_labels
)
594 named_labels
->traverse
<cp_binding_level
*, poplevel_named_label_1
>
595 (current_binding_level
);
597 /* Get the decls in the order they were written.
598 Usually current_binding_level->names is in reverse order.
599 But parameter decls were previously put in forward order. */
602 current_binding_level
->names
603 = decls
= nreverse (current_binding_level
->names
);
605 decls
= current_binding_level
->names
;
607 /* If there were any declarations or structure tags in that level,
608 or if this level is a function body,
609 create a BLOCK to record them for the life of this function. */
611 if (keep
== 1 || functionbody
)
612 block
= make_node (BLOCK
);
613 if (block
!= NULL_TREE
)
615 BLOCK_VARS (block
) = decls
;
616 BLOCK_SUBBLOCKS (block
) = subblocks
;
619 /* In each subblock, record that this is its superior. */
621 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
622 BLOCK_SUPERCONTEXT (link
) = block
;
624 /* We still support the old for-scope rules, whereby the variables
625 in a for-init statement were in scope after the for-statement
626 ended. We only use the new rules if flag_new_for_scope is
629 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
631 /* Before we remove the declarations first check for unused variables. */
632 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
633 && current_binding_level
->kind
!= sk_template_parms
634 && !processing_template_decl
)
635 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
637 /* There are cases where D itself is a TREE_LIST. See in
638 push_local_binding where the list of decls returned by
639 getdecls is built. */
640 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
641 tree type
= TREE_TYPE (decl
);
643 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
644 && ! DECL_IN_SYSTEM_HEADER (decl
)
645 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
646 && type
!= error_mark_node
647 && (!CLASS_TYPE_P (type
)
648 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
649 || lookup_attribute ("warn_unused",
650 TYPE_ATTRIBUTES (TREE_TYPE (decl
)))))
652 if (! TREE_USED (decl
))
653 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
654 else if (DECL_CONTEXT (decl
) == current_function_decl
655 // For -Wunused-but-set-variable leave references alone.
656 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
657 && errorcount
== unused_but_set_errorcount
)
659 warning (OPT_Wunused_but_set_variable
,
660 "variable %q+D set but not used", decl
);
661 unused_but_set_errorcount
= errorcount
;
666 /* Remove declarations for all the DECLs in this level. */
667 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
669 if (leaving_for_scope
&& VAR_P (link
)
670 /* It's hard to make this ARM compatibility hack play nicely with
671 lambdas, and it really isn't necessary in C++11 mode. */
672 && cxx_dialect
< cxx11
675 tree name
= DECL_NAME (link
);
679 ob
= outer_binding (name
,
680 IDENTIFIER_BINDING (name
),
683 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
685 ns_binding
= NULL_TREE
;
687 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
688 /* We have something like:
693 and we are leaving the `for' scope. There's no reason to
694 keep the binding of the inner `i' in this case. */
695 pop_binding (name
, link
);
696 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
697 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
698 /* Here, we have something like:
706 We must pop the for-scope binding so we know what's a
707 type and what isn't. */
708 pop_binding (name
, link
);
711 /* Mark this VAR_DECL as dead so that we can tell we left it
712 there only for backward compatibility. */
713 DECL_DEAD_FOR_LOCAL (link
) = 1;
715 /* Keep track of what should have happened when we
716 popped the binding. */
719 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
720 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
723 /* Add it to the list of dead variables in the next
724 outermost binding to that we can remove these when we
725 leave that binding. */
727 current_binding_level
->level_chain
->dead_vars_from_for
,
730 /* Although we don't pop the cxx_binding, we do clear
731 its SCOPE since the scope is going away now. */
732 IDENTIFIER_BINDING (name
)->scope
733 = current_binding_level
->level_chain
;
740 /* Remove the binding. */
743 if (TREE_CODE (decl
) == TREE_LIST
)
744 decl
= TREE_VALUE (decl
);
747 if (TREE_CODE (name
) == OVERLOAD
)
748 name
= OVL_FUNCTION (name
);
750 gcc_assert (DECL_P (name
));
751 pop_binding (DECL_NAME (name
), decl
);
755 /* Remove declarations for any `for' variables from inner scopes
756 that we kept around. */
757 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
759 pop_binding (DECL_NAME (decl
), decl
);
761 /* Restore the IDENTIFIER_TYPE_VALUEs. */
762 for (link
= current_binding_level
->type_shadowed
;
763 link
; link
= TREE_CHAIN (link
))
764 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
766 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
767 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
769 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
771 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
772 list if a `using' declaration put them there. The debugging
773 back ends won't understand OVERLOAD, so we remove them here.
774 Because the BLOCK_VARS are (temporarily) shared with
775 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
776 popped all the bindings. */
781 for (d
= &BLOCK_VARS (block
); *d
; )
783 if (TREE_CODE (*d
) == TREE_LIST
)
784 *d
= TREE_CHAIN (*d
);
786 d
= &DECL_CHAIN (*d
);
790 /* If the level being exited is the top level of a function,
791 check over all the labels. */
794 /* Since this is the top level block of a function, the vars are
795 the function's parameters. Don't leave them in the BLOCK
796 because they are found in the FUNCTION_DECL instead. */
797 BLOCK_VARS (block
) = 0;
801 kind
= current_binding_level
->kind
;
802 if (kind
== sk_cleanup
)
806 /* If this is a temporary binding created for a cleanup, then we'll
807 have pushed a statement list level. Pop that, create a new
808 BIND_EXPR for the block, and insert it into the stream. */
809 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
810 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
817 /* The current function is being defined, so its DECL_INITIAL
818 should be error_mark_node. */
819 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
820 DECL_INITIAL (current_function_decl
) = block
;
823 current_binding_level
->blocks
824 = block_chainon (current_binding_level
->blocks
, block
);
826 /* If we did not make a block for the level just exited,
827 any blocks made for inner levels
828 (since they cannot be recorded as subblocks in that level)
829 must be carried forward so they will later become subblocks
830 of something else. */
832 current_binding_level
->blocks
833 = block_chainon (current_binding_level
->blocks
, subblocks
);
835 /* Each and every BLOCK node created here in `poplevel' is important
836 (e.g. for proper debugging information) so if we created one
837 earlier, mark it as "used". */
839 TREE_USED (block
) = 1;
841 /* All temporary bindings created for cleanups are popped silently. */
842 if (kind
== sk_cleanup
)
845 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
849 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
850 itself, calling F for each. The DATA is passed to F as well. */
853 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
856 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
858 result
|= (*f
) (name_space
, data
);
860 for (; current
; current
= DECL_CHAIN (current
))
861 result
|= walk_namespaces_r (current
, f
, data
);
866 /* Walk all the namespaces, calling F for each. The DATA is passed to
870 walk_namespaces (walk_namespaces_fn f
, void* data
)
872 return walk_namespaces_r (global_namespace
, f
, data
);
875 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
876 DATA is non-NULL, this is the last time we will call
877 wrapup_global_declarations for this NAMESPACE. */
880 wrapup_globals_for_namespace (tree name_space
, void* data
)
882 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
883 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
884 tree
*vec
= statics
->address ();
885 int len
= statics
->length ();
886 int last_time
= (data
!= 0);
890 check_global_declarations (vec
, len
);
891 emit_debug_global_declarations (vec
, len
);
895 /* Write out any globals that need to be output. */
896 return wrapup_global_declarations (vec
, len
);
900 /* In C++, you don't have to write `struct S' to refer to `S'; you
901 can just use `S'. We accomplish this by creating a TYPE_DECL as
902 if the user had written `typedef struct S S'. Create and return
903 the TYPE_DECL for TYPE. */
906 create_implicit_typedef (tree name
, tree type
)
910 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
911 DECL_ARTIFICIAL (decl
) = 1;
912 /* There are other implicit type declarations, like the one *within*
913 a class that allows you to write `S::S'. We must distinguish
915 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
916 TYPE_NAME (type
) = decl
;
917 TYPE_STUB_DECL (type
) = decl
;
922 /* Remember a local name for name-mangling purposes. */
925 push_local_name (tree decl
)
930 timevar_start (TV_NAME_LOOKUP
);
932 name
= DECL_NAME (decl
);
934 nelts
= vec_safe_length (local_names
);
935 for (i
= 0; i
< nelts
; i
++)
937 t
= (*local_names
)[i
];
938 if (DECL_NAME (t
) == name
)
940 if (!DECL_LANG_SPECIFIC (decl
))
941 retrofit_lang_decl (decl
);
942 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
943 if (DECL_DISCRIMINATOR_SET_P (t
))
944 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
946 DECL_DISCRIMINATOR (decl
) = 1;
948 (*local_names
)[i
] = decl
;
949 timevar_stop (TV_NAME_LOOKUP
);
954 vec_safe_push (local_names
, decl
);
955 timevar_stop (TV_NAME_LOOKUP
);
958 /* Subroutine of duplicate_decls: return truthvalue of whether
959 or not types of these decls match.
961 For C++, we must compare the parameter list so that `int' can match
962 `int&' in a parameter position, but `int&' is not confused with
966 decls_match (tree newdecl
, tree olddecl
)
970 if (newdecl
== olddecl
)
973 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
974 /* If the two DECLs are not even the same kind of thing, we're not
975 interested in their types. */
978 gcc_assert (DECL_P (newdecl
));
980 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
982 tree f1
= TREE_TYPE (newdecl
);
983 tree f2
= TREE_TYPE (olddecl
);
984 tree p1
= TYPE_ARG_TYPES (f1
);
985 tree p2
= TYPE_ARG_TYPES (f2
);
988 /* Specializations of different templates are different functions
989 even if they have the same type. */
990 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
991 ? DECL_TI_TEMPLATE (newdecl
)
993 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
994 ? DECL_TI_TEMPLATE (olddecl
)
999 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1000 && ! (DECL_EXTERN_C_P (newdecl
)
1001 && DECL_EXTERN_C_P (olddecl
)))
1004 /* A new declaration doesn't match a built-in one unless it
1005 is also extern "C". */
1006 if (DECL_IS_BUILTIN (olddecl
)
1007 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
1010 if (TREE_CODE (f1
) != TREE_CODE (f2
))
1013 /* A declaration with deduced return type should use its pre-deduction
1014 type for declaration matching. */
1015 r2
= fndecl_declared_return_type (olddecl
);
1017 if (same_type_p (TREE_TYPE (f1
), r2
))
1019 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1020 && (DECL_BUILT_IN (olddecl
)
1021 #ifndef NO_IMPLICIT_EXTERN_C
1022 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1023 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1027 types_match
= self_promoting_args_p (p1
);
1028 if (p1
== void_list_node
)
1029 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1031 #ifndef NO_IMPLICIT_EXTERN_C
1032 else if (!prototype_p (f1
)
1033 && (DECL_EXTERN_C_P (olddecl
)
1034 && DECL_IN_SYSTEM_HEADER (olddecl
)
1035 && !DECL_CLASS_SCOPE_P (olddecl
))
1036 && (DECL_EXTERN_C_P (newdecl
)
1037 && DECL_IN_SYSTEM_HEADER (newdecl
)
1038 && !DECL_CLASS_SCOPE_P (newdecl
)))
1040 types_match
= self_promoting_args_p (p2
);
1041 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1047 && type_memfn_rqual (f1
) == type_memfn_rqual (f2
)
1048 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1049 || comp_type_attributes (TREE_TYPE (newdecl
),
1050 TREE_TYPE (olddecl
)) != 0);
1055 /* The decls dont match if they correspond to two different versions
1056 of the same function. Disallow extern "C" functions to be
1057 versions for now. */
1059 && !DECL_EXTERN_C_P (newdecl
)
1060 && !DECL_EXTERN_C_P (olddecl
)
1061 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1063 /* Mark functions as versions if necessary. Modify the mangled decl
1064 name if necessary. */
1065 if (DECL_FUNCTION_VERSIONED (newdecl
)
1066 && DECL_FUNCTION_VERSIONED (olddecl
))
1068 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1070 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1071 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1072 mangle_decl (newdecl
);
1074 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1076 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1077 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1078 mangle_decl (olddecl
);
1080 cgraph_node::record_function_versions (olddecl
, newdecl
);
1084 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1086 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1087 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1090 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1091 DECL_TEMPLATE_PARMS (olddecl
)))
1094 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1095 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1096 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1098 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1099 DECL_TEMPLATE_RESULT (newdecl
));
1103 /* Need to check scope for variable declaration (VAR_DECL).
1104 For typedef (TYPE_DECL), scope is ignored. */
1106 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1108 Two declarations for an object with C language linkage
1109 with the same name (ignoring the namespace that qualify
1110 it) that appear in different namespace scopes refer to
1112 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1115 if (TREE_TYPE (newdecl
) == error_mark_node
)
1116 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1117 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1118 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1119 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1122 types_match
= comptypes (TREE_TYPE (newdecl
),
1123 TREE_TYPE (olddecl
),
1124 COMPARE_REDECLARATION
);
1130 /* If NEWDECL is `static' and an `extern' was seen previously,
1131 warn about it. OLDDECL is the previous declaration.
1133 Note that this does not apply to the C++ case of declaring
1134 a variable `extern const' and then later `const'.
1136 Don't complain about built-in functions, since they are beyond
1137 the user's control. */
1140 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1142 if (TREE_CODE (newdecl
) == TYPE_DECL
1143 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1144 || TREE_CODE (newdecl
) == CONST_DECL
1145 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1148 /* Don't get confused by static member functions; that's a different
1150 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1151 && DECL_STATIC_FUNCTION_P (newdecl
))
1154 /* If the old declaration was `static', or the new one isn't, then
1155 everything is OK. */
1156 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1159 /* It's OK to declare a builtin function as `static'. */
1160 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1161 && DECL_ARTIFICIAL (olddecl
))
1164 if (permerror (input_location
,
1165 "%qD was declared %<extern%> and later %<static%>", newdecl
))
1166 inform (input_location
, "previous declaration of %q+D", olddecl
);
1169 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1170 function templates. If their exception specifications do not
1171 match, issue a diagnostic. */
1174 check_redeclaration_exception_specification (tree new_decl
,
1177 tree new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1178 tree old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1180 /* Two default specs are equivalent, don't force evaluation. */
1181 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions
)
1182 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions
))
1185 maybe_instantiate_noexcept (new_decl
);
1186 maybe_instantiate_noexcept (old_decl
);
1187 new_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl
));
1188 old_exceptions
= TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl
));
1192 If any declaration of a function has an exception-specification,
1193 all declarations, including the definition and an explicit
1194 specialization, of that function shall have an
1195 exception-specification with the same set of type-ids. */
1196 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1197 && ! DECL_IS_BUILTIN (old_decl
)
1199 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1201 error ("declaration of %qF has a different exception specifier",
1203 error ("from previous declaration %q+F", old_decl
);
1207 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1208 Otherwise issue diagnostics. */
1211 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1213 old_decl
= STRIP_TEMPLATE (old_decl
);
1214 new_decl
= STRIP_TEMPLATE (new_decl
);
1215 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1216 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1218 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1219 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1221 if (TREE_CODE (old_decl
) == FUNCTION_DECL
)
1223 if (DECL_BUILT_IN (old_decl
))
1225 /* Hide a built-in declaration. */
1226 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1227 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1230 /* 7.1.5 [dcl.constexpr]
1231 Note: An explicit specialization can differ from the template
1232 declaration with respect to the constexpr specifier. */
1233 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl
)
1234 && DECL_TEMPLATE_SPECIALIZATION (new_decl
))
1237 error ("redeclaration %qD differs in %<constexpr%>", new_decl
);
1238 error ("from previous declaration %q+D", old_decl
);
1244 /* DECL is a redeclaration of a function or function template. If
1245 it does have default arguments issue a diagnostic. Note: this
1246 function is used to enforce the requirements in C++11 8.3.6 about
1247 no default arguments in redeclarations. */
1250 check_redeclaration_no_default_args (tree decl
)
1252 gcc_assert (DECL_DECLARES_FUNCTION_P (decl
));
1254 for (tree t
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
1255 t
&& t
!= void_list_node
; t
= TREE_CHAIN (t
))
1256 if (TREE_PURPOSE (t
))
1258 permerror (input_location
,
1259 "redeclaration of %q#D may not have default "
1265 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1266 && lookup_attribute ("gnu_inline", \
1267 DECL_ATTRIBUTES (fn)))
1269 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1270 If the redeclaration is invalid, a diagnostic is issued, and the
1271 error_mark_node is returned. Otherwise, OLDDECL is returned.
1273 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1276 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1279 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1281 unsigned olddecl_uid
= DECL_UID (olddecl
);
1282 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1283 int new_defines_function
= 0;
1284 tree new_template_info
;
1286 if (newdecl
== olddecl
)
1289 types_match
= decls_match (newdecl
, olddecl
);
1291 /* If either the type of the new decl or the type of the old decl is an
1292 error_mark_node, then that implies that we have already issued an
1293 error (earlier) for some bogus type specification, and in that case,
1294 it is rather pointless to harass the user with yet more error message
1295 about the same declaration, so just pretend the types match here. */
1296 if (TREE_TYPE (newdecl
) == error_mark_node
1297 || TREE_TYPE (olddecl
) == error_mark_node
)
1298 return error_mark_node
;
1300 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1301 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1303 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1304 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1305 && check_raw_literal_operator (olddecl
))
1306 error ("literal operator template %q+D conflicts with"
1307 " raw literal operator %qD", newdecl
, olddecl
);
1308 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1309 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1310 && check_raw_literal_operator (newdecl
))
1311 error ("raw literal operator %q+D conflicts with"
1312 " literal operator template %qD", newdecl
, olddecl
);
1315 if (DECL_P (olddecl
)
1316 && TREE_CODE (newdecl
) == FUNCTION_DECL
1317 && TREE_CODE (olddecl
) == FUNCTION_DECL
1318 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1320 if (DECL_DECLARED_INLINE_P (newdecl
)
1321 && DECL_UNINLINABLE (newdecl
)
1322 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1323 /* Already warned elsewhere. */;
1324 else if (DECL_DECLARED_INLINE_P (olddecl
)
1325 && DECL_UNINLINABLE (olddecl
)
1326 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1327 /* Already warned. */;
1328 else if (DECL_DECLARED_INLINE_P (newdecl
)
1329 && DECL_UNINLINABLE (olddecl
)
1330 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1332 if (warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1334 inform (DECL_SOURCE_LOCATION (olddecl
),
1335 "previous declaration of %qD with attribute noinline",
1338 else if (DECL_DECLARED_INLINE_P (olddecl
)
1339 && DECL_UNINLINABLE (newdecl
)
1340 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1342 if (warning (OPT_Wattributes
, "function %q+D redeclared with "
1343 "attribute noinline", newdecl
))
1344 inform (DECL_SOURCE_LOCATION (olddecl
),
1345 "previous declaration of %qD was inline",
1350 /* Check for redeclaration and other discrepancies. */
1351 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1352 && DECL_ARTIFICIAL (olddecl
))
1354 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1355 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1357 /* Avoid warnings redeclaring built-ins which have not been
1358 explicitly declared. */
1359 if (DECL_ANTICIPATED (olddecl
))
1362 /* If you declare a built-in or predefined function name as static,
1363 the old definition is overridden, but optionally warn this was a
1364 bad choice of name. */
1365 if (! TREE_PUBLIC (newdecl
))
1367 warning (OPT_Wshadow
,
1368 DECL_BUILT_IN (olddecl
)
1369 ? G_("shadowing built-in function %q#D")
1370 : G_("shadowing library function %q#D"), olddecl
);
1371 /* Discard the old built-in function. */
1374 /* If the built-in is not ansi, then programs can override
1375 it even globally without an error. */
1376 else if (! DECL_BUILT_IN (olddecl
))
1377 warning (0, "library function %q#D redeclared as non-function %q#D",
1380 error ("declaration of %q#D conflicts with built-in "
1381 "declaration %q#D", newdecl
, olddecl
);
1384 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl
))
1386 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl
));
1387 error_at (DECL_SOURCE_LOCATION (newdecl
),
1388 "redeclaration of %<pragma omp declare reduction%>");
1389 inform (DECL_SOURCE_LOCATION (olddecl
),
1390 "previous %<pragma omp declare reduction%> declaration");
1391 return error_mark_node
;
1393 else if (!types_match
)
1395 /* Avoid warnings redeclaring built-ins which have not been
1396 explicitly declared. */
1397 if (DECL_ANTICIPATED (olddecl
))
1399 /* Deal with fileptr_type_node. FILE type is not known
1400 at the time we create the builtins. */
1403 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1404 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1406 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1409 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1411 tree t
= TREE_VALUE (t1
);
1414 && TYPE_IDENTIFIER (TREE_TYPE (t
))
1415 == get_identifier ("FILE")
1416 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1418 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1420 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1421 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1422 types_match
= decls_match (newdecl
, olddecl
);
1424 return duplicate_decls (newdecl
, olddecl
,
1426 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1429 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1432 else if ((DECL_EXTERN_C_P (newdecl
)
1433 && DECL_EXTERN_C_P (olddecl
))
1434 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1435 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1437 /* A near match; override the builtin. */
1439 if (TREE_PUBLIC (newdecl
))
1440 warning (0, "new declaration %q#D ambiguates built-in "
1441 "declaration %q#D", newdecl
, olddecl
);
1443 warning (OPT_Wshadow
,
1444 DECL_BUILT_IN (olddecl
)
1445 ? G_("shadowing built-in function %q#D")
1446 : G_("shadowing library function %q#D"), olddecl
);
1449 /* Discard the old built-in function. */
1452 /* Replace the old RTL to avoid problems with inlining. */
1453 COPY_DECL_RTL (newdecl
, olddecl
);
1455 /* Even if the types match, prefer the new declarations type for
1456 built-ins which have not been explicitly declared, for
1457 exception lists, etc... */
1458 else if (DECL_IS_BUILTIN (olddecl
))
1460 tree type
= TREE_TYPE (newdecl
);
1461 tree attribs
= (*targetm
.merge_type_attributes
)
1462 (TREE_TYPE (olddecl
), type
);
1464 type
= cp_build_type_attribute_variant (type
, attribs
);
1465 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1468 /* If a function is explicitly declared "throw ()", propagate that to
1469 the corresponding builtin. */
1470 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1471 && DECL_ANTICIPATED (olddecl
)
1472 && TREE_NOTHROW (newdecl
)
1473 && !TREE_NOTHROW (olddecl
))
1475 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1476 tree tmpdecl
= builtin_decl_explicit (fncode
);
1477 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1478 TREE_NOTHROW (tmpdecl
) = 1;
1481 /* Whether or not the builtin can throw exceptions has no
1482 bearing on this declarator. */
1483 TREE_NOTHROW (olddecl
) = 0;
1485 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1487 /* If a builtin function is redeclared as `static', merge
1488 the declarations, but make the original one static. */
1489 DECL_THIS_STATIC (olddecl
) = 1;
1490 TREE_PUBLIC (olddecl
) = 0;
1492 /* Make the old declaration consistent with the new one so
1493 that all remnants of the builtin-ness of this function
1494 will be banished. */
1495 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1496 COPY_DECL_RTL (newdecl
, olddecl
);
1499 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1501 /* C++ Standard, 3.3, clause 4:
1502 "[Note: a namespace name or a class template name must be unique
1503 in its declarative region (7.3.2, clause 14). ]" */
1504 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1505 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1506 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1507 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1508 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1509 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1511 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1512 && TREE_CODE (newdecl
) != TYPE_DECL
)
1513 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1514 && TREE_CODE (olddecl
) != TYPE_DECL
))
1516 /* We do nothing special here, because C++ does such nasty
1517 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1518 get shadowed, and know that if we need to find a TYPE_DECL
1519 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1520 slot of the identifier. */
1524 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1525 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1526 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1527 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1531 error ("%q#D redeclared as different kind of symbol", newdecl
);
1532 if (TREE_CODE (olddecl
) == TREE_LIST
)
1533 olddecl
= TREE_VALUE (olddecl
);
1534 inform (DECL_SOURCE_LOCATION (olddecl
),
1535 "previous declaration %q#D", olddecl
);
1537 return error_mark_node
;
1539 else if (!types_match
)
1541 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1542 /* These are certainly not duplicate declarations; they're
1543 from different scopes. */
1546 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1548 /* The name of a class template may not be declared to refer to
1549 any other template, class, function, object, namespace, value,
1550 or type in the same scope. */
1551 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1552 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1554 error ("conflicting declaration of template %q#D", newdecl
);
1555 inform (DECL_SOURCE_LOCATION (olddecl
),
1556 "previous declaration %q#D", olddecl
);
1557 return error_mark_node
;
1559 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1560 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1561 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1562 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1563 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1564 DECL_TEMPLATE_PARMS (olddecl
))
1565 /* Template functions can be disambiguated by
1567 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1568 TREE_TYPE (TREE_TYPE (olddecl
))))
1570 error ("ambiguating new declaration %q#D", newdecl
);
1571 inform (DECL_SOURCE_LOCATION (olddecl
),
1572 "old declaration %q#D", olddecl
);
1576 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1578 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1580 error ("conflicting declaration of C function %q#D",
1582 inform (DECL_SOURCE_LOCATION (olddecl
),
1583 "previous declaration %q#D", olddecl
);
1586 /* For function versions, params and types match, but they
1587 are not ambiguous. */
1588 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1589 && !DECL_FUNCTION_VERSIONED (olddecl
))
1590 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1591 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1593 error ("ambiguating new declaration of %q#D", newdecl
);
1594 inform (DECL_SOURCE_LOCATION (olddecl
),
1595 "old declaration %q#D", olddecl
);
1596 return error_mark_node
;
1603 error ("conflicting declaration %q#D", newdecl
);
1604 inform (DECL_SOURCE_LOCATION (olddecl
),
1605 "previous declaration as %q#D", olddecl
);
1606 return error_mark_node
;
1609 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1610 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1611 && (!DECL_TEMPLATE_INFO (newdecl
)
1612 || (DECL_TI_TEMPLATE (newdecl
)
1613 != DECL_TI_TEMPLATE (olddecl
))))
1614 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1615 && (!DECL_TEMPLATE_INFO (olddecl
)
1616 || (DECL_TI_TEMPLATE (olddecl
)
1617 != DECL_TI_TEMPLATE (newdecl
))))))
1618 /* It's OK to have a template specialization and a non-template
1619 with the same type, or to have specializations of two
1620 different templates with the same type. Note that if one is a
1621 specialization, and the other is an instantiation of the same
1622 template, that we do not exit at this point. That situation
1623 can occur if we instantiate a template class, and then
1624 specialize one of its methods. This situation is valid, but
1625 the declarations must be merged in the usual way. */
1627 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1628 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1629 && !DECL_USE_TEMPLATE (newdecl
))
1630 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1631 && !DECL_USE_TEMPLATE (olddecl
))))
1632 /* One of the declarations is a template instantiation, and the
1633 other is not a template at all. That's OK. */
1635 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1637 /* In [namespace.alias] we have:
1639 In a declarative region, a namespace-alias-definition can be
1640 used to redefine a namespace-alias declared in that declarative
1641 region to refer only to the namespace to which it already
1644 Therefore, if we encounter a second alias directive for the same
1645 alias, we can just ignore the second directive. */
1646 if (DECL_NAMESPACE_ALIAS (newdecl
)
1647 && (DECL_NAMESPACE_ALIAS (newdecl
)
1648 == DECL_NAMESPACE_ALIAS (olddecl
)))
1650 /* [namespace.alias]
1652 A namespace-name or namespace-alias shall not be declared as
1653 the name of any other entity in the same declarative region.
1654 A namespace-name defined at global scope shall not be
1655 declared as the name of any other entity in any global scope
1657 error ("conflicting declaration of namespace %qD", newdecl
);
1658 inform (DECL_SOURCE_LOCATION (olddecl
),
1659 "previous declaration of namespace %qD here", olddecl
);
1660 return error_mark_node
;
1664 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1667 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1668 if (DECL_NAME (olddecl
) != NULL_TREE
)
1669 inform (input_location
,
1670 (DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1671 ? G_("%q+#D previously defined here")
1672 : G_("%q+#D previously declared here"), olddecl
);
1673 return error_mark_node
;
1675 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1676 && DECL_INITIAL (olddecl
) != NULL_TREE
1677 && !prototype_p (TREE_TYPE (olddecl
))
1678 && prototype_p (TREE_TYPE (newdecl
)))
1680 /* Prototype decl follows defn w/o prototype. */
1681 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), 0,
1682 "prototype specified for %q#D", newdecl
))
1683 inform (DECL_SOURCE_LOCATION (olddecl
),
1684 "previous non-prototype definition here");
1686 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1687 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1690 If two declarations of the same function or object
1691 specify different linkage-specifications ..., the program
1692 is ill-formed.... Except for functions with C++ linkage,
1693 a function declaration without a linkage specification
1694 shall not precede the first linkage specification for
1695 that function. A function can be declared without a
1696 linkage specification after an explicit linkage
1697 specification has been seen; the linkage explicitly
1698 specified in the earlier declaration is not affected by
1699 such a function declaration.
1701 DR 563 raises the question why the restrictions on
1702 functions should not also apply to objects. Older
1703 versions of G++ silently ignore the linkage-specification
1711 which is clearly wrong. Therefore, we now treat objects
1713 if (current_lang_depth () == 0)
1715 /* There is no explicit linkage-specification, so we use
1716 the linkage from the previous declaration. */
1717 if (!DECL_LANG_SPECIFIC (newdecl
))
1718 retrofit_lang_decl (newdecl
);
1719 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1723 error ("conflicting declaration of %q#D with %qL linkage",
1724 newdecl
, DECL_LANGUAGE (newdecl
));
1725 inform (DECL_SOURCE_LOCATION (olddecl
),
1726 "previous declaration with %qL linkage",
1727 DECL_LANGUAGE (olddecl
));
1731 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1733 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1735 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1736 if (DECL_FUNCTION_MEMBER_P (olddecl
)
1737 && (/* grokfndecl passes member function templates too
1738 as FUNCTION_DECLs. */
1739 DECL_TEMPLATE_INFO (olddecl
)
1741 Default arguments for a member function of a class
1742 template shall be specified on the initial declaration
1743 of the member function within the class template. */
1744 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl
))))
1745 check_redeclaration_no_default_args (newdecl
);
1748 tree t1
= FUNCTION_FIRST_USER_PARMTYPE (olddecl
);
1749 tree t2
= FUNCTION_FIRST_USER_PARMTYPE (newdecl
);
1752 for (; t1
&& t1
!= void_list_node
;
1753 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1754 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1756 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1759 if (permerror (input_location
,
1760 "default argument given for parameter "
1761 "%d of %q#D", i
, newdecl
))
1762 inform (DECL_SOURCE_LOCATION (olddecl
),
1763 "previous specification in %q#D here",
1768 error ("default argument given for parameter %d "
1769 "of %q#D", i
, newdecl
);
1770 inform (DECL_SOURCE_LOCATION (olddecl
),
1771 "previous specification in %q#D here",
1779 /* Do not merge an implicit typedef with an explicit one. In:
1783 typedef class A A __attribute__ ((foo));
1785 the attribute should apply only to the typedef. */
1786 if (TREE_CODE (olddecl
) == TYPE_DECL
1787 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1788 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1791 /* If new decl is `static' and an `extern' was seen previously,
1793 warn_extern_redeclared_static (newdecl
, olddecl
);
1795 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1796 return error_mark_node
;
1798 /* We have committed to returning 1 at this point. */
1799 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1801 /* Now that functions must hold information normally held
1802 by field decls, there is extra work to do so that
1803 declaration information does not get destroyed during
1805 if (DECL_VINDEX (olddecl
))
1806 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1807 if (DECL_CONTEXT (olddecl
))
1808 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1809 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1810 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1811 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1812 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1813 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1814 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1815 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1816 SET_OVERLOADED_OPERATOR_CODE
1817 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1818 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1820 /* Optionally warn about more than one declaration for the same
1821 name, but don't warn about a function declaration followed by a
1823 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1824 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1825 /* Don't warn about extern decl followed by definition. */
1826 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1827 /* Don't warn about friends, let add_friend take care of it. */
1828 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1829 /* Don't warn about declaration followed by specialization. */
1830 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1831 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1833 if (warning (OPT_Wredundant_decls
,
1834 "redundant redeclaration of %qD in same scope",
1836 inform (DECL_SOURCE_LOCATION (olddecl
),
1837 "previous declaration of %qD", olddecl
);
1840 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl
)
1841 && DECL_TEMPLATE_SPECIALIZATION (newdecl
)))
1843 if (DECL_DELETED_FN (newdecl
))
1845 error ("deleted definition of %qD", newdecl
);
1846 inform (DECL_SOURCE_LOCATION (olddecl
),
1847 "previous declaration of %qD", olddecl
);
1849 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1853 /* Deal with C++: must preserve virtual function table size. */
1854 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1856 tree newtype
= TREE_TYPE (newdecl
);
1857 tree oldtype
= TREE_TYPE (olddecl
);
1859 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1860 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1861 CLASSTYPE_FRIEND_CLASSES (newtype
)
1862 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1864 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1867 /* Copy all the DECL_... slots specified in the new decl
1868 except for any that we copy here from the old type. */
1869 DECL_ATTRIBUTES (newdecl
)
1870 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1872 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1876 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1877 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1878 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1879 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1880 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1881 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1883 DECL_ATTRIBUTES (old_result
)
1884 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1886 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1888 /* Per C++11 8.3.6/4, default arguments cannot be added in later
1889 declarations of a function template. */
1890 check_redeclaration_no_default_args (newdecl
);
1892 check_default_args (newdecl
);
1894 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1895 && DECL_INITIAL (new_result
))
1897 if (DECL_INITIAL (old_result
))
1898 DECL_UNINLINABLE (old_result
) = 1;
1900 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1901 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1902 DECL_NOT_REALLY_EXTERN (old_result
)
1903 = DECL_NOT_REALLY_EXTERN (new_result
);
1904 DECL_INTERFACE_KNOWN (old_result
)
1905 = DECL_INTERFACE_KNOWN (new_result
);
1906 DECL_DECLARED_INLINE_P (old_result
)
1907 = DECL_DECLARED_INLINE_P (new_result
);
1908 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1909 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1914 DECL_DECLARED_INLINE_P (old_result
)
1915 |= DECL_DECLARED_INLINE_P (new_result
);
1916 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1917 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1918 check_redeclaration_exception_specification (newdecl
, olddecl
);
1922 /* If the new declaration is a definition, update the file and
1923 line information on the declaration, and also make
1924 the old declaration the same definition. */
1925 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1927 DECL_SOURCE_LOCATION (olddecl
)
1928 = DECL_SOURCE_LOCATION (old_result
)
1929 = DECL_SOURCE_LOCATION (newdecl
);
1930 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1931 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1934 DECL_ARGUMENTS (old_result
)
1935 = DECL_ARGUMENTS (new_result
);
1936 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1937 parm
= DECL_CHAIN (parm
))
1938 DECL_CONTEXT (parm
) = old_result
;
1947 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1948 check_redeclaration_exception_specification (newdecl
, olddecl
);
1950 /* Automatically handles default parameters. */
1951 tree oldtype
= TREE_TYPE (olddecl
);
1954 /* For typedefs use the old type, as the new type's DECL_NAME points
1955 at newdecl, which will be ggc_freed. */
1956 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1959 /* Merge the data types specified in the two decls. */
1960 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1962 if (VAR_P (newdecl
))
1964 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1965 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1966 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1967 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1968 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1969 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1971 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1972 if (DECL_LANG_SPECIFIC (olddecl
)
1973 && CP_DECL_THREADPRIVATE_P (olddecl
))
1975 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1976 if (!DECL_LANG_SPECIFIC (newdecl
))
1977 retrofit_lang_decl (newdecl
);
1979 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1983 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1985 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1986 check_default_args (newdecl
);
1988 /* Lay the type out, unless already done. */
1989 if (! same_type_p (newtype
, oldtype
)
1990 && TREE_TYPE (newdecl
) != error_mark_node
1991 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1992 layout_type (TREE_TYPE (newdecl
));
1994 if ((VAR_P (newdecl
)
1995 || TREE_CODE (newdecl
) == PARM_DECL
1996 || TREE_CODE (newdecl
) == RESULT_DECL
1997 || TREE_CODE (newdecl
) == FIELD_DECL
1998 || TREE_CODE (newdecl
) == TYPE_DECL
)
1999 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
2000 layout_decl (newdecl
, 0);
2002 /* Merge the type qualifiers. */
2003 if (TREE_READONLY (newdecl
))
2004 TREE_READONLY (olddecl
) = 1;
2005 if (TREE_THIS_VOLATILE (newdecl
))
2006 TREE_THIS_VOLATILE (olddecl
) = 1;
2007 if (TREE_NOTHROW (newdecl
))
2008 TREE_NOTHROW (olddecl
) = 1;
2010 /* Merge deprecatedness. */
2011 if (TREE_DEPRECATED (newdecl
))
2012 TREE_DEPRECATED (olddecl
) = 1;
2014 /* Preserve function specific target and optimization options */
2015 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2017 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
2018 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
2019 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
2020 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
2022 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
2023 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
2024 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
2025 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
2028 /* Merge the initialization information. */
2029 if (DECL_INITIAL (newdecl
) == NULL_TREE
2030 && DECL_INITIAL (olddecl
) != NULL_TREE
)
2032 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
2033 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
2034 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2036 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
2037 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
2041 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2043 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
2044 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
2045 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
2046 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
2047 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
2048 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
2049 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
2050 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
2051 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
2052 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
2053 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
2054 /* Keep the old RTL. */
2055 COPY_DECL_RTL (olddecl
, newdecl
);
2057 else if (VAR_P (newdecl
)
2058 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
2060 /* Keep the old RTL. We cannot keep the old RTL if the old
2061 declaration was for an incomplete object and the new
2062 declaration is not since many attributes of the RTL will
2064 COPY_DECL_RTL (olddecl
, newdecl
);
2067 /* If cannot merge, then use the new type and qualifiers,
2068 and don't preserve the old rtl. */
2071 /* Clean out any memory we had of the old declaration. */
2072 tree oldstatic
= value_member (olddecl
, static_aggregates
);
2074 TREE_VALUE (oldstatic
) = error_mark_node
;
2076 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
2077 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
2078 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
2079 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2082 /* Merge the storage class information. */
2083 merge_weak (newdecl
, olddecl
);
2085 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2086 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2087 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2088 if (! DECL_EXTERNAL (olddecl
))
2089 DECL_EXTERNAL (newdecl
) = 0;
2091 new_template_info
= NULL_TREE
;
2092 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2094 bool new_redefines_gnu_inline
= false;
2096 if (new_defines_function
2097 && ((DECL_INTERFACE_KNOWN (olddecl
)
2098 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2099 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2100 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2101 == FUNCTION_DECL
))))
2105 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2106 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2108 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2111 if (!new_redefines_gnu_inline
)
2113 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2114 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2115 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2117 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2118 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2119 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2121 /* If the OLDDECL is an instantiation and/or specialization,
2122 then the NEWDECL must be too. But, it may not yet be marked
2123 as such if the caller has created NEWDECL, but has not yet
2124 figured out that it is a redeclaration. */
2125 if (!DECL_USE_TEMPLATE (newdecl
))
2126 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2128 /* Don't really know how much of the language-specific
2129 values we should copy from old to new. */
2130 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2131 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2132 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2133 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2135 if (LANG_DECL_HAS_MIN (newdecl
))
2137 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2138 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2139 if (DECL_TEMPLATE_INFO (newdecl
))
2141 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2142 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2143 && DECL_TEMPLATE_SPECIALIZATION (newdecl
))
2144 /* Remember the presence of explicit specialization args. */
2145 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl
))
2146 = TINFO_USED_TEMPLATE_ID (new_template_info
);
2148 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2150 /* Only functions have these fields. */
2151 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2153 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2154 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2155 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2156 && DECL_HIDDEN_FRIEND_P (olddecl
)
2157 && newdecl_is_friend
);
2158 DECL_BEFRIENDING_CLASSES (newdecl
)
2159 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2160 DECL_BEFRIENDING_CLASSES (olddecl
));
2161 /* DECL_THUNKS is only valid for virtual functions,
2162 otherwise it is a DECL_FRIEND_CONTEXT. */
2163 if (DECL_VIRTUAL_P (newdecl
))
2164 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2166 /* Only variables have this field. */
2167 else if (VAR_P (newdecl
)
2168 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2169 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2172 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2176 /* Merge parameter attributes. */
2177 tree oldarg
, newarg
;
2178 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2179 newarg
= DECL_ARGUMENTS(newdecl
);
2181 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2182 DECL_ATTRIBUTES (newarg
)
2183 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2184 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2187 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2188 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2190 /* If newdecl is not a specialization, then it is not a
2191 template-related function at all. And that means that we
2192 should have exited above, returning 0. */
2193 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2195 if (DECL_ODR_USED (olddecl
))
2196 /* From [temp.expl.spec]:
2198 If a template, a member template or the member of a class
2199 template is explicitly specialized then that
2200 specialization shall be declared before the first use of
2201 that specialization that would cause an implicit
2202 instantiation to take place, in every translation unit in
2203 which such a use occurs. */
2204 error ("explicit specialization of %qD after first use",
2207 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2208 DECL_COMDAT (newdecl
) = (TREE_PUBLIC (newdecl
)
2209 && DECL_DECLARED_INLINE_P (newdecl
));
2211 /* Don't propagate visibility from the template to the
2212 specialization here. We'll do that in determine_visibility if
2214 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2216 /* [temp.expl.spec/14] We don't inline explicit specialization
2217 just because the primary template says so. */
2219 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2220 the always_inline attribute. */
2221 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2222 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2224 if (DECL_DECLARED_INLINE_P (newdecl
))
2225 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2227 DECL_ATTRIBUTES (newdecl
)
2228 = remove_attribute ("always_inline",
2229 DECL_ATTRIBUTES (newdecl
));
2232 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2234 /* Never inline re-defined extern inline functions.
2235 FIXME: this could be better handled by keeping both
2236 function as separate declarations. */
2237 DECL_UNINLINABLE (newdecl
) = 1;
2241 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2242 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2244 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2246 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2247 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2249 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2250 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2251 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2252 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2255 /* Preserve abstractness on cloned [cd]tors. */
2256 DECL_ABSTRACT_P (newdecl
) = DECL_ABSTRACT_P (olddecl
);
2258 /* Update newdecl's parms to point at olddecl. */
2259 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2260 parm
= DECL_CHAIN (parm
))
2261 DECL_CONTEXT (parm
) = olddecl
;
2265 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2266 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2267 COPY_DECL_RTL (newdecl
, olddecl
);
2269 if (! types_match
|| new_defines_function
)
2271 /* These need to be copied so that the names are available.
2272 Note that if the types do match, we'll preserve inline
2273 info and other bits, but if not, we won't. */
2274 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2275 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2277 /* If redeclaring a builtin function, it stays built in
2278 if newdecl is a gnu_inline definition, or if newdecl is just
2280 if (DECL_BUILT_IN (olddecl
)
2281 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2283 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2284 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2285 /* If we're keeping the built-in definition, keep the rtl,
2286 regardless of declaration matches. */
2287 COPY_DECL_RTL (olddecl
, newdecl
);
2288 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2290 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2293 /* If a compatible prototype of these builtin functions
2294 is seen, assume the runtime implements it with the
2295 expected semantics. */
2296 case BUILT_IN_STPCPY
:
2297 if (builtin_decl_explicit_p (fncode
))
2298 set_builtin_decl_implicit_p (fncode
, true);
2305 if (new_defines_function
)
2306 /* If defining a function declared with other language
2307 linkage, use the previously declared language linkage. */
2308 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2309 else if (types_match
)
2311 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2312 /* Don't clear out the arguments if we're just redeclaring a
2314 if (DECL_ARGUMENTS (olddecl
))
2315 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2318 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2319 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2321 /* Now preserve various other info from the definition. */
2322 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2323 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2324 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2325 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2327 /* Warn about conflicting visibility specifications. */
2328 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2329 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2330 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2332 if (warning_at (DECL_SOURCE_LOCATION (newdecl
), OPT_Wattributes
,
2333 "%qD: visibility attribute ignored because it "
2334 "conflicts with previous declaration", newdecl
))
2335 inform (DECL_SOURCE_LOCATION (olddecl
),
2336 "previous declaration of %qD", olddecl
);
2338 /* Choose the declaration which specified visibility. */
2339 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2341 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2342 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2344 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2345 so keep this behavior. */
2346 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2348 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2349 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2351 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2352 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2354 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2355 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2357 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2358 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2359 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2361 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2362 with that from NEWDECL below. */
2363 if (DECL_LANG_SPECIFIC (olddecl
))
2365 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2366 != DECL_LANG_SPECIFIC (newdecl
));
2367 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2370 /* Merge the USED information. */
2371 if (TREE_USED (olddecl
))
2372 TREE_USED (newdecl
) = 1;
2373 else if (TREE_USED (newdecl
))
2374 TREE_USED (olddecl
) = 1;
2375 if (VAR_P (newdecl
))
2377 if (DECL_READ_P (olddecl
))
2378 DECL_READ_P (newdecl
) = 1;
2379 else if (DECL_READ_P (newdecl
))
2380 DECL_READ_P (olddecl
) = 1;
2382 if (DECL_PRESERVE_P (olddecl
))
2383 DECL_PRESERVE_P (newdecl
) = 1;
2384 else if (DECL_PRESERVE_P (newdecl
))
2385 DECL_PRESERVE_P (olddecl
) = 1;
2387 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2388 to olddecl and deleted. */
2389 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2390 && DECL_FUNCTION_VERSIONED (olddecl
))
2392 /* Set the flag for newdecl so that it gets copied to olddecl. */
2393 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2394 /* newdecl will be purged after copying to olddecl and is no longer
2396 cgraph_node::delete_function_version (newdecl
);
2399 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2402 struct symtab_node
*snode
= symtab_node::get (olddecl
);
2404 function_size
= sizeof (struct tree_decl_common
);
2406 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2407 (char *) newdecl
+ sizeof (struct tree_common
),
2408 function_size
- sizeof (struct tree_common
));
2410 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2411 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2412 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2414 /* Preserve symtab node mapping. */
2415 olddecl
->decl_with_vis
.symtab_node
= snode
;
2417 if (new_template_info
)
2418 /* If newdecl is a template instantiation, it is possible that
2419 the following sequence of events has occurred:
2421 o A friend function was declared in a class template. The
2422 class template was instantiated.
2424 o The instantiation of the friend declaration was
2425 recorded on the instantiation list, and is newdecl.
2427 o Later, however, instantiate_class_template called pushdecl
2428 on the newdecl to perform name injection. But, pushdecl in
2429 turn called duplicate_decls when it discovered that another
2430 declaration of a global function with the same name already
2433 o Here, in duplicate_decls, we decided to clobber newdecl.
2435 If we're going to do that, we'd better make sure that
2436 olddecl, and not newdecl, is on the list of
2437 instantiations so that if we try to do the instantiation
2438 again we won't get the clobbered declaration. */
2439 reregister_specialization (newdecl
,
2445 size_t size
= tree_code_size (TREE_CODE (newdecl
));
2447 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2448 (char *) newdecl
+ sizeof (struct tree_common
),
2449 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2450 switch (TREE_CODE (newdecl
))
2460 struct symtab_node
*snode
= NULL
;
2462 if (TREE_CODE (newdecl
) == VAR_DECL
2463 && (TREE_STATIC (olddecl
) || TREE_PUBLIC (olddecl
) || DECL_EXTERNAL (olddecl
)))
2464 snode
= symtab_node::get (olddecl
);
2465 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2466 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2467 size
- sizeof (struct tree_decl_common
)
2468 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2469 if (TREE_CODE (newdecl
) == VAR_DECL
)
2470 olddecl
->decl_with_vis
.symtab_node
= snode
;
2474 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2475 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2476 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2477 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2482 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2483 || TREE_CODE (newdecl
) == VAR_DECL
)
2485 if (DECL_EXTERNAL (olddecl
)
2486 || TREE_PUBLIC (olddecl
)
2487 || TREE_STATIC (olddecl
))
2489 /* Merge the section attribute.
2490 We want to issue an error if the sections conflict but that must be
2491 done later in decl_attributes since we are called before attributes
2493 if (DECL_SECTION_NAME (newdecl
) != NULL
)
2494 set_decl_section_name (olddecl
, DECL_SECTION_NAME (newdecl
));
2496 if (DECL_ONE_ONLY (newdecl
))
2498 struct symtab_node
*oldsym
, *newsym
;
2499 if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
2500 oldsym
= cgraph_node::get_create (olddecl
);
2502 oldsym
= varpool_node::get_create (olddecl
);
2503 newsym
= symtab_node::get (newdecl
);
2504 oldsym
->set_comdat_group (newsym
->get_comdat_group ());
2508 if (TREE_CODE (newdecl
) == VAR_DECL
2509 && DECL_THREAD_LOCAL_P (newdecl
))
2510 set_decl_tls_model (olddecl
, DECL_TLS_MODEL (newdecl
));
2513 DECL_UID (olddecl
) = olddecl_uid
;
2515 DECL_FRIEND_P (olddecl
) = 1;
2518 DECL_ANTICIPATED (olddecl
) = 1;
2519 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2522 /* NEWDECL contains the merged attribute lists.
2523 Update OLDDECL to be the same. */
2524 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2526 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2527 so that encode_section_info has a chance to look at the new decl
2528 flags and attributes. */
2529 if (DECL_RTL_SET_P (olddecl
)
2530 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2532 && TREE_STATIC (olddecl
))))
2533 make_decl_rtl (olddecl
);
2535 /* The NEWDECL will no longer be needed. Because every out-of-class
2536 declaration of a member results in a call to duplicate_decls,
2537 freeing these nodes represents in a significant savings.
2539 Before releasing the node, be sore to remove function from symbol
2540 table that might have been inserted there to record comdat group.
2541 Be sure to however do not free DECL_STRUCT_FUNCTION becuase this
2542 structure is shared in between newdecl and oldecl. */
2543 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2544 DECL_STRUCT_FUNCTION (newdecl
) = NULL
;
2545 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2546 || TREE_CODE (newdecl
) == VAR_DECL
)
2548 struct symtab_node
*snode
= symtab_node::get (newdecl
);
2557 /* Return zero if the declaration NEWDECL is valid
2558 when the declaration OLDDECL (assumed to be for the same name)
2559 has already been seen.
2560 Otherwise return an error message format string with a %s
2561 where the identifier should go. */
2564 redeclaration_error_message (tree newdecl
, tree olddecl
)
2566 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2568 /* Because C++ can put things into name space for free,
2569 constructs like "typedef struct foo { ... } foo"
2570 would look like an erroneous redeclaration. */
2571 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2574 return G_("redefinition of %q#D");
2576 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2578 /* If this is a pure function, its olddecl will actually be
2579 the original initialization to `0' (which we force to call
2580 abort()). Don't complain about redefinition in this case. */
2581 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2582 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2585 /* If both functions come from different namespaces, this is not
2586 a redeclaration - this is a conflict with a used function. */
2587 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2588 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2589 && ! decls_match (olddecl
, newdecl
))
2590 return G_("%qD conflicts with used function");
2592 /* We'll complain about linkage mismatches in
2593 warn_extern_redeclared_static. */
2595 /* Defining the same name twice is no good. */
2596 if (DECL_INITIAL (olddecl
) != NULL_TREE
2597 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2599 if (DECL_NAME (olddecl
) == NULL_TREE
)
2600 return G_("%q#D not declared in class");
2601 else if (!GNU_INLINE_P (olddecl
)
2602 || GNU_INLINE_P (newdecl
))
2603 return G_("redefinition of %q#D");
2606 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2608 bool olda
= GNU_INLINE_P (olddecl
);
2609 bool newa
= GNU_INLINE_P (newdecl
);
2614 return G_("%q+D redeclared inline with "
2615 "%<gnu_inline%> attribute");
2617 return G_("%q+D redeclared inline without "
2618 "%<gnu_inline%> attribute");
2622 check_abi_tag_redeclaration
2623 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2624 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2628 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2632 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2634 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2635 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2636 return G_("redefinition of %q#D");
2640 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2641 || (DECL_TEMPLATE_RESULT (newdecl
)
2642 == DECL_TEMPLATE_RESULT (olddecl
)))
2645 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2646 if (DECL_TEMPLATE_INFO (nt
))
2647 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2648 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2649 if (DECL_TEMPLATE_INFO (ot
))
2650 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2651 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2652 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2653 return G_("redefinition of %q#D");
2655 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2657 bool olda
= GNU_INLINE_P (ot
);
2658 bool newa
= GNU_INLINE_P (nt
);
2663 return G_("%q+D redeclared inline with "
2664 "%<gnu_inline%> attribute");
2666 return G_("%q+D redeclared inline without "
2667 "%<gnu_inline%> attribute");
2671 /* Core issue #226 (C++0x):
2673 If a friend function template declaration specifies a
2674 default template-argument, that declaration shall be a
2675 definition and shall be the only declaration of the
2676 function template in the translation unit. */
2677 if ((cxx_dialect
!= cxx98
)
2678 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2679 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2680 /*is_primary=*/true,
2681 /*is_partial=*/false,
2682 /*is_friend_decl=*/2))
2683 return G_("redeclaration of friend %q#D "
2684 "may not have default template arguments");
2688 else if (VAR_P (newdecl
)
2689 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2690 && (! DECL_LANG_SPECIFIC (olddecl
)
2691 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2692 || DECL_THREAD_LOCAL_P (newdecl
)))
2694 /* Only variables can be thread-local, and all declarations must
2695 agree on this property. */
2696 if (DECL_THREAD_LOCAL_P (newdecl
))
2697 return G_("thread-local declaration of %q#D follows "
2698 "non-thread-local declaration");
2700 return G_("non-thread-local declaration of %q#D follows "
2701 "thread-local declaration");
2703 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2705 /* The objects have been declared at namespace scope. If either
2706 is a member of an anonymous union, then this is an invalid
2707 redeclaration. For example:
2713 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2714 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2715 return G_("redeclaration of %q#D");
2716 /* If at least one declaration is a reference, there is no
2717 conflict. For example:
2723 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2725 /* Reject two definitions. */
2726 return G_("redefinition of %q#D");
2730 /* Objects declared with block scope: */
2731 /* Reject two definitions, and reject a definition
2732 together with an external reference. */
2733 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2734 return G_("redeclaration of %q#D");
2739 /* Hash and equality functions for the named_label table. */
2742 named_label_hasher::hash (named_label_entry
*ent
)
2744 return DECL_UID (ent
->label_decl
);
2748 named_label_hasher::equal (named_label_entry
*a
, named_label_entry
*b
)
2750 return a
->label_decl
== b
->label_decl
;
2753 /* Create a new label, named ID. */
2756 make_label_decl (tree id
, int local_p
)
2758 struct named_label_entry
*ent
;
2761 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2763 DECL_CONTEXT (decl
) = current_function_decl
;
2764 DECL_MODE (decl
) = VOIDmode
;
2765 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2767 /* Say where one reference is to the label, for the sake of the
2768 error if it is not defined. */
2769 DECL_SOURCE_LOCATION (decl
) = input_location
;
2771 /* Record the fact that this identifier is bound to this label. */
2772 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2774 /* Create the label htab for the function on demand. */
2776 named_labels
= hash_table
<named_label_hasher
>::create_ggc (13);
2778 /* Record this label on the list of labels used in this function.
2779 We do this before calling make_label_decl so that we get the
2780 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2781 ent
= ggc_cleared_alloc
<named_label_entry
> ();
2782 ent
->label_decl
= decl
;
2784 named_label_entry
**slot
= named_labels
->find_slot (ent
, INSERT
);
2785 gcc_assert (*slot
== NULL
);
2791 /* Look for a label named ID in the current function. If one cannot
2792 be found, create one. (We keep track of used, but undefined,
2793 labels, and complain about them at the end of a function.) */
2796 lookup_label_1 (tree id
)
2800 /* You can't use labels at global scope. */
2801 if (current_function_decl
== NULL_TREE
)
2803 error ("label %qE referenced outside of any function", id
);
2807 /* See if we've already got this label. */
2808 decl
= IDENTIFIER_LABEL_VALUE (id
);
2809 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2812 decl
= make_label_decl (id
, /*local_p=*/0);
2816 /* Wrapper for lookup_label_1. */
2819 lookup_label (tree id
)
2822 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2823 ret
= lookup_label_1 (id
);
2824 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2828 /* Declare a local label named ID. */
2831 declare_local_label (tree id
)
2834 cp_label_binding bind
;
2836 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2837 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2838 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2840 decl
= make_label_decl (id
, /*local_p=*/1);
2842 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2847 /* Returns nonzero if it is ill-formed to jump past the declaration of
2848 DECL. Returns 2 if it's also a real problem. */
2851 decl_jump_unsafe (tree decl
)
2853 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2854 with automatic storage duration is not in scope to a point where it is
2855 in scope is ill-formed unless the variable has scalar type, class type
2856 with a trivial default constructor and a trivial destructor, a
2857 cv-qualified version of one of these types, or an array of one of the
2858 preceding types and is declared without an initializer (8.5). */
2859 tree type
= TREE_TYPE (decl
);
2861 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2862 || type
== error_mark_node
)
2865 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
)
2866 || variably_modified_type_p (type
, NULL_TREE
))
2869 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
2875 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2878 identify_goto (tree decl
, const location_t
*locus
)
2880 bool complained
= (decl
2881 ? permerror (input_location
, "jump to label %qD", decl
)
2882 : permerror (input_location
, "jump to case label"));
2883 if (complained
&& locus
)
2884 inform (*locus
, " from here");
2888 /* Check that a single previously seen jump to a newly defined label
2889 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2890 the jump context; NAMES are the names in scope in LEVEL at the jump
2891 context; LOCUS is the source position of the jump or 0. Returns
2892 true if all is well. */
2895 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2896 bool exited_omp
, const location_t
*locus
)
2898 cp_binding_level
*b
;
2899 bool identified
= false, complained
= false;
2900 bool saw_eh
= false, saw_omp
= false;
2904 complained
= identify_goto (decl
, locus
);
2906 inform (input_location
, " exits OpenMP structured block");
2907 identified
= saw_omp
= true;
2910 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2912 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2914 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2915 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2916 : TREE_CHAIN (new_decls
)))
2918 int problem
= decl_jump_unsafe (new_decls
);
2924 complained
= identify_goto (decl
, locus
);
2930 inform (input_location
,
2931 " crosses initialization of %q+#D", new_decls
);
2933 inform (input_location
, " enters scope of %q+#D which has "
2934 "non-trivial destructor", new_decls
);
2940 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2944 complained
= identify_goto (decl
, locus
);
2949 if (b
->kind
== sk_try
)
2950 inform (input_location
, " enters try block");
2952 inform (input_location
, " enters catch block");
2956 if (b
->kind
== sk_omp
&& !saw_omp
)
2960 complained
= identify_goto (decl
, locus
);
2964 inform (input_location
, " enters OpenMP structured block");
2973 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2975 check_previous_goto_1 (decl
, use
->binding_level
,
2976 use
->names_in_scope
, use
->in_omp_scope
,
2977 &use
->o_goto_locus
);
2981 check_switch_goto (cp_binding_level
* level
)
2983 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2986 /* Check that a new jump to a label DECL is OK. Called by
2987 finish_goto_stmt. */
2990 check_goto (tree decl
)
2992 struct named_label_entry
*ent
, dummy
;
2993 bool saw_catch
= false, identified
= false, complained
= false;
2997 /* We can't know where a computed goto is jumping.
2998 So we assume that it's OK. */
2999 if (TREE_CODE (decl
) != LABEL_DECL
)
3002 /* We didn't record any information about this label when we created it,
3003 and there's not much point since it's trivial to analyze as a return. */
3004 if (decl
== cdtor_label
)
3007 dummy
.label_decl
= decl
;
3008 ent
= named_labels
->find (&dummy
);
3009 gcc_assert (ent
!= NULL
);
3011 /* If the label hasn't been defined yet, defer checking. */
3012 if (! DECL_INITIAL (decl
))
3014 struct named_label_use_entry
*new_use
;
3016 /* Don't bother creating another use if the last goto had the
3017 same data, and will therefore create the same set of errors. */
3019 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
3022 new_use
= ggc_alloc
<named_label_use_entry
> ();
3023 new_use
->binding_level
= current_binding_level
;
3024 new_use
->names_in_scope
= current_binding_level
->names
;
3025 new_use
->o_goto_locus
= input_location
;
3026 new_use
->in_omp_scope
= false;
3028 new_use
->next
= ent
->uses
;
3029 ent
->uses
= new_use
;
3033 if (ent
->in_try_scope
|| ent
->in_catch_scope
3034 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
3036 complained
= permerror (input_location
, "jump to label %q+D", decl
);
3038 inform (input_location
, " from here");
3042 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
3044 int u
= decl_jump_unsafe (bad
);
3046 if (u
> 1 && DECL_ARTIFICIAL (bad
))
3048 /* Can't skip init of __exception_info. */
3050 inform (DECL_SOURCE_LOCATION (bad
), " enters catch block");
3053 else if (complained
)
3056 inform (input_location
, " skips initialization of %q+#D", bad
);
3058 inform (input_location
, " enters scope of %q+#D which has "
3059 "non-trivial destructor", bad
);
3065 if (ent
->in_try_scope
)
3066 inform (input_location
, " enters try block");
3067 else if (ent
->in_catch_scope
&& !saw_catch
)
3068 inform (input_location
, " enters catch block");
3071 if (ent
->in_omp_scope
)
3074 inform (input_location
, " enters OpenMP structured block");
3076 else if (flag_openmp
)
3078 cp_binding_level
*b
;
3079 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3081 if (b
== ent
->binding_level
)
3083 if (b
->kind
== sk_omp
)
3087 complained
= permerror (input_location
,
3088 "jump to label %q+D", decl
);
3090 inform (input_location
, " from here");
3094 inform (input_location
, " exits OpenMP structured block");
3101 /* Check that a return is ok wrt OpenMP structured blocks.
3102 Called by finish_return_stmt. Returns true if all is well. */
3105 check_omp_return (void)
3107 cp_binding_level
*b
;
3108 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
3109 if (b
->kind
== sk_omp
)
3111 error ("invalid exit from OpenMP structured block");
3114 else if (b
->kind
== sk_function_parms
)
3119 /* Define a label, specifying the location in the source file.
3120 Return the LABEL_DECL node for the label. */
3123 define_label_1 (location_t location
, tree name
)
3125 struct named_label_entry
*ent
, dummy
;
3126 cp_binding_level
*p
;
3129 decl
= lookup_label (name
);
3131 dummy
.label_decl
= decl
;
3132 ent
= named_labels
->find (&dummy
);
3133 gcc_assert (ent
!= NULL
);
3135 /* After labels, make any new cleanups in the function go into their
3136 own new (temporary) binding contour. */
3137 for (p
= current_binding_level
;
3138 p
->kind
!= sk_function_parms
;
3140 p
->more_cleanups_ok
= 0;
3142 if (name
== get_identifier ("wchar_t"))
3143 permerror (input_location
, "label named wchar_t");
3145 if (DECL_INITIAL (decl
) != NULL_TREE
)
3147 error ("duplicate label %qD", decl
);
3148 return error_mark_node
;
3152 struct named_label_use_entry
*use
;
3154 /* Mark label as having been defined. */
3155 DECL_INITIAL (decl
) = error_mark_node
;
3156 /* Say where in the source. */
3157 DECL_SOURCE_LOCATION (decl
) = location
;
3159 ent
->binding_level
= current_binding_level
;
3160 ent
->names_in_scope
= current_binding_level
->names
;
3162 for (use
= ent
->uses
; use
; use
= use
->next
)
3163 check_previous_goto (decl
, use
);
3170 /* Wrapper for define_label_1. */
3173 define_label (location_t location
, tree name
)
3176 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3177 ret
= define_label_1 (location
, name
);
3178 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3185 cp_binding_level
*level
;
3186 struct cp_switch
*next
;
3187 /* The SWITCH_STMT being built. */
3189 /* A splay-tree mapping the low element of a case range to the high
3190 element, or NULL_TREE if there is no high element. Used to
3191 determine whether or not a new case label duplicates an old case
3192 label. We need a tree, rather than simply a hash table, because
3193 of the GNU case range extension. */
3197 /* A stack of the currently active switch statements. The innermost
3198 switch statement is on the top of the stack. There is no need to
3199 mark the stack for garbage collection because it is only active
3200 during the processing of the body of a function, and we never
3201 collect at that point. */
3203 static struct cp_switch
*switch_stack
;
3205 /* Called right after a switch-statement condition is parsed.
3206 SWITCH_STMT is the switch statement being parsed. */
3209 push_switch (tree switch_stmt
)
3211 struct cp_switch
*p
= XNEW (struct cp_switch
);
3212 p
->level
= current_binding_level
;
3213 p
->next
= switch_stack
;
3214 p
->switch_stmt
= switch_stmt
;
3215 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3222 struct cp_switch
*cs
= switch_stack
;
3223 location_t switch_location
;
3225 /* Emit warnings as needed. */
3226 switch_location
= EXPR_LOC_OR_LOC (cs
->switch_stmt
, input_location
);
3227 if (!processing_template_decl
)
3228 c_do_switch_warnings (cs
->cases
, switch_location
,
3229 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3230 SWITCH_STMT_COND (cs
->switch_stmt
));
3232 splay_tree_delete (cs
->cases
);
3233 switch_stack
= switch_stack
->next
;
3237 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3238 condition. Note that if TYPE and VALUE are already integral we don't
3239 really do the conversion because the language-independent
3240 warning/optimization code will work better that way. */
3243 case_conversion (tree type
, tree value
)
3245 if (value
== NULL_TREE
)
3248 if (cxx_dialect
>= cxx11
3249 && (SCOPED_ENUM_P (type
)
3250 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3252 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3253 type
= type_promotes_to (type
);
3254 value
= (perform_implicit_conversion_flags
3255 (type
, value
, tf_warning_or_error
,
3256 LOOKUP_IMPLICIT
| LOOKUP_NO_NON_INTEGRAL
));
3258 return cxx_constant_value (value
);
3261 /* Note that we've seen a definition of a case label, and complain if this
3262 is a bad place for one. */
3265 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3268 cp_binding_level
*p
;
3271 if (processing_template_decl
)
3275 /* For templates, just add the case label; we'll do semantic
3276 analysis at instantiation-time. */
3277 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3278 return add_stmt (build_case_label (low_value
, high_value
, label
));
3281 /* Find the condition on which this switch statement depends. */
3282 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3283 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3284 cond
= TREE_VALUE (cond
);
3286 if (!check_switch_goto (switch_stack
->level
))
3287 return error_mark_node
;
3289 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3291 low_value
= case_conversion (type
, low_value
);
3292 high_value
= case_conversion (type
, high_value
);
3294 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3295 low_value
, high_value
);
3297 /* After labels, make any new cleanups in the function go into their
3298 own new (temporary) binding contour. */
3299 for (p
= current_binding_level
;
3300 p
->kind
!= sk_function_parms
;
3302 p
->more_cleanups_ok
= 0;
3307 struct typename_info
{
3315 struct typename_hasher
: ggc_hasher
<tree
>
3317 typedef typename_info
*compare_type
;
3319 /* Hash a TYPENAME_TYPE. */
3326 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3327 ^ htab_hash_pointer (TYPE_IDENTIFIER (t
)));
3332 /* Compare two TYPENAME_TYPEs. */
3335 equal (tree t1
, const typename_info
*t2
)
3337 return (TYPE_IDENTIFIER (t1
) == t2
->name
3338 && TYPE_CONTEXT (t1
) == t2
->scope
3339 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3340 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3341 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3345 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3346 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3348 Returns the new TYPENAME_TYPE. */
3350 static GTY (()) hash_table
<typename_hasher
> *typename_htab
;
3353 build_typename_type (tree context
, tree name
, tree fullname
,
3354 enum tag_types tag_type
)
3362 if (typename_htab
== NULL
)
3363 typename_htab
= hash_table
<typename_hasher
>::create_ggc (61);
3365 ti
.scope
= FROB_CONTEXT (context
);
3367 ti
.template_id
= fullname
;
3368 ti
.enum_p
= tag_type
== enum_type
;
3369 ti
.class_p
= (tag_type
== class_type
3370 || tag_type
== record_type
3371 || tag_type
== union_type
);
3372 hash
= (htab_hash_pointer (ti
.scope
)
3373 ^ htab_hash_pointer (ti
.name
));
3375 /* See if we already have this type. */
3376 e
= typename_htab
->find_slot_with_hash (&ti
, hash
, INSERT
);
3381 /* Build the TYPENAME_TYPE. */
3382 t
= cxx_make_type (TYPENAME_TYPE
);
3383 TYPE_CONTEXT (t
) = ti
.scope
;
3384 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3385 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3386 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3388 /* Build the corresponding TYPE_DECL. */
3389 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3390 TYPE_NAME (TREE_TYPE (d
)) = d
;
3391 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3392 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3393 DECL_ARTIFICIAL (d
) = 1;
3395 /* Store it in the hash table. */
3398 /* TYPENAME_TYPEs must always be compared structurally, because
3399 they may or may not resolve down to another type depending on
3400 the currently open classes. */
3401 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3407 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3408 provided to name the type. Returns an appropriate type, unless an
3409 error occurs, in which case error_mark_node is returned. If we
3410 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3411 return that, rather than the _TYPE it corresponds to, in other
3412 cases we look through the type decl. If TF_ERROR is set, complain
3413 about errors, otherwise be quiet. */
3416 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3417 tsubst_flags_t complain
)
3423 if (name
== error_mark_node
3424 || context
== NULL_TREE
3425 || context
== error_mark_node
)
3426 return error_mark_node
;
3430 if (!(TYPE_LANG_SPECIFIC (name
)
3431 && (CLASSTYPE_IS_TEMPLATE (name
)
3432 || CLASSTYPE_USE_TEMPLATE (name
))))
3433 name
= TYPE_IDENTIFIER (name
);
3435 /* Create a TEMPLATE_ID_EXPR for the type. */
3436 name
= build_nt (TEMPLATE_ID_EXPR
,
3437 CLASSTYPE_TI_TEMPLATE (name
),
3438 CLASSTYPE_TI_ARGS (name
));
3440 else if (TREE_CODE (name
) == TYPE_DECL
)
3441 name
= DECL_NAME (name
);
3445 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3447 name
= TREE_OPERAND (name
, 0);
3448 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3449 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3450 else if (TREE_CODE (name
) == OVERLOAD
)
3452 if (complain
& tf_error
)
3453 error ("%qD is not a type", name
);
3454 return error_mark_node
;
3457 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3459 if (complain
& tf_error
)
3460 error ("%qD used without template parameters", name
);
3461 return error_mark_node
;
3463 gcc_assert (identifier_p (name
));
3464 gcc_assert (TYPE_P (context
));
3466 if (!MAYBE_CLASS_TYPE_P (context
))
3468 if (complain
& tf_error
)
3469 error ("%q#T is not a class", context
);
3470 return error_mark_node
;
3473 /* When the CONTEXT is a dependent type, NAME could refer to a
3474 dependent base class of CONTEXT. But look inside it anyway
3475 if CONTEXT is a currently open scope, in case it refers to a
3476 member of the current instantiation or a non-dependent base;
3477 lookup will stop when we hit a dependent base. */
3478 if (!dependent_scope_p (context
))
3479 /* We should only set WANT_TYPE when we're a nested typename type.
3480 Then we can give better diagnostics if we find a non-type. */
3481 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3485 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3486 return build_typename_type (context
, name
, fullname
, tag_type
);
3488 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3492 if (complain
& tf_error
)
3493 error (want_template
? G_("no class template named %q#T in %q#T")
3494 : G_("no type named %q#T in %q#T"), name
, context
);
3495 return error_mark_node
;
3498 /* Pull out the template from an injected-class-name (or multiple). */
3500 t
= maybe_get_template_decl_from_type_decl (t
);
3502 if (TREE_CODE (t
) == TREE_LIST
)
3504 if (complain
& tf_error
)
3506 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3507 print_candidates (t
);
3509 return error_mark_node
;
3512 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3514 if (complain
& tf_error
)
3515 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3517 return error_mark_node
;
3519 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3521 if (complain
& tf_error
)
3522 error ("%<typename %T::%D%> names %q#T, which is not a type",
3524 return error_mark_node
;
3527 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3528 return error_mark_node
;
3530 /* If we are currently parsing a template and if T is a typedef accessed
3531 through CONTEXT then we need to remember and check access of T at
3532 template instantiation time. */
3533 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3536 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3538 /*entering_scope=*/0,
3539 tf_warning_or_error
| tf_user
);
3541 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3544 maybe_record_typedef_use (t
);
3549 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3550 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3551 in which case error_mark_node is returned.
3553 If PARM_LIST is non-NULL, also make sure that the template parameter
3554 list of TEMPLATE_DECL matches.
3556 If COMPLAIN zero, don't complain about any errors that occur. */
3559 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3560 tsubst_flags_t complain
)
3566 name
= TYPE_IDENTIFIER (name
);
3567 else if (DECL_P (name
))
3568 name
= DECL_NAME (name
);
3569 gcc_assert (identifier_p (name
));
3571 if (!dependent_type_p (context
)
3572 || currently_open_class (context
))
3574 tree tmpl
= NULL_TREE
;
3576 if (MAYBE_CLASS_TYPE_P (context
))
3577 tmpl
= lookup_field (context
, name
, 0, false);
3579 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3580 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3582 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3584 if (complain
& tf_error
)
3585 error ("no class template named %q#T in %q#T", name
, context
);
3586 return error_mark_node
;
3590 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3592 if (complain
& tf_error
)
3594 error ("template parameters do not match template %qD", tmpl
);
3595 inform (DECL_SOURCE_LOCATION (tmpl
),
3596 "%qD declared here", tmpl
);
3598 return error_mark_node
;
3601 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3603 return error_mark_node
;
3608 /* Build the UNBOUND_CLASS_TEMPLATE. */
3609 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3610 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3611 TREE_TYPE (t
) = NULL_TREE
;
3612 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3614 /* Build the corresponding TEMPLATE_DECL. */
3615 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3616 TYPE_NAME (TREE_TYPE (d
)) = d
;
3617 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3618 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3619 DECL_ARTIFICIAL (d
) = 1;
3620 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3627 /* Push the declarations of builtin types into the namespace.
3628 RID_INDEX is the index of the builtin type in the array
3629 RID_POINTERS. NAME is the name used when looking up the builtin
3630 type. TYPE is the _TYPE node for the builtin type. */
3633 record_builtin_type (enum rid rid_index
,
3637 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3638 tree tdecl
= NULL_TREE
;
3640 if ((int) rid_index
< (int) RID_MAX
)
3641 rname
= ridpointers
[(int) rid_index
];
3643 tname
= get_identifier (name
);
3645 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3646 eliminated. Built-in types should not be looked up name; their
3647 names are keywords that the parser can recognize. However, there
3648 is code in c-common.c that uses identifier_global_value to look
3649 up built-in types by name. */
3652 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3653 DECL_ARTIFICIAL (tdecl
) = 1;
3654 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3660 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3661 DECL_ARTIFICIAL (tdecl
) = 1;
3663 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3666 if (!TYPE_NAME (type
))
3667 TYPE_NAME (type
) = tdecl
;
3670 debug_hooks
->type_decl (tdecl
, 0);
3673 /* Record one of the standard Java types.
3674 * Declare it as having the given NAME.
3675 * If SIZE > 0, it is the size of one of the integral types;
3676 * otherwise it is the negative of the size of one of the other types. */
3679 record_builtin_java_type (const char* name
, int size
)
3684 type
= build_nonstandard_integer_type (size
, 0);
3685 type
= build_distinct_type_copy (type
);
3687 else if (size
> -32)
3690 /* "__java_char" or ""__java_boolean". */
3691 type
= build_nonstandard_integer_type (-size
, 1);
3692 type
= build_distinct_type_copy (type
);
3693 /* Get the signed type cached and attached to the unsigned type,
3694 so it doesn't get garbage-collected at "random" times,
3695 causing potential codegen differences out of different UIDs
3696 and different alias set numbers. */
3697 stype
= build_nonstandard_integer_type (-size
, 0);
3698 stype
= build_distinct_type_copy (stype
);
3699 TREE_CHAIN (type
) = stype
;
3700 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3703 { /* "__java_float" or ""__java_double". */
3704 type
= make_node (REAL_TYPE
);
3705 TYPE_PRECISION (type
) = - size
;
3708 record_builtin_type (RID_MAX
, name
, type
);
3709 decl
= TYPE_NAME (type
);
3711 /* Suppress generate debug symbol entries for these types,
3712 since for normal C++ they are just clutter.
3713 However, push_lang_context undoes this if extern "Java" is seen. */
3714 DECL_IGNORED_P (decl
) = 1;
3716 TYPE_FOR_JAVA (type
) = 1;
3720 /* Push a type into the namespace so that the back ends ignore it. */
3723 record_unknown_type (tree type
, const char* name
)
3725 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3726 TYPE_DECL
, get_identifier (name
), type
));
3727 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3728 DECL_IGNORED_P (decl
) = 1;
3729 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3730 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3731 TYPE_ALIGN (type
) = 1;
3732 TYPE_USER_ALIGN (type
) = 0;
3733 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3736 /* A string for which we should create an IDENTIFIER_NODE at
3739 typedef struct predefined_identifier
3741 /* The name of the identifier. */
3742 const char *const name
;
3743 /* The place where the IDENTIFIER_NODE should be stored. */
3745 /* Nonzero if this is the name of a constructor or destructor. */
3746 const int ctor_or_dtor_p
;
3747 } predefined_identifier
;
3749 /* Create all the predefined identifiers. */
3752 initialize_predefined_identifiers (void)
3754 const predefined_identifier
*pid
;
3756 /* A table of identifiers to create at startup. */
3757 static const predefined_identifier predefined_identifiers
[] = {
3758 { "C++", &lang_name_cplusplus
, 0 },
3759 { "C", &lang_name_c
, 0 },
3760 { "Java", &lang_name_java
, 0 },
3761 /* Some of these names have a trailing space so that it is
3762 impossible for them to conflict with names written by users. */
3763 { "__ct ", &ctor_identifier
, 1 },
3764 { "__base_ctor ", &base_ctor_identifier
, 1 },
3765 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3766 { "__dt ", &dtor_identifier
, 1 },
3767 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3768 { "__base_dtor ", &base_dtor_identifier
, 1 },
3769 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3770 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3771 { "nelts", &nelts_identifier
, 0 },
3772 { THIS_NAME
, &this_identifier
, 0 },
3773 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3774 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3775 { "_vptr", &vptr_identifier
, 0 },
3776 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3777 { "::", &global_scope_name
, 0 },
3778 { "std", &std_identifier
, 0 },
3782 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3784 *pid
->node
= get_identifier (pid
->name
);
3785 if (pid
->ctor_or_dtor_p
)
3786 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3790 /* Create the predefined scalar types of C,
3791 and some nodes representing standard constants (0, 1, (void *)0).
3792 Initialize the global binding level.
3793 Make definitions for built-in primitive functions. */
3796 cxx_init_decl_processing (void)
3799 tree void_ftype_ptr
;
3801 /* Create all the identifiers we need. */
3802 initialize_predefined_identifiers ();
3804 /* Create the global variables. */
3805 push_to_top_level ();
3807 current_function_decl
= NULL_TREE
;
3808 current_binding_level
= NULL
;
3809 /* Enter the global namespace. */
3810 gcc_assert (global_namespace
== NULL_TREE
);
3811 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3813 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3814 TREE_PUBLIC (global_namespace
) = 1;
3815 begin_scope (sk_namespace
, global_namespace
);
3817 if (flag_visibility_ms_compat
)
3818 default_visibility
= VISIBILITY_HIDDEN
;
3821 current_lang_name
= lang_name_c
;
3823 /* Create the `std' namespace. */
3824 push_namespace (std_identifier
);
3825 std_node
= current_namespace
;
3828 c_common_nodes_and_builtins ();
3830 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3831 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3832 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3833 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3834 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3835 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3836 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3837 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3839 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3841 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3842 truthvalue_type_node
= boolean_type_node
;
3843 truthvalue_false_node
= boolean_false_node
;
3844 truthvalue_true_node
= boolean_true_node
;
3846 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3847 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3848 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3851 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3854 delta_type_node
= ptrdiff_type_node
;
3855 vtable_index_type
= ptrdiff_type_node
;
3857 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3858 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3859 void_ftype_ptr
= build_function_type_list (void_type_node
,
3860 ptr_type_node
, NULL_TREE
);
3862 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3864 /* C++ extensions */
3866 unknown_type_node
= make_node (LANG_TYPE
);
3867 record_unknown_type (unknown_type_node
, "unknown type");
3869 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3870 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3872 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3874 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3875 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3877 init_list_type_node
= make_node (LANG_TYPE
);
3878 record_unknown_type (init_list_type_node
, "init list");
3881 /* Make sure we get a unique function type, so we can give
3882 its pointer type a name. (This wins for gdb.) */
3883 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3884 TREE_TYPE (vfunc_type
) = integer_type_node
;
3885 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3886 layout_type (vfunc_type
);
3888 vtable_entry_type
= build_pointer_type (vfunc_type
);
3890 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3893 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3894 layout_type (vtbl_type_node
);
3895 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3896 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3897 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3898 layout_type (vtbl_ptr_type_node
);
3899 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3901 push_namespace (get_identifier ("__cxxabiv1"));
3902 abi_node
= current_namespace
;
3905 global_type_node
= make_node (LANG_TYPE
);
3906 record_unknown_type (global_type_node
, "global type");
3909 current_lang_name
= lang_name_cplusplus
;
3912 tree newattrs
, extvisattr
;
3913 tree newtype
, deltype
;
3914 tree ptr_ftype_sizetype
;
3918 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3919 if (cxx_dialect
== cxx98
)
3922 tree bad_alloc_type_node
;
3923 tree bad_alloc_decl
;
3925 push_namespace (std_identifier
);
3926 bad_alloc_id
= get_identifier ("bad_alloc");
3927 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3928 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3930 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3931 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3935 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3938 new_eh_spec
= noexcept_false_spec
;
3940 /* Ensure attribs.c is initialized. */
3942 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3944 newattrs
= tree_cons (get_identifier ("alloc_size"),
3945 build_tree_list (NULL_TREE
, integer_one_node
),
3947 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3948 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3949 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3950 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3951 tree opnew
= push_cp_library_fn (NEW_EXPR
, newtype
, 0);
3952 DECL_IS_MALLOC (opnew
) = 1;
3953 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3954 opnew
= push_cp_library_fn (VEC_NEW_EXPR
, newtype
, 0);
3955 DECL_IS_MALLOC (opnew
) = 1;
3956 DECL_IS_OPERATOR_NEW (opnew
) = 1;
3957 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3958 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
, ECF_NOTHROW
);
3960 nullptr_type_node
= make_node (NULLPTR_TYPE
);
3961 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
3962 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
3963 TYPE_UNSIGNED (nullptr_type_node
) = 1;
3964 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
3965 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
3966 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
3967 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
3971 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
,
3972 ECF_NORETURN
| ECF_NOTHROW
);
3974 /* Perform other language dependent initializations. */
3975 init_class_processing ();
3976 init_rtti_processing ();
3977 init_template_processing ();
3979 if (flag_exceptions
)
3980 init_exception_processing ();
3982 if (! supports_one_only ())
3985 make_fname_decl
= cp_make_fname_decl
;
3986 start_fname_decls ();
3988 /* Show we use EH for cleanups. */
3989 if (flag_exceptions
)
3990 using_eh_for_cleanups ();
3993 /* Generate an initializer for a function naming variable from
3994 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3995 filled in with the type of the init. */
3998 cp_fname_init (const char* name
, tree
*type_p
)
4000 tree domain
= NULL_TREE
;
4002 tree init
= NULL_TREE
;
4007 length
= strlen (name
);
4008 domain
= build_index_type (size_int (length
));
4009 init
= build_string (length
+ 1, name
);
4012 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
4013 type
= build_cplus_array_type (type
, domain
);
4018 TREE_TYPE (init
) = type
;
4020 init
= error_mark_node
;
4025 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4026 the decl, LOC is the location to give the decl, NAME is the
4027 initialization string and TYPE_DEP indicates whether NAME depended
4028 on the type of the function. We make use of that to detect
4029 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4030 at the point of first use, so we mustn't push the decl now. */
4033 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
4035 const char *const name
= (type_dep
&& processing_template_decl
4036 ? NULL
: fname_as_string (type_dep
));
4038 tree init
= cp_fname_init (name
, &type
);
4039 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
4042 free (CONST_CAST (char *, name
));
4044 /* As we're using pushdecl_with_scope, we must set the context. */
4045 DECL_CONTEXT (decl
) = current_function_decl
;
4047 TREE_STATIC (decl
) = 1;
4048 TREE_READONLY (decl
) = 1;
4049 DECL_ARTIFICIAL (decl
) = 1;
4051 TREE_USED (decl
) = 1;
4053 if (current_function_decl
)
4055 cp_binding_level
*b
= current_binding_level
;
4056 if (b
->kind
== sk_function_parms
)
4057 return error_mark_node
;
4058 while (b
->level_chain
->kind
!= sk_function_parms
)
4060 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
4061 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
4062 LOOKUP_ONLYCONVERTING
);
4066 DECL_THIS_STATIC (decl
) = true;
4067 pushdecl_top_level_and_finish (decl
, init
);
4074 builtin_function_1 (tree decl
, tree context
, bool is_global
)
4076 tree id
= DECL_NAME (decl
);
4077 const char *name
= IDENTIFIER_POINTER (id
);
4079 retrofit_lang_decl (decl
);
4081 DECL_ARTIFICIAL (decl
) = 1;
4082 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
4083 SET_DECL_LANGUAGE (decl
, lang_c
);
4084 /* Runtime library routines are, by definition, available in an
4085 external shared object. */
4086 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
4087 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
4089 DECL_CONTEXT (decl
) = context
;
4092 pushdecl_top_level (decl
);
4096 /* A function in the user's namespace should have an explicit
4097 declaration before it is used. Mark the built-in function as
4098 anticipated but not actually declared. */
4099 if (name
[0] != '_' || name
[1] != '_')
4100 DECL_ANTICIPATED (decl
) = 1;
4101 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
4103 size_t len
= strlen (name
);
4105 /* Treat __*_chk fortification functions as anticipated as well,
4106 unless they are __builtin_*. */
4107 if (len
> strlen ("___chk")
4108 && memcmp (name
+ len
- strlen ("_chk"),
4109 "_chk", strlen ("_chk") + 1) == 0)
4110 DECL_ANTICIPATED (decl
) = 1;
4117 cxx_builtin_function (tree decl
)
4119 tree id
= DECL_NAME (decl
);
4120 const char *name
= IDENTIFIER_POINTER (id
);
4121 /* All builtins that don't begin with an '_' should additionally
4122 go in the 'std' namespace. */
4125 tree decl2
= copy_node(decl
);
4126 push_namespace (std_identifier
);
4127 builtin_function_1 (decl2
, std_node
, false);
4131 return builtin_function_1 (decl
, NULL_TREE
, false);
4134 /* Like cxx_builtin_function, but guarantee the function is added to the global
4135 scope. This is to allow function specific options to add new machine
4136 dependent builtins when the target ISA changes via attribute((target(...)))
4137 which saves space on program startup if the program does not use non-generic
4141 cxx_builtin_function_ext_scope (tree decl
)
4144 tree id
= DECL_NAME (decl
);
4145 const char *name
= IDENTIFIER_POINTER (id
);
4146 /* All builtins that don't begin with an '_' should additionally
4147 go in the 'std' namespace. */
4150 tree decl2
= copy_node(decl
);
4151 push_namespace (std_identifier
);
4152 builtin_function_1 (decl2
, std_node
, true);
4156 return builtin_function_1 (decl
, NULL_TREE
, true);
4159 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4160 function. Not called directly. */
4163 build_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4166 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
4167 DECL_EXTERNAL (fn
) = 1;
4168 TREE_PUBLIC (fn
) = 1;
4169 DECL_ARTIFICIAL (fn
) = 1;
4170 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
4171 SET_DECL_LANGUAGE (fn
, lang_c
);
4172 /* Runtime library routines are, by definition, available in an
4173 external shared object. */
4174 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4175 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4176 set_call_expr_flags (fn
, ecf_flags
);
4180 /* Returns the _DECL for a library function with C++ linkage. */
4183 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
,
4186 tree fn
= build_library_fn (name
, operator_code
, type
, ecf_flags
);
4187 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4188 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4192 /* Like build_library_fn, but takes a C string instead of an
4196 build_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4198 return build_library_fn (get_identifier (name
), ERROR_MARK
, type
, ecf_flags
);
4201 /* Like build_cp_library_fn, but takes a C string instead of an
4205 build_cp_library_fn_ptr (const char* name
, tree type
, int ecf_flags
)
4207 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
,
4211 /* Like build_library_fn, but also pushes the function so that we will
4212 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4213 may throw exceptions listed in RAISES. */
4216 push_library_fn (tree name
, tree type
, tree raises
, int ecf_flags
)
4221 type
= build_exception_variant (type
, raises
);
4223 fn
= build_library_fn (name
, ERROR_MARK
, type
, ecf_flags
);
4224 pushdecl_top_level (fn
);
4228 /* Like build_cp_library_fn, but also pushes the function so that it
4229 will be found by normal lookup. */
4232 push_cp_library_fn (enum tree_code operator_code
, tree type
,
4235 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4240 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4244 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4248 push_void_library_fn (tree name
, tree parmtypes
, int ecf_flags
)
4250 tree type
= build_function_type (void_type_node
, parmtypes
);
4251 return push_library_fn (name
, type
, NULL_TREE
, ecf_flags
);
4254 /* Like push_library_fn, but also note that this function throws
4255 and does not return. Used for __throw_foo and the like. */
4258 push_throw_library_fn (tree name
, tree type
)
4260 tree fn
= push_library_fn (name
, type
, NULL_TREE
, ECF_NORETURN
);
4264 /* When we call finish_struct for an anonymous union, we create
4265 default copy constructors and such. But, an anonymous union
4266 shouldn't have such things; this function undoes the damage to the
4267 anonymous union type T.
4269 (The reason that we create the synthesized methods is that we don't
4270 distinguish `union { int i; }' from `typedef union { int i; } U'.
4271 The first is an anonymous union; the second is just an ordinary
4275 fixup_anonymous_aggr (tree t
)
4279 /* Wipe out memory of synthesized methods. */
4280 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4281 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4282 TYPE_HAS_COPY_CTOR (t
) = 0;
4283 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4284 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4285 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4287 /* Splice the implicitly generated functions out of the TYPE_METHODS
4289 q
= &TYPE_METHODS (t
);
4292 if (DECL_ARTIFICIAL (*q
))
4293 *q
= TREE_CHAIN (*q
);
4295 q
= &DECL_CHAIN (*q
);
4298 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4299 if (TYPE_METHODS (t
))
4301 tree decl
= TYPE_MAIN_DECL (t
);
4303 if (TREE_CODE (t
) != UNION_TYPE
)
4304 error_at (DECL_SOURCE_LOCATION (decl
),
4305 "an anonymous struct cannot have function members");
4307 error_at (DECL_SOURCE_LOCATION (decl
),
4308 "an anonymous union cannot have function members");
4311 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4312 assignment operators (because they cannot have these methods themselves).
4313 For anonymous unions this is already checked because they are not allowed
4314 in any union, otherwise we have to check it. */
4315 if (TREE_CODE (t
) != UNION_TYPE
)
4319 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4320 if (TREE_CODE (field
) == FIELD_DECL
)
4322 type
= TREE_TYPE (field
);
4323 if (CLASS_TYPE_P (type
))
4325 if (TYPE_NEEDS_CONSTRUCTING (type
))
4326 error ("member %q+#D with constructor not allowed "
4327 "in anonymous aggregate", field
);
4328 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4329 error ("member %q+#D with destructor not allowed "
4330 "in anonymous aggregate", field
);
4331 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4332 error ("member %q+#D with copy assignment operator "
4333 "not allowed in anonymous aggregate", field
);
4339 /* Warn for an attribute located at LOCATION that appertains to the
4340 class type CLASS_TYPE that has not been properly placed after its
4341 class-key, in it class-specifier. */
4344 warn_misplaced_attr_for_class_type (source_location location
,
4347 gcc_assert (OVERLOAD_TYPE_P (class_type
));
4349 if (warning_at (location
, OPT_Wattributes
,
4350 "attribute ignored in declaration "
4351 "of %q#T", class_type
))
4353 "attribute for %q#T must follow the %qs keyword",
4354 class_type
, class_key_or_enum_as_string (class_type
));
4357 /* Make sure that a declaration with no declarator is well-formed, i.e.
4358 just declares a tagged type or anonymous union.
4360 Returns the type declared; or NULL_TREE if none. */
4363 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4364 bool explicit_type_instantiation_p
)
4366 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4367 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4368 /* If a class, struct, or enum type is declared by the DECLSPECS
4369 (i.e, if a class-specifier, enum-specifier, or non-typename
4370 elaborated-type-specifier appears in the DECLSPECS),
4371 DECLARED_TYPE is set to the corresponding type. */
4372 tree declared_type
= NULL_TREE
;
4373 bool error_p
= false;
4375 if (declspecs
->multiple_types_p
)
4376 error ("multiple types in one declaration");
4377 else if (declspecs
->redefined_builtin_type
)
4379 if (!in_system_header_at (input_location
))
4380 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4381 "redeclaration of C++ built-in type %qT",
4382 declspecs
->redefined_builtin_type
);
4387 && TYPE_P (declspecs
->type
)
4388 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4389 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4390 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4391 declared_type
= declspecs
->type
;
4392 else if (declspecs
->type
== error_mark_node
)
4394 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4395 permerror (input_location
, "declaration does not declare anything");
4396 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4398 error ("%<auto%> can only be specified for variables "
4399 "or function declarations");
4400 return error_mark_node
;
4402 /* Check for an anonymous union. */
4403 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4404 && TYPE_ANONYMOUS_P (declared_type
))
4406 /* 7/3 In a simple-declaration, the optional init-declarator-list
4407 can be omitted only when declaring a class (clause 9) or
4408 enumeration (7.2), that is, when the decl-specifier-seq contains
4409 either a class-specifier, an elaborated-type-specifier with
4410 a class-key (9.1), or an enum-specifier. In these cases and
4411 whenever a class-specifier or enum-specifier is present in the
4412 decl-specifier-seq, the identifiers in these specifiers are among
4413 the names being declared by the declaration (as class-name,
4414 enum-names, or enumerators, depending on the syntax). In such
4415 cases, and except for the declaration of an unnamed bit-field (9.6),
4416 the decl-specifier-seq shall introduce one or more names into the
4417 program, or shall redeclare a name introduced by a previous
4418 declaration. [Example:
4419 enum { }; // ill-formed
4420 typedef class { }; // ill-formed
4424 error ("missing type-name in typedef-declaration");
4427 /* Anonymous unions are objects, so they can have specifiers. */;
4428 SET_ANON_AGGR_TYPE_P (declared_type
);
4430 if (TREE_CODE (declared_type
) != UNION_TYPE
4431 && !in_system_header_at (input_location
))
4432 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4437 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4438 || decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4439 error ("%qs can only be specified for functions",
4440 decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4441 ? "inline" : "virtual");
4443 && (!current_class_type
4444 || current_scope () != current_class_type
))
4445 error ("%<friend%> can only be specified inside a class");
4446 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4447 error ("%<explicit%> can only be specified for constructors");
4448 else if (declspecs
->storage_class
)
4449 error ("a storage class can only be specified for objects "
4451 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
)
4452 || decl_spec_seq_has_spec_p (declspecs
, ds_volatile
)
4453 || decl_spec_seq_has_spec_p (declspecs
, ds_restrict
)
4454 || decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4455 error ("qualifiers can only be specified for objects "
4457 else if (saw_typedef
)
4458 warning (0, "%<typedef%> was ignored in this declaration");
4459 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4460 error ("%<constexpr%> cannot be used for type declarations");
4463 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4466 if (!CLASS_TYPE_P (declared_type
)
4467 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4468 /* For a non-template class, use the name location. */
4469 loc
= location_of (declared_type
);
4471 /* For a template class (an explicit instantiation), use the
4472 current location. */
4473 loc
= input_location
;
4475 if (explicit_type_instantiation_p
)
4476 /* [dcl.attr.grammar]/4:
4478 No attribute-specifier-seq shall appertain to an explicit
4481 if (warning_at (loc
, OPT_Wattributes
,
4482 "attribute ignored in explicit instantiation %q#T",
4485 "no attribute can be applied to "
4486 "an explicit instantiation");
4489 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4492 return declared_type
;
4495 /* Called when a declaration is seen that contains no names to declare.
4496 If its type is a reference to a structure, union or enum inherited
4497 from a containing scope, shadow that tag name for the current scope
4498 with a forward reference.
4499 If its type defines a new named structure or union
4500 or defines an enum, it is valid but we need not do anything here.
4501 Otherwise, it is an error.
4503 C++: may have to grok the declspecs to learn about static,
4504 complain for anonymous unions.
4506 Returns the TYPE declared -- or NULL_TREE if none. */
4509 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4511 tree t
= check_tag_decl (declspecs
,
4512 /*explicit_type_instantiation_p=*/false);
4517 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4520 /* This is where the variables in an anonymous union are
4521 declared. An anonymous union declaration looks like:
4523 because there is no declarator after the union, the parser
4524 sends that declaration here. */
4525 if (ANON_AGGR_TYPE_P (t
))
4527 fixup_anonymous_aggr (t
);
4529 if (TYPE_FIELDS (t
))
4531 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4532 declspecs
, NORMAL
, 0, NULL
);
4533 finish_anon_union (decl
);
4540 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4543 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4544 const cp_declarator
*declarator
,
4545 bool is_template_arg
)
4549 enum decl_context context
4550 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4551 attrs
= type_specifiers
->attributes
;
4552 type_specifiers
->attributes
= NULL_TREE
;
4553 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4554 if (attrs
&& type
!= error_mark_node
)
4556 if (CLASS_TYPE_P (type
))
4557 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4558 "outside of definition", type
);
4559 else if (MAYBE_CLASS_TYPE_P (type
))
4560 /* A template type parameter or other dependent type. */
4561 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4562 "type %qT without an associated declaration", type
);
4564 cplus_decl_attributes (&type
, attrs
, 0);
4569 /* Process a DECLARATOR for a function-scope variable declaration,
4570 namespace-scope variable declaration, or function declaration.
4571 (Function definitions go through start_function; class member
4572 declarations appearing in the body of the class go through
4573 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4574 If an error occurs, the error_mark_node is returned instead.
4576 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4577 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4578 for an explicitly defaulted function, or SD_DELETED for an explicitly
4579 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4580 implicitly initialized via a default constructor. ATTRIBUTES and
4581 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4583 The scope represented by the context of the returned DECL is pushed
4584 (if it is not the global namespace) and is assigned to
4585 *PUSHED_SCOPE_P. The caller is then responsible for calling
4586 pop_scope on *PUSHED_SCOPE_P if it is set. */
4589 start_decl (const cp_declarator
*declarator
,
4590 cp_decl_specifier_seq
*declspecs
,
4593 tree prefix_attributes
,
4594 tree
*pushed_scope_p
)
4602 *pushed_scope_p
= NULL_TREE
;
4604 /* An object declared as __attribute__((deprecated)) suppresses
4605 warnings of uses of other deprecated items. */
4606 if (lookup_attribute ("deprecated", attributes
))
4607 deprecated_state
= DEPRECATED_SUPPRESS
;
4609 attributes
= chainon (attributes
, prefix_attributes
);
4611 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4614 deprecated_state
= DEPRECATED_NORMAL
;
4616 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4617 || decl
== error_mark_node
)
4618 return error_mark_node
;
4620 context
= CP_DECL_CONTEXT (decl
);
4621 if (context
!= global_namespace
)
4622 *pushed_scope_p
= push_scope (context
);
4625 /* Is it valid for this decl to have an initializer at all?
4626 If not, set INITIALIZED to zero, which will indirectly
4627 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4628 switch (TREE_CODE (decl
))
4631 error ("typedef %qD is initialized (use decltype instead)", decl
);
4632 return error_mark_node
;
4635 if (initialized
== SD_DELETED
)
4636 /* We'll handle the rest of the semantics later, but we need to
4637 set this now so it's visible to duplicate_decls. */
4638 DECL_DELETED_FN (decl
) = 1;
4647 if (! toplevel_bindings_p ()
4648 && DECL_EXTERNAL (decl
))
4649 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4651 DECL_EXTERNAL (decl
) = 0;
4652 if (toplevel_bindings_p ())
4653 TREE_STATIC (decl
) = 1;
4655 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4657 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4658 record_key_method_defined (decl
);
4660 /* If this is a typedef that names the class for linkage purposes
4661 (7.1.3p8), apply any attributes directly to the type. */
4662 if (TREE_CODE (decl
) == TYPE_DECL
4663 && OVERLOAD_TYPE_P (TREE_TYPE (decl
))
4664 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4665 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4669 /* Set attributes here so if duplicate decl, will have proper attributes. */
4670 cplus_decl_attributes (&decl
, attributes
, flags
);
4672 /* Dllimported symbols cannot be defined. Static data members (which
4673 can be initialized in-class and dllimported) go through grokfield,
4674 not here, so we don't need to exclude those decls when checking for
4676 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4678 error ("definition of %q#D is marked %<dllimport%>", decl
);
4679 DECL_DLLIMPORT_P (decl
) = 0;
4682 /* If #pragma weak was used, mark the decl weak now. */
4683 if (!processing_template_decl
)
4684 maybe_apply_pragma_weak (decl
);
4686 if (TREE_CODE (decl
) == FUNCTION_DECL
4687 && DECL_DECLARED_INLINE_P (decl
)
4688 && DECL_UNINLINABLE (decl
)
4689 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4690 warning (0, "inline function %q+D given attribute noinline", decl
);
4692 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4694 bool this_tmpl
= (processing_template_decl
4695 > template_class_depth (context
));
4698 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4699 if (field
== NULL_TREE
4700 || !(VAR_P (field
) || variable_template_p (field
)))
4701 error ("%q+#D is not a static data member of %q#T", decl
, context
);
4702 else if (variable_template_p (field
) && !this_tmpl
)
4704 if (DECL_LANG_SPECIFIC (decl
)
4705 && DECL_TEMPLATE_SPECIALIZATION (decl
))
4706 /* OK, specialization was already checked. */;
4709 error_at (DECL_SOURCE_LOCATION (decl
),
4710 "non-member-template declaration of %qD", decl
);
4711 inform (DECL_SOURCE_LOCATION (field
), "does not match "
4712 "member template declaration here");
4713 return error_mark_node
;
4718 if (variable_template_p (field
))
4719 field
= DECL_TEMPLATE_RESULT (field
);
4721 if (DECL_CONTEXT (field
) != context
)
4723 if (!same_type_p (DECL_CONTEXT (field
), context
))
4724 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4725 "to be defined as %<%T::%D%>",
4726 DECL_CONTEXT (field
), DECL_NAME (decl
),
4727 context
, DECL_NAME (decl
));
4728 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4730 /* Static data member are tricky; an in-class initialization
4731 still doesn't provide a definition, so the in-class
4732 declaration will have DECL_EXTERNAL set, but will have an
4733 initialization. Thus, duplicate_decls won't warn
4734 about this situation, and so we check here. */
4735 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4736 error ("duplicate initialization of %qD", decl
);
4737 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4739 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4740 && !DECL_DECLARED_CONSTEXPR_P (field
))
4741 error ("%qD declared %<constexpr%> outside its class", field
);
4746 tree field
= check_classfn (context
, decl
,
4748 ? current_template_parms
4750 if (field
&& field
!= error_mark_node
4751 && duplicate_decls (decl
, field
,
4752 /*newdecl_is_friend=*/false))
4756 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4757 DECL_IN_AGGR_P (decl
) = 0;
4758 /* Do not mark DECL as an explicit specialization if it was not
4759 already marked as an instantiation; a declaration should
4760 never be marked as a specialization unless we know what
4761 template is being specialized. */
4762 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4764 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4765 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4766 DECL_COMDAT (decl
) = (TREE_PUBLIC (decl
)
4767 && DECL_DECLARED_INLINE_P (decl
));
4769 DECL_COMDAT (decl
) = false;
4771 /* [temp.expl.spec] An explicit specialization of a static data
4772 member of a template is a definition if the declaration
4773 includes an initializer; otherwise, it is a declaration.
4775 We check for processing_specialization so this only applies
4776 to the new specialization syntax. */
4777 if (!initialized
&& processing_specialization
)
4778 DECL_EXTERNAL (decl
) = 1;
4781 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4782 /* Aliases are definitions. */
4784 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4788 was_public
= TREE_PUBLIC (decl
);
4790 /* Enter this declaration into the symbol table. */
4791 decl
= maybe_push_decl (decl
);
4793 if (processing_template_decl
)
4794 decl
= push_template_decl (decl
);
4795 if (decl
== error_mark_node
)
4796 return error_mark_node
;
4799 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4800 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4802 /* This is a const variable with implicit 'static'. Set
4803 DECL_THIS_STATIC so we can tell it from variables that are
4804 !TREE_PUBLIC because of the anonymous namespace. */
4805 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4806 DECL_THIS_STATIC (decl
) = 1;
4809 if (current_function_decl
&& VAR_P (decl
)
4810 && DECL_DECLARED_CONSTEXPR_P (current_function_decl
))
4813 if (DECL_THREAD_LOCAL_P (decl
))
4814 error ("%qD declared %<thread_local%> in %<constexpr%> function",
4816 else if (TREE_STATIC (decl
))
4817 error ("%qD declared %<static%> in %<constexpr%> function", decl
);
4821 cp_function_chain
->invalid_constexpr
= true;
4824 if (!processing_template_decl
&& VAR_P (decl
))
4825 start_decl_1 (decl
, initialized
);
4830 /* Process the declaration of a variable DECL. INITIALIZED is true
4831 iff DECL is explicitly initialized. (INITIALIZED is false if the
4832 variable is initialized via an implicitly-called constructor.)
4833 This function must be called for ordinary variables (including, for
4834 example, implicit instantiations of templates), but must not be
4835 called for template declarations. */
4838 start_decl_1 (tree decl
, bool initialized
)
4842 bool aggregate_definition_p
;
4844 gcc_assert (!processing_template_decl
);
4846 if (error_operand_p (decl
))
4849 gcc_assert (VAR_P (decl
));
4851 type
= TREE_TYPE (decl
);
4852 complete_p
= COMPLETE_TYPE_P (type
);
4853 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4855 /* If an explicit initializer is present, or if this is a definition
4856 of an aggregate, then we need a complete type at this point.
4857 (Scalars are always complete types, so there is nothing to
4858 check.) This code just sets COMPLETE_P; errors (if necessary)
4859 are issued below. */
4860 if ((initialized
|| aggregate_definition_p
)
4862 && COMPLETE_TYPE_P (complete_type (type
)))
4865 /* We will not yet have set TREE_READONLY on DECL if the type
4866 was "const", but incomplete, before this point. But, now, we
4867 have a complete type, so we can try again. */
4868 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4872 /* Is it valid for this decl to have an initializer at all? */
4874 /* Don't allow initializations for incomplete types except for
4875 arrays which might be completed by the initialization. */
4877 ; /* A complete type is ok. */
4878 else if (type_uses_auto (type
))
4879 ; /* An auto type is ok. */
4880 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4882 error ("variable %q#D has initializer but incomplete type", decl
);
4883 type
= TREE_TYPE (decl
) = error_mark_node
;
4885 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4887 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4888 error ("elements of array %q#D have incomplete type", decl
);
4889 /* else we already gave an error in start_decl. */
4892 else if (aggregate_definition_p
&& !complete_p
)
4894 if (type_uses_auto (type
))
4895 error ("declaration of %q#D has no initializer", decl
);
4897 error ("aggregate %q#D has incomplete type and cannot be defined",
4899 /* Change the type so that assemble_variable will give
4900 DECL an rtl we can live with: (mem (const_int 0)). */
4901 type
= TREE_TYPE (decl
) = error_mark_node
;
4904 /* Create a new scope to hold this declaration if necessary.
4905 Whether or not a new scope is necessary cannot be determined
4906 until after the type has been completed; if the type is a
4907 specialization of a class template it is not until after
4908 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4909 will be set correctly. */
4910 maybe_push_cleanup_level (type
);
4913 /* Handle initialization of references. DECL, TYPE, and INIT have the
4914 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4915 but will be set to a new CLEANUP_STMT if a temporary is created
4916 that must be destroyed subsequently.
4918 Returns an initializer expression to use to initialize DECL, or
4919 NULL if the initialization can be performed statically.
4921 Quotes on semantics can be found in ARM 8.4.3. */
4924 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4926 if (init
== NULL_TREE
)
4928 if ((DECL_LANG_SPECIFIC (decl
) == 0
4929 || DECL_IN_AGGR_P (decl
) == 0)
4930 && ! DECL_THIS_EXTERN (decl
))
4931 error ("%qD declared as reference but not initialized", decl
);
4935 if (TREE_CODE (init
) == TREE_LIST
)
4936 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4937 tf_warning_or_error
);
4939 tree ttype
= TREE_TYPE (type
);
4940 if (TREE_CODE (ttype
) != ARRAY_TYPE
4941 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4942 /* Note: default conversion is only called in very special cases. */
4943 init
= decay_conversion (init
, tf_warning_or_error
);
4945 /* check_initializer handles this for non-reference variables, but for
4946 references we need to do it here or the initializer will get the
4947 incomplete array type and confuse later calls to
4948 cp_complete_array_type. */
4949 if (TREE_CODE (ttype
) == ARRAY_TYPE
4950 && TYPE_DOMAIN (ttype
) == NULL_TREE
4951 && (BRACE_ENCLOSED_INITIALIZER_P (init
)
4952 || TREE_CODE (init
) == STRING_CST
))
4954 cp_complete_array_type (&ttype
, init
, false);
4955 if (ttype
!= TREE_TYPE (type
))
4956 type
= cp_build_reference_type (ttype
, TYPE_REF_IS_RVALUE (type
));
4959 /* Convert INIT to the reference type TYPE. This may involve the
4960 creation of a temporary, whose lifetime must be the same as that
4961 of the reference. If so, a DECL_EXPR for the temporary will be
4962 added just after the DECL_EXPR for DECL. That's why we don't set
4963 DECL_INITIAL for local references (instead assigning to them
4964 explicitly); we need to allow the temporary to be initialized
4966 return initialize_reference (type
, init
, flags
,
4967 tf_warning_or_error
);
4970 /* Designated initializers in arrays are not supported in GNU C++.
4971 The parser cannot detect this error since it does not know whether
4972 a given brace-enclosed initializer is for a class type or for an
4973 array. This function checks that CE does not use a designated
4974 initializer. If it does, an error is issued. Returns true if CE
4975 is valid, i.e., does not have a designated initializer. */
4978 check_array_designated_initializer (constructor_elt
*ce
,
4979 unsigned HOST_WIDE_INT index
)
4981 /* Designated initializers for array elements are not supported. */
4984 /* The parser only allows identifiers as designated
4986 if (ce
->index
== error_mark_node
)
4988 error ("name used in a GNU-style designated "
4989 "initializer for an array");
4992 else if (identifier_p (ce
->index
))
4994 error ("name %qD used in a GNU-style designated "
4995 "initializer for an array", ce
->index
);
4999 ce
->index
= cxx_constant_value (ce
->index
);
5001 if (TREE_CODE (ce
->index
) == INTEGER_CST
)
5003 /* A C99 designator is OK if it matches the current index. */
5004 if (wi::eq_p (ce
->index
, index
))
5007 sorry ("non-trivial designated initializers not supported");
5018 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5019 array until we finish parsing the initializer. If that's the
5020 situation we're in, update DECL accordingly. */
5023 maybe_deduce_size_from_array_init (tree decl
, tree init
)
5025 tree type
= TREE_TYPE (decl
);
5027 if (TREE_CODE (type
) == ARRAY_TYPE
5028 && TYPE_DOMAIN (type
) == NULL_TREE
5029 && TREE_CODE (decl
) != TYPE_DECL
)
5031 /* do_default is really a C-ism to deal with tentative definitions.
5032 But let's leave it here to ease the eventual merge. */
5033 int do_default
= !DECL_EXTERNAL (decl
);
5034 tree initializer
= init
? init
: DECL_INITIAL (decl
);
5037 /* Check that there are no designated initializers in INIT, as
5038 those are not supported in GNU C++, and as the middle-end
5039 will crash if presented with a non-numeric designated
5041 if (initializer
&& BRACE_ENCLOSED_INITIALIZER_P (initializer
))
5043 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
5044 constructor_elt
*ce
;
5046 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
5047 if (!check_array_designated_initializer (ce
, i
))
5053 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
5057 error ("initializer fails to determine size of %qD", decl
);
5059 else if (failure
== 2)
5063 error ("array size missing in %qD", decl
);
5065 /* If a `static' var's size isn't known, make it extern as
5066 well as static, so it does not get allocated. If it's not
5067 `static', then don't mark it extern; finish_incomplete_decl
5068 will give it a default size and it will get allocated. */
5069 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
5070 DECL_EXTERNAL (decl
) = 1;
5072 else if (failure
== 3)
5074 error ("zero-size array %qD", decl
);
5078 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
5080 relayout_decl (decl
);
5084 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5085 any appropriate error messages regarding the layout. */
5088 layout_var_decl (tree decl
)
5092 type
= TREE_TYPE (decl
);
5093 if (type
== error_mark_node
)
5096 /* If we haven't already laid out this declaration, do so now.
5097 Note that we must not call complete type for an external object
5098 because it's type might involve templates that we are not
5099 supposed to instantiate yet. (And it's perfectly valid to say
5100 `extern X x' for some incomplete type `X'.) */
5101 if (!DECL_EXTERNAL (decl
))
5102 complete_type (type
);
5103 if (!DECL_SIZE (decl
)
5104 && TREE_TYPE (decl
) != error_mark_node
5105 && (COMPLETE_TYPE_P (type
)
5106 || (TREE_CODE (type
) == ARRAY_TYPE
5107 && !TYPE_DOMAIN (type
)
5108 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
5109 layout_decl (decl
, 0);
5111 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
5113 /* An automatic variable with an incomplete type: that is an error.
5114 Don't talk about array types here, since we took care of that
5115 message in grokdeclarator. */
5116 error ("storage size of %qD isn%'t known", decl
);
5117 TREE_TYPE (decl
) = error_mark_node
;
5120 /* Keep this code around in case we later want to control debug info
5121 based on whether a type is "used". (jason 1999-11-11) */
5123 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
5124 /* Let debugger know it should output info for this type. */
5125 note_debug_info_needed (ttype
);
5127 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
5128 note_debug_info_needed (DECL_CONTEXT (decl
));
5131 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
5132 && DECL_SIZE (decl
) != NULL_TREE
5133 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
5135 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
5136 constant_expression_warning (DECL_SIZE (decl
));
5139 error ("storage size of %qD isn%'t constant", decl
);
5140 TREE_TYPE (decl
) = error_mark_node
;
5145 /* If a local static variable is declared in an inline function, or if
5146 we have a weak definition, we must endeavor to create only one
5147 instance of the variable at link-time. */
5150 maybe_commonize_var (tree decl
)
5152 /* Static data in a function with comdat linkage also has comdat
5154 if (TREE_STATIC (decl
)
5155 /* Don't mess with __FUNCTION__. */
5156 && ! DECL_ARTIFICIAL (decl
)
5157 && DECL_FUNCTION_SCOPE_P (decl
)
5158 && vague_linkage_p (DECL_CONTEXT (decl
)))
5162 /* With weak symbols, we simply make the variable COMDAT;
5163 that will cause copies in multiple translations units to
5165 comdat_linkage (decl
);
5169 if (DECL_INITIAL (decl
) == NULL_TREE
5170 || DECL_INITIAL (decl
) == error_mark_node
)
5172 /* Without weak symbols, we can use COMMON to merge
5173 uninitialized variables. */
5174 TREE_PUBLIC (decl
) = 1;
5175 DECL_COMMON (decl
) = 1;
5179 /* While for initialized variables, we must use internal
5180 linkage -- which means that multiple copies will not
5182 TREE_PUBLIC (decl
) = 0;
5183 DECL_COMMON (decl
) = 0;
5184 if (warning_at (DECL_SOURCE_LOCATION (decl
), 0,
5185 "sorry: semantics of inline function static "
5186 "data %q#D are wrong (you%'ll wind up "
5187 "with multiple copies)", decl
))
5188 inform (DECL_SOURCE_LOCATION (decl
),
5189 "you can work around this by removing the initializer");
5195 /* Issue an error message if DECL is an uninitialized const variable. */
5198 check_for_uninitialized_const_var (tree decl
)
5200 tree type
= strip_array_types (TREE_TYPE (decl
));
5202 /* ``Unless explicitly declared extern, a const object does not have
5203 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5206 && TREE_CODE (type
) != REFERENCE_TYPE
5207 && (CP_TYPE_CONST_P (type
) || var_in_constexpr_fn (decl
))
5208 && !DECL_INITIAL (decl
))
5210 tree field
= default_init_uninitialized_part (type
);
5214 if (CP_TYPE_CONST_P (type
))
5215 permerror (DECL_SOURCE_LOCATION (decl
),
5216 "uninitialized const %qD", decl
);
5219 error_at (DECL_SOURCE_LOCATION (decl
),
5220 "uninitialized variable %qD in %<constexpr%> function",
5222 cp_function_chain
->invalid_constexpr
= true;
5225 if (CLASS_TYPE_P (type
))
5227 tree defaulted_ctor
;
5229 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5230 "%q#T has no user-provided default constructor", type
);
5231 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5233 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5234 "constructor is not user-provided because it is "
5235 "explicitly defaulted in the class body");
5236 inform (0, "and the implicitly-defined constructor does not "
5237 "initialize %q+#D", field
);
5242 /* Structure holding the current initializer being processed by reshape_init.
5243 CUR is a pointer to the current element being processed, END is a pointer
5244 after the last element present in the initializer. */
5245 typedef struct reshape_iterator_t
5247 constructor_elt
*cur
;
5248 constructor_elt
*end
;
5251 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5253 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5254 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5255 initialized. If there are no more such fields, the return value
5259 next_initializable_field (tree field
)
5262 && (TREE_CODE (field
) != FIELD_DECL
5263 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5264 || DECL_ARTIFICIAL (field
)))
5265 field
= DECL_CHAIN (field
);
5270 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5271 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5272 INTEGER_CST representing the size of the array minus one (the maximum index),
5273 or NULL_TREE if the array was declared without specifying the size. D is
5274 the iterator within the constructor. */
5277 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5278 tsubst_flags_t complain
)
5281 bool sized_array_p
= (max_index
&& TREE_CONSTANT (max_index
));
5282 unsigned HOST_WIDE_INT max_index_cst
= 0;
5283 unsigned HOST_WIDE_INT index
;
5285 /* The initializer for an array is always a CONSTRUCTOR. */
5286 new_init
= build_constructor (init_list_type_node
, NULL
);
5290 /* Minus 1 is used for zero sized arrays. */
5291 if (integer_all_onesp (max_index
))
5294 if (tree_fits_uhwi_p (max_index
))
5295 max_index_cst
= tree_to_uhwi (max_index
);
5296 /* sizetype is sign extended, not zero extended. */
5298 max_index_cst
= tree_to_uhwi (fold_convert (size_type_node
, max_index
));
5301 /* Loop until there are no more initializers. */
5303 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5307 constructor_elt
*old_cur
= d
->cur
;
5309 check_array_designated_initializer (d
->cur
, index
);
5310 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5312 if (elt_init
== error_mark_node
)
5313 return error_mark_node
;
5314 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5315 size_int (index
), elt_init
);
5316 if (!TREE_CONSTANT (elt_init
))
5317 TREE_CONSTANT (new_init
) = false;
5319 /* This can happen with an invalid initializer (c++/54501). */
5320 if (d
->cur
== old_cur
&& !sized_array_p
)
5327 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5328 Parameters are the same of reshape_init_r. */
5331 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5333 tree max_index
= NULL_TREE
;
5335 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5337 if (TYPE_DOMAIN (type
))
5338 max_index
= array_type_nelts (type
);
5340 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5343 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5344 Parameters are the same of reshape_init_r. */
5347 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5349 tree max_index
= NULL_TREE
;
5351 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
5353 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5355 tree value
= d
->cur
->value
;
5356 if (!same_type_p (TREE_TYPE (value
), type
))
5358 if (complain
& tf_error
)
5359 error ("invalid type %qT as initializer for a vector of type %qT",
5360 TREE_TYPE (d
->cur
->value
), type
);
5361 value
= error_mark_node
;
5367 /* For a vector, we initialize it as an array of the appropriate size. */
5368 if (TREE_CODE (type
) == VECTOR_TYPE
)
5369 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5371 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5374 /* Subroutine of reshape_init_r, processes the initializers for classes
5375 or union. Parameters are the same of reshape_init_r. */
5378 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5379 tsubst_flags_t complain
)
5384 gcc_assert (CLASS_TYPE_P (type
));
5386 /* The initializer for a class is always a CONSTRUCTOR. */
5387 new_init
= build_constructor (init_list_type_node
, NULL
);
5388 field
= next_initializable_field (TYPE_FIELDS (type
));
5394 An initializer for an aggregate member that is an
5395 empty class shall have the form of an empty
5396 initializer-list {}. */
5397 if (!first_initializer_p
)
5399 if (complain
& tf_error
)
5400 error ("initializer for %qT must be brace-enclosed", type
);
5401 return error_mark_node
;
5406 /* Loop through the initializable fields, gathering initializers. */
5407 while (d
->cur
!= d
->end
)
5410 constructor_elt
*old_cur
= d
->cur
;
5412 /* Handle designated initializers, as an extension. */
5415 if (d
->cur
->index
== error_mark_node
)
5416 return error_mark_node
;
5418 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5419 /* We already reshaped this. */
5420 gcc_assert (d
->cur
->index
== field
);
5421 else if (TREE_CODE (d
->cur
->index
) == IDENTIFIER_NODE
)
5422 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5425 if (complain
& tf_error
)
5426 error ("%<[%E] =%> used in a GNU-style designated initializer"
5427 " for class %qT", d
->cur
->index
, type
);
5428 return error_mark_node
;
5431 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5433 if (complain
& tf_error
)
5434 error ("%qT has no non-static data member named %qD", type
,
5436 return error_mark_node
;
5440 /* If we processed all the member of the class, we are done. */
5444 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5445 /*first_initializer_p=*/false, complain
);
5446 if (field_init
== error_mark_node
)
5447 return error_mark_node
;
5449 if (d
->cur
== old_cur
&& d
->cur
->index
)
5451 /* This can happen with an invalid initializer for a flexible
5452 array member (c++/54441). */
5453 if (complain
& tf_error
)
5454 error ("invalid initializer for %q#D", field
);
5455 return error_mark_node
;
5458 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5462 When a union is initialized with a brace-enclosed
5463 initializer, the braces shall only contain an
5464 initializer for the first member of the union. */
5465 if (TREE_CODE (type
) == UNION_TYPE
)
5468 field
= next_initializable_field (DECL_CHAIN (field
));
5474 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5475 designators are not valid; either complain or return true to indicate
5476 that reshape_init_r should return error_mark_node. */
5479 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5483 if (complain
& tf_error
)
5484 error ("C99 designator %qE outside aggregate initializer",
5492 /* Subroutine of reshape_init, which processes a single initializer (part of
5493 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5494 iterator within the CONSTRUCTOR which points to the initializer to process.
5495 FIRST_INITIALIZER_P is true if this is the first initializer of the
5496 outermost CONSTRUCTOR node. */
5499 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5500 tsubst_flags_t complain
)
5502 tree init
= d
->cur
->value
;
5504 if (error_operand_p (init
))
5505 return error_mark_node
;
5507 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5508 && has_designator_problem (d
, complain
))
5509 return error_mark_node
;
5511 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5513 /* A complex type can be initialized from one or two initializers,
5514 but braces are not elided. */
5516 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5518 if (CONSTRUCTOR_NELTS (init
) > 2)
5520 if (complain
& tf_error
)
5521 error ("too many initializers for %qT", type
);
5523 return error_mark_node
;
5526 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5528 vec
<constructor_elt
, va_gc
> *v
= 0;
5529 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5530 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5531 if (has_designator_problem (d
, complain
))
5532 return error_mark_node
;
5534 init
= build_constructor (init_list_type_node
, v
);
5539 /* A non-aggregate type is always initialized with a single
5541 if (!CP_AGGREGATE_TYPE_P (type
))
5543 /* It is invalid to initialize a non-aggregate type with a
5544 brace-enclosed initializer before C++0x.
5545 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5546 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5547 a CONSTRUCTOR (with a record type). */
5548 if (TREE_CODE (init
) == CONSTRUCTOR
5549 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5551 if (SCALAR_TYPE_P (type
))
5553 if (cxx_dialect
< cxx11
5554 /* Isn't value-initialization. */
5555 || CONSTRUCTOR_NELTS (init
) > 0)
5557 if (complain
& tf_error
)
5558 error ("braces around scalar initializer for type %qT",
5560 init
= error_mark_node
;
5564 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5571 /* "If T is a class type and the initializer list has a single element of
5572 type cv U, where U is T or a class derived from T, the object is
5573 initialized from that element." Even if T is an aggregate. */
5574 if (cxx_dialect
>= cxx11
&& (CLASS_TYPE_P (type
) || VECTOR_TYPE_P (type
))
5575 && first_initializer_p
5576 && d
->end
- d
->cur
== 1
5577 && reference_related_p (type
, TREE_TYPE (init
)))
5585 All implicit type conversions (clause _conv_) are considered when
5586 initializing the aggregate member with an initializer from an
5587 initializer-list. If the initializer can initialize a member,
5588 the member is initialized. Otherwise, if the member is itself a
5589 non-empty subaggregate, brace elision is assumed and the
5590 initializer is considered for the initialization of the first
5591 member of the subaggregate. */
5592 if (TREE_CODE (init
) != CONSTRUCTOR
5593 /* But don't try this for the first initializer, since that would be
5594 looking through the outermost braces; A a2 = { a1 }; is not a
5595 valid aggregate initialization. */
5596 && !first_initializer_p
5597 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5598 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5605 /* [dcl.init.string]
5607 A char array (whether plain char, signed char, or unsigned char)
5608 can be initialized by a string-literal (optionally enclosed in
5609 braces); a wchar_t array can be initialized by a wide
5610 string-literal (optionally enclosed in braces). */
5611 if (TREE_CODE (type
) == ARRAY_TYPE
5612 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5614 tree str_init
= init
;
5616 /* Strip one level of braces if and only if they enclose a single
5617 element (as allowed by [dcl.init.string]). */
5618 if (!first_initializer_p
5619 && TREE_CODE (str_init
) == CONSTRUCTOR
5620 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5622 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5625 /* If it's a string literal, then it's the initializer for the array
5626 as a whole. Otherwise, continue with normal initialization for
5627 array types (one value per array element). */
5628 if (TREE_CODE (str_init
) == STRING_CST
)
5630 if (has_designator_problem (d
, complain
))
5631 return error_mark_node
;
5637 /* The following cases are about aggregates. If we are not within a full
5638 initializer already, and there is not a CONSTRUCTOR, it means that there
5639 is a missing set of braces (that is, we are processing the case for
5640 which reshape_init exists). */
5641 if (!first_initializer_p
)
5643 if (TREE_CODE (init
) == CONSTRUCTOR
)
5645 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5646 /* There is no need to reshape pointer-to-member function
5647 initializers, as they are always constructed correctly
5648 by the front end. */
5650 else if (COMPOUND_LITERAL_P (init
))
5651 /* For a nested compound literal, there is no need to reshape since
5652 brace elision is not allowed. Even if we decided to allow it,
5653 we should add a call to reshape_init in finish_compound_literal,
5654 before calling digest_init, so changing this code would still
5655 not be necessary. */
5656 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5660 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5661 return reshape_init (type
, init
, complain
);
5665 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5669 /* Dispatch to specialized routines. */
5670 if (CLASS_TYPE_P (type
))
5671 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5672 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5673 return reshape_init_array (type
, d
, complain
);
5674 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5675 return reshape_init_vector (type
, d
, complain
);
5680 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5681 brace-enclosed aggregate initializer.
5683 INIT is the CONSTRUCTOR containing the list of initializers describing
5684 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5685 It may not presently match the shape of the TYPE; for example:
5687 struct S { int a; int b; };
5688 struct S a[] = { 1, 2, 3, 4 };
5690 Here INIT will hold a vector of four elements, rather than a
5691 vector of two elements, each itself a vector of two elements. This
5692 routine transforms INIT from the former form into the latter. The
5693 revised CONSTRUCTOR node is returned. */
5696 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5698 vec
<constructor_elt
, va_gc
> *v
;
5702 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5704 v
= CONSTRUCTOR_ELTS (init
);
5706 /* An empty constructor does not need reshaping, and it is always a valid
5708 if (vec_safe_is_empty (v
))
5711 /* Recurse on this CONSTRUCTOR. */
5713 d
.end
= d
.cur
+ v
->length ();
5715 new_init
= reshape_init_r (type
, &d
, true, complain
);
5716 if (new_init
== error_mark_node
)
5717 return error_mark_node
;
5719 /* Make sure all the element of the constructor were used. Otherwise,
5720 issue an error about exceeding initializers. */
5723 if (complain
& tf_error
)
5724 error ("too many initializers for %qT", type
);
5726 return error_mark_node
;
5732 /* Verify array initializer. Returns true if errors have been reported. */
5735 check_array_initializer (tree decl
, tree type
, tree init
)
5737 tree element_type
= TREE_TYPE (type
);
5739 /* The array type itself need not be complete, because the
5740 initializer may tell us how many elements are in the array.
5741 But, the elements of the array must be complete. */
5742 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5745 error ("elements of array %q#D have incomplete type", decl
);
5747 error ("elements of array %q#T have incomplete type", type
);
5750 /* A compound literal can't have variable size. */
5752 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5753 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5755 error ("variable-sized compound literal");
5761 /* Subroutine of check_initializer; args are passed down from that function.
5762 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5765 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5768 gcc_assert (stmts_are_full_exprs_p ());
5769 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5772 /* Verify INIT (the initializer for DECL), and record the
5773 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5774 grok_reference_init.
5776 If the return value is non-NULL, it is an expression that must be
5777 evaluated dynamically to initialize DECL. */
5780 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5782 tree type
= TREE_TYPE (decl
);
5783 tree init_code
= NULL
;
5786 /* Things that are going to be initialized need to have complete
5788 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5790 if (DECL_HAS_VALUE_EXPR_P (decl
))
5792 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5793 it doesn't have storage to be initialized. */
5794 gcc_assert (init
== NULL_TREE
);
5798 if (type
== error_mark_node
)
5799 /* We will have already complained. */
5802 if (TREE_CODE (type
) == ARRAY_TYPE
)
5804 if (check_array_initializer (decl
, type
, init
))
5807 else if (!COMPLETE_TYPE_P (type
))
5809 error ("%q#D has incomplete type", decl
);
5810 TREE_TYPE (decl
) = error_mark_node
;
5814 /* There is no way to make a variable-sized class type in GNU C++. */
5815 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5817 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5819 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5820 if (SCALAR_TYPE_P (type
))
5824 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5825 init
= build_zero_init (type
, NULL_TREE
, false);
5827 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5829 error ("scalar object %qD requires one element in initializer",
5831 TREE_TYPE (decl
) = error_mark_node
;
5837 if (TREE_CODE (decl
) == CONST_DECL
)
5839 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5841 DECL_INITIAL (decl
) = init
;
5843 gcc_assert (init
!= NULL_TREE
);
5846 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5848 else if (init
|| type_build_ctor_call (type
)
5849 || TREE_CODE (type
) == REFERENCE_TYPE
)
5851 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5853 init
= grok_reference_init (decl
, type
, init
, flags
);
5854 flags
|= LOOKUP_ALREADY_DIGESTED
;
5857 check_for_uninitialized_const_var (decl
);
5858 /* Do not reshape constructors of vectors (they don't need to be
5860 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5862 if (is_std_init_list (type
))
5864 init
= perform_implicit_conversion (type
, init
,
5865 tf_warning_or_error
);
5866 flags
|= LOOKUP_ALREADY_DIGESTED
;
5868 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5870 /* Don't reshape if the class has constructors. */
5871 if (cxx_dialect
== cxx98
)
5872 error ("in C++98 %qD must be initialized by constructor, "
5876 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5878 error ("opaque vector types cannot be initialized");
5879 init
= error_mark_node
;
5883 init
= reshape_init (type
, init
, tf_warning_or_error
);
5884 flags
|= LOOKUP_NO_NARROWING
;
5887 else if (TREE_CODE (init
) == TREE_LIST
5888 && TREE_TYPE (init
) != unknown_type_node
5889 && !MAYBE_CLASS_TYPE_P (type
))
5891 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
5893 /* We get here with code like `int a (2);' */
5894 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
5895 tf_warning_or_error
);
5898 /* If DECL has an array type without a specific bound, deduce the
5899 array size from the initializer. */
5900 maybe_deduce_size_from_array_init (decl
, init
);
5901 type
= TREE_TYPE (decl
);
5902 if (type
== error_mark_node
)
5905 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5906 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5907 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5908 && CP_AGGREGATE_TYPE_P (type
)
5909 && (CLASS_TYPE_P (type
)
5910 || !TYPE_NEEDS_CONSTRUCTING (type
)
5911 || type_has_extended_temps (type
))))
5913 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5915 /* A constructor call is a non-trivial initializer even if
5916 it isn't explicitly written. */
5917 if (TREE_SIDE_EFFECTS (init_code
))
5918 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5920 /* If this is a constexpr initializer, expand_default_init will
5921 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5922 case, pull the initializer back out and pass it down into
5923 store_init_value. */
5924 while (TREE_CODE (init_code
) == EXPR_STMT
5925 || TREE_CODE (init_code
) == CONVERT_EXPR
)
5926 init_code
= TREE_OPERAND (init_code
, 0);
5927 if (TREE_CODE (init_code
) == INIT_EXPR
)
5929 init
= TREE_OPERAND (init_code
, 1);
5930 init_code
= NULL_TREE
;
5931 /* Don't call digest_init; it's unnecessary and will complain
5932 about aggregate initialization of non-aggregate classes. */
5933 flags
|= LOOKUP_ALREADY_DIGESTED
;
5935 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
5937 /* Declared constexpr, but no suitable initializer; massage
5938 init appropriately so we can pass it into store_init_value
5940 if (CLASS_TYPE_P (type
)
5941 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
5943 init
= build_functional_cast (type
, init
, tf_none
);
5944 if (TREE_CODE (init
) == TARGET_EXPR
)
5945 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
5947 init_code
= NULL_TREE
;
5953 if (init
&& TREE_CODE (init
) != TREE_VEC
)
5955 /* In aggregate initialization of a variable, each element
5956 initialization is a full-expression because there is no
5957 enclosing expression. */
5958 gcc_assert (stmts_are_full_exprs_p ());
5960 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
5962 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5963 && DECL_INITIAL (decl
)
5964 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5965 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5966 warning (0, "array %qD initialized by parenthesized string literal %qE",
5967 decl
, DECL_INITIAL (decl
));
5973 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
5974 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
5975 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
5976 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
5979 check_for_uninitialized_const_var (decl
);
5982 if (init
&& init
!= error_mark_node
)
5983 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5987 /* We might have set these in cp_finish_decl. */
5988 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = false;
5989 TREE_CONSTANT (decl
) = false;
5992 if (init_code
&& DECL_IN_AGGR_P (decl
))
5994 static int explained
= 0;
5996 if (cxx_dialect
< cxx11
)
5997 error ("initializer invalid for static member with constructor");
5999 error ("non-constant in-class initialization invalid for static "
6000 "member %qD", decl
);
6003 inform (input_location
,
6004 "(an out of class initialization is required)");
6013 /* If DECL is not a local variable, give it RTL. */
6016 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
6018 int toplev
= toplevel_bindings_p ();
6020 const char *filename
;
6022 /* Set the DECL_ASSEMBLER_NAME for the object. */
6025 /* The `register' keyword, when used together with an
6026 asm-specification, indicates that the variable should be
6027 placed in a particular register. */
6028 if (VAR_P (decl
) && DECL_REGISTER (decl
))
6030 set_user_assembler_name (decl
, asmspec
);
6031 DECL_HARD_REGISTER (decl
) = 1;
6035 if (TREE_CODE (decl
) == FUNCTION_DECL
6036 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
6037 set_builtin_user_assembler_name (decl
, asmspec
);
6038 set_user_assembler_name (decl
, asmspec
);
6042 /* Handle non-variables up front. */
6045 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6049 /* If we see a class member here, it should be a static data
6051 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
6053 gcc_assert (TREE_STATIC (decl
));
6054 /* An in-class declaration of a static data member should be
6055 external; it is only a declaration, and not a definition. */
6056 if (init
== NULL_TREE
)
6057 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
6060 /* We don't create any RTL for local variables. */
6061 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6064 /* We defer emission of local statics until the corresponding
6065 DECL_EXPR is expanded. */
6066 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
6068 /* We try to defer namespace-scope static constants so that they are
6069 not emitted into the object file unnecessarily. */
6070 filename
= LOCATION_FILE (input_location
);
6071 if (!DECL_VIRTUAL_P (decl
)
6072 && TREE_READONLY (decl
)
6073 && DECL_INITIAL (decl
) != NULL_TREE
6074 && DECL_INITIAL (decl
) != error_mark_node
6076 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
6078 && !TREE_PUBLIC (decl
))
6080 /* Fool with the linkage of static consts according to #pragma
6082 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
6083 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
6085 TREE_PUBLIC (decl
) = 1;
6086 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
6091 /* Likewise for template instantiations. */
6092 else if (DECL_LANG_SPECIFIC (decl
)
6093 && DECL_IMPLICIT_INSTANTIATION (decl
))
6096 /* If we're not deferring, go ahead and assemble the variable. */
6098 rest_of_decl_compilation (decl
, toplev
, at_eof
);
6101 /* walk_tree helper for wrap_temporary_cleanups, below. */
6104 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
6106 /* Stop at types or full-expression boundaries. */
6107 if (TYPE_P (*stmt_p
)
6108 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
6114 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
6116 tree guard
= (tree
)data
;
6117 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
6119 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
6120 /* Tell honor_protect_cleanup_actions to handle this as a separate
6122 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
6124 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
6130 /* We're initializing a local variable which has a cleanup GUARD. If there
6131 are any temporaries used in the initializer INIT of this variable, we
6132 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6133 variable will be cleaned up properly if one of them throws.
6135 Unfortunately, there's no way to express this properly in terms of
6136 nesting, as the regions for the temporaries overlap the region for the
6137 variable itself; if there are two temporaries, the variable needs to be
6138 the first thing destroyed if either of them throws. However, we only
6139 want to run the variable's cleanup if it actually got constructed. So
6140 we need to guard the temporary cleanups with the variable's cleanup if
6141 they are run on the normal path, but not if they are run on the
6142 exceptional path. We implement this by telling
6143 honor_protect_cleanup_actions to strip the variable cleanup from the
6144 exceptional path. */
6147 wrap_temporary_cleanups (tree init
, tree guard
)
6149 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
6152 /* Generate code to initialize DECL (a local variable). */
6155 initialize_local_var (tree decl
, tree init
)
6157 tree type
= TREE_TYPE (decl
);
6161 gcc_assert (VAR_P (decl
)
6162 || TREE_CODE (decl
) == RESULT_DECL
);
6163 gcc_assert (!TREE_STATIC (decl
));
6165 if (DECL_SIZE (decl
) == NULL_TREE
)
6167 /* If we used it already as memory, it must stay in memory. */
6168 DECL_INITIAL (decl
) = NULL_TREE
;
6169 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
6173 if (type
== error_mark_node
)
6176 /* Compute and store the initial value. */
6177 already_used
= TREE_USED (decl
) || TREE_USED (type
);
6178 if (TREE_USED (type
))
6179 DECL_READ_P (decl
) = 1;
6181 /* Generate a cleanup, if necessary. */
6182 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
6184 /* Perform the initialization. */
6187 tree rinit
= (TREE_CODE (init
) == INIT_EXPR
6188 ? TREE_OPERAND (init
, 1) : NULL_TREE
);
6189 if (rinit
&& !TREE_SIDE_EFFECTS (rinit
))
6191 /* Stick simple initializers in DECL_INITIAL so that
6192 -Wno-init-self works (c++/34772). */
6193 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
6194 DECL_INITIAL (decl
) = rinit
;
6196 if (warn_init_self
&& TREE_CODE (type
) == REFERENCE_TYPE
)
6200 warning_at (DECL_SOURCE_LOCATION (decl
),
6202 "reference %qD is initialized with itself", decl
);
6207 int saved_stmts_are_full_exprs_p
;
6209 /* If we're only initializing a single object, guard the
6210 destructors of any temporaries used in its initializer with
6211 its destructor. This isn't right for arrays because each
6212 element initialization is a full-expression. */
6213 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
6214 wrap_temporary_cleanups (init
, cleanup
);
6216 gcc_assert (building_stmt_list_p ());
6217 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
6218 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
6219 finish_expr_stmt (init
);
6220 current_stmt_tree ()->stmts_are_full_exprs_p
=
6221 saved_stmts_are_full_exprs_p
;
6225 /* Set this to 0 so we can tell whether an aggregate which was
6226 initialized was ever used. Don't do this if it has a
6227 destructor, so we don't complain about the 'resource
6228 allocation is initialization' idiom. Now set
6229 attribute((unused)) on types so decls of that type will be
6230 marked used. (see TREE_USED, above.) */
6231 if (TYPE_NEEDS_CONSTRUCTING (type
)
6233 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
6234 && DECL_NAME (decl
))
6235 TREE_USED (decl
) = 0;
6236 else if (already_used
)
6237 TREE_USED (decl
) = 1;
6240 finish_decl_cleanup (decl
, cleanup
);
6243 /* DECL is a VAR_DECL for a compiler-generated variable with static
6244 storage duration (like a virtual table) whose initializer is a
6245 compile-time constant. Initialize the variable and provide it to the
6249 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
6252 gcc_assert (DECL_ARTIFICIAL (decl
));
6253 init
= build_constructor (TREE_TYPE (decl
), v
);
6254 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
6255 DECL_INITIAL (decl
) = init
;
6256 DECL_INITIALIZED_P (decl
) = 1;
6257 determine_visibility (decl
);
6258 layout_var_decl (decl
);
6259 maybe_commonize_var (decl
);
6260 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6263 /* INIT is the initializer for a variable, as represented by the
6264 parser. Returns true iff INIT is type-dependent. */
6267 type_dependent_init_p (tree init
)
6269 if (TREE_CODE (init
) == TREE_LIST
)
6270 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6271 return any_type_dependent_elements_p (init
);
6272 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6273 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6275 vec
<constructor_elt
, va_gc
> *elts
;
6279 elts
= CONSTRUCTOR_ELTS (init
);
6280 nelts
= vec_safe_length (elts
);
6281 for (i
= 0; i
< nelts
; ++i
)
6282 if (type_dependent_init_p ((*elts
)[i
].value
))
6286 /* It must be a simple expression, e.g., int i = 3; */
6287 return type_dependent_expression_p (init
);
6292 /* INIT is the initializer for a variable, as represented by the
6293 parser. Returns true iff INIT is value-dependent. */
6296 value_dependent_init_p (tree init
)
6298 if (TREE_CODE (init
) == TREE_LIST
)
6299 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6300 return any_value_dependent_elements_p (init
);
6301 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6302 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6304 vec
<constructor_elt
, va_gc
> *elts
;
6308 elts
= CONSTRUCTOR_ELTS (init
);
6309 nelts
= vec_safe_length (elts
);
6310 for (i
= 0; i
< nelts
; ++i
)
6311 if (value_dependent_init_p ((*elts
)[i
].value
))
6315 /* It must be a simple expression, e.g., int i = 3; */
6316 return value_dependent_expression_p (init
);
6321 /* Finish processing of a declaration;
6322 install its line number and initial value.
6323 If the length of an array type is not known before,
6324 it must be determined now, from the initial value, or it is an error.
6326 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6327 true, then INIT is an integral constant expression.
6329 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6330 if the (init) syntax was used. */
6333 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6334 tree asmspec_tree
, int flags
)
6337 vec
<tree
, va_gc
> *cleanups
= NULL
;
6338 const char *asmspec
= NULL
;
6339 int was_readonly
= 0;
6340 bool var_definition_p
= false;
6343 if (decl
== error_mark_node
)
6348 error ("assignment (not initialization) in declaration");
6352 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6353 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6354 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6356 type
= TREE_TYPE (decl
);
6357 if (type
== error_mark_node
)
6360 /* If a name was specified, get the string. */
6361 if (at_namespace_scope_p ())
6362 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6363 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6364 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6366 if (current_class_type
6367 && CP_DECL_CONTEXT (decl
) == current_class_type
6368 && TYPE_BEING_DEFINED (current_class_type
)
6369 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6370 && (DECL_INITIAL (decl
) || init
))
6371 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6373 if (TREE_CODE (decl
) != FUNCTION_DECL
6374 && (auto_node
= type_uses_auto (type
)))
6377 if (init
== NULL_TREE
)
6379 if (DECL_LANG_SPECIFIC (decl
)
6380 && DECL_TEMPLATE_INSTANTIATION (decl
)
6381 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6383 /* init is null because we're deferring instantiating the
6384 initializer until we need it. Well, we need it now. */
6385 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6389 error ("declaration of %q#D has no initializer", decl
);
6390 TREE_TYPE (decl
) = error_mark_node
;
6394 if (TREE_CODE (d_init
) == TREE_LIST
)
6395 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6396 tf_warning_or_error
);
6397 d_init
= resolve_nondeduced_context (d_init
);
6398 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6400 if (type
== error_mark_node
)
6402 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
6405 if (!ensure_literal_type_for_constexpr_object (decl
))
6406 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6409 && DECL_CLASS_SCOPE_P (decl
)
6410 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6411 check_static_variable_definition (decl
, type
);
6413 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6416 if (init
== ridpointers
[(int)RID_DELETE
])
6418 /* FIXME check this is 1st decl. */
6419 DECL_DELETED_FN (decl
) = 1;
6420 DECL_DECLARED_INLINE_P (decl
) = 1;
6421 DECL_INITIAL (decl
) = error_mark_node
;
6422 FOR_EACH_CLONE (clone
, decl
)
6424 DECL_DELETED_FN (clone
) = 1;
6425 DECL_DECLARED_INLINE_P (clone
) = 1;
6426 DECL_INITIAL (clone
) = error_mark_node
;
6430 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6432 if (defaultable_fn_check (decl
))
6433 DECL_DEFAULTED_FN (decl
) = 1;
6435 DECL_INITIAL (decl
) = NULL_TREE
;
6439 if (init
&& VAR_P (decl
))
6441 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6442 /* If DECL is a reference, then we want to know whether init is a
6443 reference constant; init_const_expr_p as passed tells us whether
6444 it's an rvalue constant. */
6445 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6446 init_const_expr_p
= potential_constant_expression (init
);
6447 if (init_const_expr_p
)
6449 /* Set these flags now for templates. We'll update the flags in
6450 store_init_value for instantiations. */
6451 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6452 if (decl_maybe_constant_var_p (decl
))
6453 TREE_CONSTANT (decl
) = 1;
6457 if (processing_template_decl
)
6459 bool type_dependent_p
;
6461 /* Add this declaration to the statement-tree. */
6462 if (at_function_scope_p ())
6463 add_decl_expr (decl
);
6465 type_dependent_p
= dependent_type_p (type
);
6467 if (check_for_bare_parameter_packs (init
))
6470 DECL_INITIAL (decl
) = NULL_TREE
;
6473 /* Generally, initializers in templates are expanded when the
6474 template is instantiated. But, if DECL is a variable constant
6475 then it can be used in future constant expressions, so its value
6476 must be available. */
6478 if (!VAR_P (decl
) || dependent_type_p (type
))
6479 /* We can't do anything if the decl has dependent type. */;
6481 && init_const_expr_p
6482 && !type_dependent_p
6483 && TREE_CODE (type
) != REFERENCE_TYPE
6484 && decl_maybe_constant_var_p (decl
)
6485 && !type_dependent_init_p (init
)
6486 && !value_dependent_init_p (init
))
6488 /* This variable seems to be a non-dependent constant, so process
6489 its initializer. If check_initializer returns non-null the
6490 initialization wasn't constant after all. */
6492 cleanups
= make_tree_vector ();
6493 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6494 if (init_code
== NULL_TREE
)
6496 release_tree_vector (cleanups
);
6498 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6500 /* Deduce array size even if the initializer is dependent. */
6501 maybe_deduce_size_from_array_init (decl
, init
);
6502 /* And complain about multiple initializers. */
6503 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6504 && !MAYBE_CLASS_TYPE_P (type
))
6505 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6506 tf_warning_or_error
);
6510 DECL_INITIAL (decl
) = init
;
6514 /* Just store non-static data member initializers for later. */
6515 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6516 DECL_INITIAL (decl
) = init
;
6518 /* Take care of TYPE_DECLs up front. */
6519 if (TREE_CODE (decl
) == TYPE_DECL
)
6521 if (type
!= error_mark_node
6522 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6524 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6525 warning (0, "shadowing previous type declaration of %q#D", decl
);
6526 set_identifier_type_value (DECL_NAME (decl
), decl
);
6529 /* If we have installed this as the canonical typedef for this
6530 type, and that type has not been defined yet, delay emitting
6531 the debug information for it, as we will emit it later. */
6532 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6533 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6534 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6536 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6541 /* A reference will be modified here, as it is initialized. */
6542 if (! DECL_EXTERNAL (decl
)
6543 && TREE_READONLY (decl
)
6544 && TREE_CODE (type
) == REFERENCE_TYPE
)
6547 TREE_READONLY (decl
) = 0;
6552 /* If this is a local variable that will need a mangled name,
6553 register it now. We must do this before processing the
6554 initializer for the variable, since the initialization might
6555 require a guard variable, and since the mangled name of the
6556 guard variable will depend on the mangled name of this
6558 if (DECL_FUNCTION_SCOPE_P (decl
)
6559 && TREE_STATIC (decl
)
6560 && !DECL_ARTIFICIAL (decl
))
6562 push_local_name (decl
);
6563 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6564 || DECL_DESTRUCTOR_P (current_function_decl
))
6565 /* Normally local_decls is populated during GIMPLE lowering,
6566 but [cd]tors are never actually compiled directly. We need
6567 to put statics on the list so we can deal with the label
6568 address extension. FIXME. */
6569 add_local_decl (cfun
, decl
);
6572 /* Convert the initializer to the type of DECL, if we have not
6573 already initialized DECL. */
6574 if (!DECL_INITIALIZED_P (decl
)
6575 /* If !DECL_EXTERNAL then DECL is being defined. In the
6576 case of a static data member initialized inside the
6577 class-specifier, there can be an initializer even if DECL
6578 is *not* defined. */
6579 && (!DECL_EXTERNAL (decl
) || init
))
6581 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6584 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6585 /* Allow libjava/prims.cc define primitive classes. */
6586 if (init
!= NULL_TREE
6587 || jclass
== NULL_TREE
6588 || TREE_CODE (jclass
) != TYPE_DECL
6589 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6590 || !same_type_ignoring_top_level_qualifiers_p
6591 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6592 error ("Java object %qD not allocated with %<new%>", decl
);
6595 cleanups
= make_tree_vector ();
6596 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6602 The memory occupied by any object of static storage
6603 duration is zero-initialized at program startup before
6604 any other initialization takes place.
6606 We cannot create an appropriate initializer until after
6607 the type of DECL is finalized. If DECL_INITIAL is set,
6608 then the DECL is statically initialized, and any
6609 necessary zero-initialization has already been performed. */
6610 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6611 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6612 /*nelts=*/NULL_TREE
,
6613 /*static_storage_p=*/true);
6614 /* Remember that the initialization for this variable has
6616 DECL_INITIALIZED_P (decl
) = 1;
6617 /* This declaration is the definition of this variable,
6618 unless we are initializing a static data member within
6619 the class specifier. */
6620 if (!DECL_EXTERNAL (decl
))
6621 var_definition_p
= true;
6623 /* If the variable has an array type, lay out the type, even if
6624 there is no initializer. It is valid to index through the
6625 array, and we must get TYPE_ALIGN set correctly on the array
6627 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6630 if (TREE_STATIC (decl
)
6631 && !at_function_scope_p ()
6632 && current_function_decl
== NULL
)
6633 /* So decl is a global variable or a static member of a
6634 non local class. Record the types it uses
6635 so that we can decide later to emit debug info for them. */
6636 record_types_used_by_current_var_decl (decl
);
6638 else if (TREE_CODE (decl
) == FIELD_DECL
6639 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6640 error ("non-static data member %qD has Java class type", decl
);
6642 /* Add this declaration to the statement-tree. This needs to happen
6643 after the call to check_initializer so that the DECL_EXPR for a
6644 reference temp is added before the DECL_EXPR for the reference itself. */
6645 if (DECL_FUNCTION_SCOPE_P (decl
))
6647 /* If we're building a variable sized type, and we might be
6648 reachable other than via the top of the current binding
6649 level, then create a new BIND_EXPR so that we deallocate
6650 the object at the right time. */
6653 && !TREE_CONSTANT (DECL_SIZE (decl
))
6654 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list
))
6657 bind
= build3 (BIND_EXPR
, void_type_node
, NULL
, NULL
, NULL
);
6658 TREE_SIDE_EFFECTS (bind
) = 1;
6660 BIND_EXPR_BODY (bind
) = push_stmt_list ();
6662 add_decl_expr (decl
);
6665 /* Let the middle end know about variables and functions -- but not
6666 static data members in uninstantiated class templates. */
6667 if (VAR_OR_FUNCTION_DECL_P (decl
))
6671 layout_var_decl (decl
);
6672 maybe_commonize_var (decl
);
6675 /* This needs to happen after the linkage is set. */
6676 determine_visibility (decl
);
6678 if (var_definition_p
&& TREE_STATIC (decl
))
6680 /* If a TREE_READONLY variable needs initialization
6681 at runtime, it is no longer readonly and we need to
6682 avoid MEM_READONLY_P being set on RTL created for it. */
6685 if (TREE_READONLY (decl
))
6686 TREE_READONLY (decl
) = 0;
6689 else if (was_readonly
)
6690 TREE_READONLY (decl
) = 1;
6692 /* Likewise if it needs destruction. */
6693 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6694 TREE_READONLY (decl
) = 0;
6697 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6699 /* Check for abstractness of the type. Notice that there is no
6700 need to strip array types here since the check for those types
6701 is already done within create_array_type_for_decl. */
6702 abstract_virtuals_error (decl
, type
);
6704 if (TREE_TYPE (decl
) == error_mark_node
)
6705 /* No initialization required. */
6707 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6711 if (init
== ridpointers
[(int)RID_DEFAULT
])
6713 /* An out-of-class default definition is defined at
6714 the point where it is explicitly defaulted. */
6715 if (DECL_DELETED_FN (decl
))
6716 maybe_explain_implicit_delete (decl
);
6717 else if (DECL_INITIAL (decl
) == error_mark_node
)
6718 synthesize_method (decl
);
6721 error ("function %q#D is initialized like a variable", decl
);
6723 /* else no initialization required. */
6725 else if (DECL_EXTERNAL (decl
)
6726 && ! (DECL_LANG_SPECIFIC (decl
)
6727 && DECL_NOT_REALLY_EXTERN (decl
)))
6730 DECL_INITIAL (decl
) = init
;
6732 /* A variable definition. */
6733 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6734 /* Initialize the local variable. */
6735 initialize_local_var (decl
, init
);
6737 /* If a variable is defined, and then a subsequent
6738 definition with external linkage is encountered, we will
6739 get here twice for the same variable. We want to avoid
6740 calling expand_static_init more than once. For variables
6741 that are not static data members, we can call
6742 expand_static_init only when we actually process the
6743 initializer. It is not legal to redeclare a static data
6744 member, so this issue does not arise in that case. */
6745 else if (var_definition_p
&& TREE_STATIC (decl
))
6746 expand_static_init (decl
, init
);
6749 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6750 reference, insert it in the statement-tree now. */
6754 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6755 push_cleanup (decl
, t
, false);
6756 release_tree_vector (cleanups
);
6760 TREE_READONLY (decl
) = 1;
6762 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6765 /* Returns a declaration for a VAR_DECL as if:
6767 extern "C" TYPE NAME;
6769 had been seen. Used to create compiler-generated global
6773 declare_global_var (tree name
, tree type
)
6777 push_to_top_level ();
6778 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6779 TREE_PUBLIC (decl
) = 1;
6780 DECL_EXTERNAL (decl
) = 1;
6781 DECL_ARTIFICIAL (decl
) = 1;
6782 /* If the user has explicitly declared this variable (perhaps
6783 because the code we are compiling is part of a low-level runtime
6784 library), then it is possible that our declaration will be merged
6785 with theirs by pushdecl. */
6786 decl
= pushdecl (decl
);
6787 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6788 pop_from_top_level ();
6793 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6794 if "__cxa_atexit" is not being used) corresponding to the function
6795 to be called when the program exits. */
6798 get_atexit_fn_ptr_type (void)
6802 if (!atexit_fn_ptr_type_node
)
6805 if (flag_use_cxa_atexit
6806 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6807 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6808 arg_type
= ptr_type_node
;
6810 /* The parameter to "atexit" is "void (*)(void)". */
6811 arg_type
= NULL_TREE
;
6813 fn_type
= build_function_type_list (void_type_node
,
6814 arg_type
, NULL_TREE
);
6815 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6818 return atexit_fn_ptr_type_node
;
6821 /* Returns a pointer to the `atexit' function. Note that if
6822 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6823 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6826 get_atexit_node (void)
6832 bool use_aeabi_atexit
;
6837 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6839 /* The declaration for `__cxa_atexit' is:
6841 int __cxa_atexit (void (*)(void *), void *, void *)
6843 We build up the argument types and then the function type
6845 tree argtype0
, argtype1
, argtype2
;
6847 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6848 /* First, build the pointer-to-function type for the first
6850 fn_ptr_type
= get_atexit_fn_ptr_type ();
6851 /* Then, build the rest of the argument types. */
6852 argtype2
= ptr_type_node
;
6853 if (use_aeabi_atexit
)
6855 argtype1
= fn_ptr_type
;
6856 argtype0
= ptr_type_node
;
6860 argtype1
= ptr_type_node
;
6861 argtype0
= fn_ptr_type
;
6863 /* And the final __cxa_atexit type. */
6864 fn_type
= build_function_type_list (integer_type_node
,
6865 argtype0
, argtype1
, argtype2
,
6867 if (use_aeabi_atexit
)
6868 name
= "__aeabi_atexit";
6870 name
= "__cxa_atexit";
6874 /* The declaration for `atexit' is:
6876 int atexit (void (*)());
6878 We build up the argument types and then the function type
6880 fn_ptr_type
= get_atexit_fn_ptr_type ();
6881 /* Build the final atexit type. */
6882 fn_type
= build_function_type_list (integer_type_node
,
6883 fn_ptr_type
, NULL_TREE
);
6887 /* Now, build the function declaration. */
6888 push_lang_context (lang_name_c
);
6889 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
, ECF_LEAF
| ECF_NOTHROW
);
6890 mark_used (atexit_fndecl
);
6891 pop_lang_context ();
6892 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6897 /* Like get_atexit_node, but for thread-local cleanups. */
6900 get_thread_atexit_node (void)
6902 /* The declaration for `__cxa_thread_atexit' is:
6904 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6905 tree fn_type
= build_function_type_list (integer_type_node
,
6906 get_atexit_fn_ptr_type (),
6907 ptr_type_node
, ptr_type_node
,
6910 /* Now, build the function declaration. */
6911 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
,
6912 ECF_LEAF
| ECF_NOTHROW
);
6913 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6916 /* Returns the __dso_handle VAR_DECL. */
6919 get_dso_handle_node (void)
6921 if (dso_handle_node
)
6922 return dso_handle_node
;
6924 /* Declare the variable. */
6925 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6928 #ifdef HAVE_GAS_HIDDEN
6929 if (dso_handle_node
!= error_mark_node
)
6931 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6932 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6936 return dso_handle_node
;
6939 /* Begin a new function with internal linkage whose job will be simply
6940 to destroy some particular variable. */
6942 static GTY(()) int start_cleanup_cnt
;
6945 start_cleanup_fn (void)
6950 bool use_cxa_atexit
= flag_use_cxa_atexit
6951 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6953 push_to_top_level ();
6955 /* No need to mangle this. */
6956 push_lang_context (lang_name_c
);
6958 /* Build the name of the function. */
6959 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6960 /* Build the function declaration. */
6961 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6962 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6963 /* It's a function with internal linkage, generated by the
6965 TREE_PUBLIC (fndecl
) = 0;
6966 DECL_ARTIFICIAL (fndecl
) = 1;
6967 /* Make the function `inline' so that it is only emitted if it is
6968 actually needed. It is unlikely that it will be inlined, since
6969 it is only called via a function pointer, but we avoid unnecessary
6970 emissions this way. */
6971 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6972 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6973 /* Build the parameter. */
6978 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6979 DECL_CONTEXT (parmdecl
) = fndecl
;
6980 TREE_USED (parmdecl
) = 1;
6981 DECL_READ_P (parmdecl
) = 1;
6982 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6986 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6988 pop_lang_context ();
6990 return current_function_decl
;
6993 /* Finish the cleanup function begun by start_cleanup_fn. */
6996 end_cleanup_fn (void)
6998 expand_or_defer_fn (finish_function (0));
7000 pop_from_top_level ();
7003 /* Generate code to handle the destruction of DECL, an object with
7004 static storage duration. */
7007 register_dtor_fn (tree decl
)
7014 bool ob_parm
, dso_parm
, use_dtor
;
7015 tree arg0
, arg1
, arg2
;
7018 type
= TREE_TYPE (decl
);
7019 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
7022 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
7023 "__aeabi_atexit"), and DECL is a class object, we can just pass the
7024 destructor to "__cxa_atexit"; we don't have to build a temporary
7025 function to do the cleanup. */
7026 dso_parm
= (flag_use_cxa_atexit
7027 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
7028 ob_parm
= (DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
7029 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
7034 /* Find the destructor. */
7035 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
7036 gcc_assert (idx
>= 0);
7037 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
7038 /* Make sure it is accessible. */
7039 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
7040 tf_warning_or_error
);
7044 /* Call build_cleanup before we enter the anonymous function so
7045 that any access checks will be done relative to the current
7046 scope, rather than the scope of the anonymous function. */
7047 build_cleanup (decl
);
7049 /* Now start the function. */
7050 cleanup
= start_cleanup_fn ();
7052 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
7053 to the original function, rather than the anonymous one. That
7054 will make the back end think that nested functions are in use,
7055 which causes confusion. */
7056 push_deferring_access_checks (dk_no_check
);
7057 fcall
= build_cleanup (decl
);
7058 pop_deferring_access_checks ();
7060 /* Create the body of the anonymous function. */
7061 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
7062 finish_expr_stmt (fcall
);
7063 finish_compound_stmt (compound_stmt
);
7067 /* Call atexit with the cleanup function. */
7068 mark_used (cleanup
);
7069 cleanup
= build_address (cleanup
);
7071 if (DECL_THREAD_LOCAL_P (decl
))
7072 atex_node
= get_thread_atexit_node ();
7074 atex_node
= get_atexit_node ();
7078 /* We must convert CLEANUP to the type that "__cxa_atexit"
7080 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
7081 /* "__cxa_atexit" will pass the address of DECL to the
7082 cleanup function. */
7084 addr
= build_address (decl
);
7085 /* The declared type of the parameter to "__cxa_atexit" is
7086 "void *". For plain "T*", we could just let the
7087 machinery in cp_build_function_call convert it -- but if the
7088 type is "cv-qualified T *", then we need to convert it
7089 before passing it in, to avoid spurious errors. */
7090 addr
= build_nop (ptr_type_node
, addr
);
7093 /* Since the cleanup functions we build ignore the address
7094 they're given, there's no reason to pass the actual address
7095 in, and, in general, it's cheaper to pass NULL than any
7097 addr
= null_pointer_node
;
7100 arg2
= cp_build_addr_expr (get_dso_handle_node (),
7101 tf_warning_or_error
);
7103 /* Just pass NULL to the dso handle parm if we don't actually
7104 have a DSO handle on this target. */
7105 arg2
= null_pointer_node
;
7111 if (!DECL_THREAD_LOCAL_P (decl
)
7112 && targetm
.cxx
.use_aeabi_atexit ())
7128 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
7129 arg0
, arg1
, arg2
, NULL_TREE
);
7132 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
7133 is its initializer. Generate code to handle the construction
7134 and destruction of DECL. */
7137 expand_static_init (tree decl
, tree init
)
7139 gcc_assert (VAR_P (decl
));
7140 gcc_assert (TREE_STATIC (decl
));
7142 /* Some variables require no dynamic initialization. */
7144 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
7146 /* Make sure the destructor is callable. */
7147 cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
7151 if (DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
7152 && !DECL_FUNCTION_SCOPE_P (decl
))
7155 error ("non-local variable %qD declared %<__thread%> "
7156 "needs dynamic initialization", decl
);
7158 error ("non-local variable %qD declared %<__thread%> "
7159 "has a non-trivial destructor", decl
);
7160 static bool informed
;
7163 inform (DECL_SOURCE_LOCATION (decl
),
7164 "C++11 %<thread_local%> allows dynamic initialization "
7171 if (DECL_FUNCTION_SCOPE_P (decl
))
7173 /* Emit code to perform this initialization but once. */
7174 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
7175 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
7176 tree guard
, guard_addr
;
7178 /* We don't need thread-safety code for thread-local vars. */
7179 bool thread_guard
= (flag_threadsafe_statics
7180 && !DECL_THREAD_LOCAL_P (decl
));
7182 /* Emit code to perform this initialization but once. This code
7185 static <type> guard;
7186 if (!guard.first_byte) {
7187 if (__cxa_guard_acquire (&guard)) {
7190 // Do initialization.
7191 flag = true; __cxa_guard_release (&guard);
7192 // Register variable for destruction at end of program.
7194 if (!flag) __cxa_guard_abort (&guard);
7198 Note that the `flag' variable is only set to 1 *after* the
7199 initialization is complete. This ensures that an exception,
7200 thrown during the construction, will cause the variable to
7201 reinitialized when we pass through this code again, as per:
7205 If the initialization exits by throwing an exception, the
7206 initialization is not complete, so it will be tried again
7207 the next time control enters the declaration.
7209 This process should be thread-safe, too; multiple threads
7210 should not be able to initialize the variable more than
7213 /* Create the guard variable. */
7214 guard
= get_guard (decl
);
7216 /* This optimization isn't safe on targets with relaxed memory
7217 consistency. On such targets we force synchronization in
7218 __cxa_guard_acquire. */
7219 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7221 /* Begin the conditional initialization. */
7222 if_stmt
= begin_if_stmt ();
7223 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
7224 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7229 tree vfntype
= NULL_TREE
;
7230 tree acquire_name
, release_name
, abort_name
;
7231 tree acquire_fn
, release_fn
, abort_fn
;
7232 guard_addr
= build_address (guard
);
7234 acquire_name
= get_identifier ("__cxa_guard_acquire");
7235 release_name
= get_identifier ("__cxa_guard_release");
7236 abort_name
= get_identifier ("__cxa_guard_abort");
7237 acquire_fn
= identifier_global_value (acquire_name
);
7238 release_fn
= identifier_global_value (release_name
);
7239 abort_fn
= identifier_global_value (abort_name
);
7241 acquire_fn
= push_library_fn
7242 (acquire_name
, build_function_type_list (integer_type_node
,
7243 TREE_TYPE (guard_addr
),
7245 NULL_TREE
, ECF_NOTHROW
| ECF_LEAF
);
7246 if (!release_fn
|| !abort_fn
)
7247 vfntype
= build_function_type_list (void_type_node
,
7248 TREE_TYPE (guard_addr
),
7251 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
,
7252 ECF_NOTHROW
| ECF_LEAF
);
7254 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
,
7255 ECF_NOTHROW
| ECF_LEAF
);
7257 inner_if_stmt
= begin_if_stmt ();
7258 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
7261 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
7262 begin
= get_target_expr (boolean_false_node
);
7263 flag
= TARGET_EXPR_SLOT (begin
);
7265 TARGET_EXPR_CLEANUP (begin
)
7266 = build3 (COND_EXPR
, void_type_node
, flag
,
7268 build_call_n (abort_fn
, 1, guard_addr
));
7269 CLEANUP_EH_ONLY (begin
) = 1;
7271 /* Do the initialization itself. */
7272 init
= add_stmt_to_compound (begin
, init
);
7273 init
= add_stmt_to_compound
7274 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7275 init
= add_stmt_to_compound
7276 (init
, build_call_n (release_fn
, 1, guard_addr
));
7279 init
= add_stmt_to_compound (init
, set_guard (guard
));
7281 /* Use atexit to register a function for destroying this static
7283 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7285 finish_expr_stmt (init
);
7289 finish_compound_stmt (inner_then_clause
);
7290 finish_then_clause (inner_if_stmt
);
7291 finish_if_stmt (inner_if_stmt
);
7294 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7296 finish_compound_stmt (then_clause
);
7297 finish_then_clause (if_stmt
);
7298 finish_if_stmt (if_stmt
);
7301 else if (DECL_THREAD_LOCAL_P (decl
))
7302 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7304 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7308 /* Make TYPE a complete type based on INITIAL_VALUE.
7309 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7310 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7311 3 if the initializer list is empty (in pedantic mode). */
7314 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7317 tree type
, elt_type
;
7319 /* Don't get confused by a CONSTRUCTOR for some other type. */
7320 if (initial_value
&& TREE_CODE (initial_value
) == CONSTRUCTOR
7321 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value
))
7326 unsigned HOST_WIDE_INT i
;
7329 /* An array of character type can be initialized from a
7330 brace-enclosed string constant.
7332 FIXME: this code is duplicated from reshape_init. Probably
7333 we should just call reshape_init here? */
7334 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7335 && TREE_CODE (initial_value
) == CONSTRUCTOR
7336 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7338 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7339 tree value
= (*v
)[0].value
;
7341 if (TREE_CODE (value
) == STRING_CST
7342 && v
->length () == 1)
7343 initial_value
= value
;
7346 /* If any of the elements are parameter packs, we can't actually
7347 complete this type now because the array size is dependent. */
7348 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7350 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7353 if (PACK_EXPANSION_P (value
))
7359 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7361 /* We can create the array before the element type is complete, which
7362 means that we didn't have these two bits set in the original type
7363 either. In completing the type, we are expected to propagate these
7364 bits. See also complete_type which does the same thing for arrays
7367 if (TYPE_DOMAIN (type
))
7369 elt_type
= TREE_TYPE (type
);
7370 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7371 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7372 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7378 /* As above, but either give an error or reject zero-size arrays, depending
7382 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7383 bool do_default
, tsubst_flags_t complain
)
7386 bool sfinae
= !(complain
& tf_error
);
7387 /* In SFINAE context we can't be lenient about zero-size arrays. */
7390 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7396 /* Not an error. */;
7397 else if (failure
== 1)
7398 error ("initializer fails to determine size of %qT", *ptype
);
7399 else if (failure
== 2)
7402 error ("array size missing in %qT", *ptype
);
7404 else if (failure
== 3)
7405 error ("zero-size array %qT", *ptype
);
7406 *ptype
= error_mark_node
;
7411 /* Return zero if something is declared to be a member of type
7412 CTYPE when in the context of CUR_TYPE. STRING is the error
7413 message to print in that case. Otherwise, quietly return 1. */
7416 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7418 if (ctype
&& ctype
!= cur_type
)
7420 if (flags
== DTOR_FLAG
)
7421 error ("destructor for alien class %qT cannot be a member", ctype
);
7423 error ("constructor for alien class %qT cannot be a member", ctype
);
7429 /* Subroutine of `grokdeclarator'. */
7431 /* Generate errors possibly applicable for a given set of specifiers.
7432 This is for ARM $7.1.2. */
7435 bad_specifiers (tree object
,
7436 enum bad_spec_place type
,
7447 error ("%qD declared as a %<virtual%> variable", object
);
7449 error ("%qD declared as an %<inline%> variable", object
);
7451 error ("%<const%> and %<volatile%> function specifiers on "
7452 "%qD invalid in variable declaration", object
);
7456 error ("%qD declared as a %<virtual%> parameter", object
);
7458 error ("%qD declared as an %<inline%> parameter", object
);
7460 error ("%<const%> and %<volatile%> function specifiers on "
7461 "%qD invalid in parameter declaration", object
);
7465 error ("%qD declared as a %<virtual%> type", object
);
7467 error ("%qD declared as an %<inline%> type", object
);
7469 error ("%<const%> and %<volatile%> function specifiers on "
7470 "%qD invalid in type declaration", object
);
7474 error ("%qD declared as a %<virtual%> field", object
);
7476 error ("%qD declared as an %<inline%> field", object
);
7478 error ("%<const%> and %<volatile%> function specifiers on "
7479 "%qD invalid in field declaration", object
);
7485 error ("%q+D declared as a friend", object
);
7487 && (TREE_CODE (object
) == TYPE_DECL
7488 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7489 && !TYPE_REFFN_P (TREE_TYPE (object
))
7490 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7491 error ("%q+D declared with an exception specification", object
);
7494 /* DECL is a member function or static data member and is presently
7495 being defined. Check that the definition is taking place in a
7499 check_class_member_definition_namespace (tree decl
)
7501 /* These checks only apply to member functions and static data
7503 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7504 /* We check for problems with specializations in pt.c in
7505 check_specialization_namespace, where we can issue better
7507 if (processing_specialization
)
7509 /* There are no restrictions on the placement of
7510 explicit instantiations. */
7511 if (processing_explicit_instantiation
)
7515 A member function definition that appears outside of the
7516 class definition shall appear in a namespace scope enclosing
7517 the class definition.
7521 The definition for a static data member shall appear in a
7522 namespace scope enclosing the member's class definition. */
7523 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7524 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7525 decl
, DECL_CONTEXT (decl
));
7528 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7529 METHOD_TYPE for a non-static member function; QUALS are the
7530 cv-qualifiers that apply to the function. */
7533 build_this_parm (tree type
, cp_cv_quals quals
)
7538 cp_cv_quals this_quals
;
7540 if (CLASS_TYPE_P (type
))
7543 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7544 this_type
= build_pointer_type (this_type
);
7547 this_type
= type_of_this_parm (type
);
7548 /* The `this' parameter is implicitly `const'; it cannot be
7550 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7551 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7552 parm
= build_artificial_parm (this_identifier
, qual_type
);
7553 cp_apply_type_quals_to_decl (this_quals
, parm
);
7557 /* DECL is a static member function. Complain if it was declared
7558 with function-cv-quals. */
7561 check_static_quals (tree decl
, cp_cv_quals quals
)
7563 if (quals
!= TYPE_UNQUALIFIED
)
7564 error ("static member function %q#D declared with type qualifiers",
7568 /* Helper function. Replace the temporary this parameter injected
7569 during cp_finish_omp_declare_simd with the real this parameter. */
7572 declare_simd_adjust_this (tree
*tp
, int *walk_subtrees
, void *data
)
7574 tree this_parm
= (tree
) data
;
7575 if (TREE_CODE (*tp
) == PARM_DECL
7576 && DECL_NAME (*tp
) == this_identifier
7577 && *tp
!= this_parm
)
7579 else if (TYPE_P (*tp
))
7584 /* CTYPE is class type, or null if non-class.
7585 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7587 DECLARATOR is the function's name.
7588 PARMS is a chain of PARM_DECLs for the function.
7589 VIRTUALP is truthvalue of whether the function is virtual or not.
7590 FLAGS are to be passed through to `grokclassfn'.
7591 QUALS are qualifiers indicating whether the function is `const'
7593 RAISES is a list of exceptions that this function can raise.
7594 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7595 not look, and -1 if we should not call `grokclassfn' at all.
7597 SFK is the kind of special function (if any) for the new function.
7599 Returns `NULL_TREE' if something goes wrong, after issuing
7600 applicable error messages. */
7603 grokfndecl (tree ctype
,
7607 tree orig_declarator
,
7609 enum overload_flags flags
,
7611 cp_ref_qualifier rqual
,
7617 special_function_kind sfk
,
7622 location_t location
)
7625 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7629 type
= build_ref_qualified_type (type
, rqual
);
7631 type
= build_exception_variant (type
, raises
);
7633 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7635 /* If we have an explicit location, use it, otherwise use whatever
7636 build_lang_decl used (probably input_location). */
7637 if (location
!= UNKNOWN_LOCATION
)
7638 DECL_SOURCE_LOCATION (decl
) = location
;
7640 if (TREE_CODE (type
) == METHOD_TYPE
)
7643 parm
= build_this_parm (type
, quals
);
7644 DECL_CHAIN (parm
) = parms
;
7647 DECL_ARGUMENTS (decl
) = parms
;
7648 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7649 DECL_CONTEXT (t
) = decl
;
7650 /* Propagate volatile out from type to decl. */
7651 if (TYPE_VOLATILE (type
))
7652 TREE_THIS_VOLATILE (decl
) = 1;
7654 /* Setup decl according to sfk. */
7657 case sfk_constructor
:
7658 case sfk_copy_constructor
:
7659 case sfk_move_constructor
:
7660 DECL_CONSTRUCTOR_P (decl
) = 1;
7662 case sfk_destructor
:
7663 DECL_DESTRUCTOR_P (decl
) = 1;
7669 /* If pointers to member functions use the least significant bit to
7670 indicate whether a function is virtual, ensure a pointer
7671 to this function will have that bit clear. */
7672 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7673 && TREE_CODE (type
) == METHOD_TYPE
7674 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7675 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7678 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7682 ("defining explicit specialization %qD in friend declaration",
7686 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7687 tree args
= TREE_OPERAND (orig_declarator
, 1);
7689 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7691 /* Something like `template <class T> friend void f<T>()'. */
7692 error ("invalid use of template-id %qD in declaration "
7693 "of primary template",
7699 /* A friend declaration of the form friend void f<>(). Record
7700 the information in the TEMPLATE_ID_EXPR. */
7701 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7703 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7704 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7706 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7707 if (TREE_PURPOSE (t
)
7708 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7710 error ("default arguments are not allowed in declaration "
7711 "of friend template specialization %qD",
7717 error ("%<inline%> is not allowed in declaration of friend "
7718 "template specialization %qD",
7721 error ("%<constexpr%> is not allowed in declaration of friend "
7722 "template specialization %qD",
7729 /* If this decl has namespace scope, set that up. */
7731 set_decl_namespace (decl
, in_namespace
, friendp
);
7733 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7735 /* `main' and builtins have implicit 'C' linkage. */
7736 if ((MAIN_NAME_P (declarator
)
7737 || (IDENTIFIER_LENGTH (declarator
) > 10
7738 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7739 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7740 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0)
7741 || (targetcm
.cxx_implicit_extern_c
7742 && targetcm
.cxx_implicit_extern_c(IDENTIFIER_POINTER (declarator
))))
7743 && current_lang_name
== lang_name_cplusplus
7744 && ctype
== NULL_TREE
7745 && DECL_FILE_SCOPE_P (decl
))
7746 SET_DECL_LANGUAGE (decl
, lang_c
);
7748 /* Should probably propagate const out from type to decl I bet (mrs). */
7751 DECL_STATIC_FUNCTION_P (decl
) = 1;
7752 DECL_CONTEXT (decl
) = ctype
;
7757 DECL_CONTEXT (decl
) = ctype
;
7759 check_class_member_definition_namespace (decl
);
7762 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7764 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7765 error ("cannot declare %<::main%> to be a template");
7767 error ("cannot declare %<::main%> to be inline");
7769 error ("cannot declare %<::main%> to be constexpr");
7771 error ("cannot declare %<::main%> to be static");
7776 /* Members of anonymous types and local classes have no linkage; make
7777 them internal. If a typedef is made later, this will be changed. */
7778 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
7779 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7782 if (publicp
&& cxx_dialect
== cxx98
)
7784 /* [basic.link]: A name with no linkage (notably, the name of a class
7785 or enumeration declared in a local scope) shall not be used to
7786 declare an entity with linkage.
7788 DR 757 relaxes this restriction for C++0x. */
7789 no_linkage_error (decl
);
7792 TREE_PUBLIC (decl
) = publicp
;
7795 DECL_INTERFACE_KNOWN (decl
) = 1;
7796 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7799 /* If the declaration was declared inline, mark it as such. */
7802 DECL_DECLARED_INLINE_P (decl
) = 1;
7804 DECL_COMDAT (decl
) = 1;
7807 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7809 DECL_EXTERNAL (decl
) = 1;
7810 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7815 ? G_("static member function %qD cannot have cv-qualifier")
7816 : G_("non-member function %qD cannot have cv-qualifier"),
7818 quals
= TYPE_UNQUALIFIED
;
7824 ? G_("static member function %qD cannot have ref-qualifier")
7825 : G_("non-member function %qD cannot have ref-qualifier"),
7827 rqual
= REF_QUAL_NONE
;
7831 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7832 && !grok_op_properties (decl
, /*complain=*/true))
7834 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7836 bool long_long_unsigned_p
;
7838 const char *suffix
= NULL
;
7839 /* [over.literal]/6: Literal operators shall not have C linkage. */
7840 if (DECL_LANGUAGE (decl
) == lang_c
)
7842 error ("literal operator with C linkage");
7846 if (DECL_NAMESPACE_SCOPE_P (decl
))
7848 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7851 error ("%qD has invalid argument list", decl
);
7855 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7856 if (long_long_unsigned_p
)
7858 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7859 warning (0, "integer suffix %<%s%>"
7860 " shadowed by implementation", suffix
);
7862 else if (long_double_p
)
7864 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7865 warning (0, "floating point suffix %<%s%>"
7866 " shadowed by implementation", suffix
);
7871 error ("%qD must be a non-member function", decl
);
7877 /* Make the init_value nonzero so pushdecl knows this is not
7878 tentative. error_mark_node is replaced later with the BLOCK. */
7879 DECL_INITIAL (decl
) = error_mark_node
;
7881 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7882 TREE_NOTHROW (decl
) = 1;
7884 if (flag_openmp
|| flag_cilkplus
)
7886 /* Adjust "omp declare simd" attributes. */
7887 tree ods
= lookup_attribute ("omp declare simd", *attrlist
);
7891 for (attr
= ods
; attr
;
7892 attr
= lookup_attribute ("omp declare simd", TREE_CHAIN (attr
)))
7894 if (TREE_CODE (type
) == METHOD_TYPE
)
7895 walk_tree (&TREE_VALUE (attr
), declare_simd_adjust_this
,
7896 DECL_ARGUMENTS (decl
), NULL
);
7897 if (TREE_VALUE (attr
) != NULL_TREE
)
7899 tree cl
= TREE_VALUE (TREE_VALUE (attr
));
7900 cl
= c_omp_declare_simd_clauses_to_numbers
7901 (DECL_ARGUMENTS (decl
), cl
);
7903 TREE_VALUE (TREE_VALUE (attr
)) = cl
;
7905 TREE_VALUE (attr
) = NULL_TREE
;
7911 /* Caller will do the rest of this. */
7915 if (ctype
!= NULL_TREE
)
7916 grokclassfn (ctype
, decl
, flags
);
7919 if (cxx_dialect
>= cxx11
7920 && DECL_DESTRUCTOR_P (decl
)
7921 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7922 && !processing_template_decl
)
7923 deduce_noexcept_on_destructor (decl
);
7925 decl
= check_explicit_specialization (orig_declarator
, decl
,
7928 4 * (friendp
!= 0));
7929 if (decl
== error_mark_node
)
7932 if (DECL_STATIC_FUNCTION_P (decl
))
7933 check_static_quals (decl
, quals
);
7937 cplus_decl_attributes (&decl
, *attrlist
, 0);
7938 *attrlist
= NULL_TREE
;
7941 /* Check main's type after attributes have been applied. */
7942 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7944 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7947 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7949 error ("%<::main%> must return %<int%>");
7950 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7951 TREE_TYPE (decl
) = newtype
;
7954 check_main_parameter_types (decl
);
7957 if (ctype
!= NULL_TREE
7958 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
7961 tree old_decl
= check_classfn (ctype
, decl
,
7962 (processing_template_decl
7963 > template_class_depth (ctype
))
7964 ? current_template_parms
7967 if (old_decl
== error_mark_node
)
7975 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
7976 /* Because grokfndecl is always supposed to return a
7977 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7978 here. We depend on our callers to figure out that its
7979 really a template that's being returned. */
7980 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
7982 if (DECL_STATIC_FUNCTION_P (old_decl
)
7983 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7985 /* Remove the `this' parm added by grokclassfn. */
7986 revert_static_member_fn (decl
);
7987 check_static_quals (decl
, quals
);
7989 if (DECL_ARTIFICIAL (old_decl
))
7991 error ("definition of implicitly-declared %qD", old_decl
);
7994 else if (DECL_DEFAULTED_FN (old_decl
))
7996 error ("definition of explicitly-defaulted %q+D", decl
);
7997 error ("%q+#D explicitly defaulted here", old_decl
);
8001 /* Since we've smashed OLD_DECL to its
8002 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
8003 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
8004 decl
= DECL_TEMPLATE_RESULT (decl
);
8006 /* Attempt to merge the declarations. This can fail, in
8007 the case of some invalid specialization declarations. */
8008 pushed_scope
= push_scope (ctype
);
8009 ok
= duplicate_decls (decl
, old_decl
, friendp
);
8011 pop_scope (pushed_scope
);
8014 error ("no %q#D member function declared in class %qT",
8018 if (ok
== error_mark_node
)
8024 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
8027 if (ctype
== NULL_TREE
|| check
)
8031 DECL_VIRTUAL_P (decl
) = 1;
8036 /* decl is a FUNCTION_DECL.
8037 specifiers are the parsed virt-specifiers.
8039 Set flags to reflect the virt-specifiers.
8044 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
8046 if (decl
== NULL_TREE
)
8048 if (specifiers
& VIRT_SPEC_OVERRIDE
)
8049 DECL_OVERRIDE_P (decl
) = 1;
8050 if (specifiers
& VIRT_SPEC_FINAL
)
8051 DECL_FINAL_P (decl
) = 1;
8055 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
8056 the linkage that DECL will receive in the object file. */
8059 set_linkage_for_static_data_member (tree decl
)
8061 /* A static data member always has static storage duration and
8062 external linkage. Note that static data members are forbidden in
8063 local classes -- the only situation in which a class has
8064 non-external linkage. */
8065 TREE_PUBLIC (decl
) = 1;
8066 TREE_STATIC (decl
) = 1;
8067 /* For non-template classes, static data members are always put
8068 out in exactly those files where they are defined, just as
8069 with ordinary namespace-scope variables. */
8070 if (!processing_template_decl
)
8071 DECL_INTERFACE_KNOWN (decl
) = 1;
8074 /* Create a VAR_DECL named NAME with the indicated TYPE.
8076 If SCOPE is non-NULL, it is the class type or namespace containing
8077 the variable. If SCOPE is NULL, the variable should is created in
8078 the innermost enclosing scope. */
8081 grokvardecl (tree type
,
8083 tree orig_declarator
,
8084 const cp_decl_specifier_seq
*declspecs
,
8091 tree explicit_scope
;
8093 gcc_assert (!name
|| identifier_p (name
));
8095 /* Compute the scope in which to place the variable, but remember
8096 whether or not that scope was explicitly specified by the user. */
8097 explicit_scope
= scope
;
8100 /* An explicit "extern" specifier indicates a namespace-scope
8102 if (declspecs
->storage_class
== sc_extern
)
8103 scope
= current_decl_namespace ();
8104 else if (!at_function_scope_p ())
8105 scope
= current_scope ();
8109 && (/* If the variable is a namespace-scope variable declared in a
8110 template, we need DECL_LANG_SPECIFIC. */
8111 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
8112 /* Similarly for namespace-scope variables with language linkage
8114 || (TREE_CODE (scope
) == NAMESPACE_DECL
8115 && current_lang_name
!= lang_name_cplusplus
)
8116 /* Similarly for static data members. */
8118 /* Similarly for explicit specializations. */
8120 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)))
8121 decl
= build_lang_decl (VAR_DECL
, name
, type
);
8123 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
8125 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
8126 set_decl_namespace (decl
, explicit_scope
, 0);
8128 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
8130 if (declspecs
->storage_class
== sc_extern
)
8132 DECL_THIS_EXTERN (decl
) = 1;
8133 DECL_EXTERNAL (decl
) = !initialized
;
8136 if (DECL_CLASS_SCOPE_P (decl
))
8138 set_linkage_for_static_data_member (decl
);
8139 /* This function is only called with out-of-class definitions. */
8140 DECL_EXTERNAL (decl
) = 0;
8141 check_class_member_definition_namespace (decl
);
8143 /* At top level, either `static' or no s.c. makes a definition
8144 (perhaps tentative), and absence of `static' makes it public. */
8145 else if (toplevel_bindings_p ())
8147 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
8148 && (DECL_THIS_EXTERN (decl
) || ! constp
));
8149 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
8151 /* Not at top level, only `static' makes a static definition. */
8154 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
8155 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
8158 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
8160 if (DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
8161 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
8162 if (declspecs
->gnu_thread_keyword_p
)
8163 DECL_GNU_TLS_P (decl
) = true;
8166 /* If the type of the decl has no linkage, make sure that we'll
8167 notice that in mark_used. */
8168 if (cxx_dialect
> cxx98
8169 && decl_linkage (decl
) != lk_none
8170 && DECL_LANG_SPECIFIC (decl
) == NULL
8171 && !DECL_EXTERN_C_P (decl
)
8172 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
8173 retrofit_lang_decl (decl
);
8175 if (TREE_PUBLIC (decl
))
8177 /* [basic.link]: A name with no linkage (notably, the name of a class
8178 or enumeration declared in a local scope) shall not be used to
8179 declare an entity with linkage.
8181 DR 757 relaxes this restriction for C++0x. */
8182 if (cxx_dialect
< cxx11
)
8183 no_linkage_error (decl
);
8186 DECL_INTERFACE_KNOWN (decl
) = 1;
8188 // Handle explicit specializations and instantiations of variable templates.
8189 if (orig_declarator
)
8190 decl
= check_explicit_specialization (orig_declarator
, decl
,
8193 return decl
!= error_mark_node
? decl
: NULL_TREE
;
8196 /* Create and return a canonical pointer to member function type, for
8197 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8200 build_ptrmemfunc_type (tree type
)
8205 if (type
== error_mark_node
)
8208 /* If a canonical type already exists for this type, use it. We use
8209 this method instead of type_hash_canon, because it only does a
8210 simple equality check on the list of field members. */
8212 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
8215 /* Make sure that we always have the unqualified pointer-to-member
8217 if (cp_cv_quals quals
= cp_type_quals (type
))
8219 tree unqual
= build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
8220 return cp_build_qualified_type (unqual
, quals
);
8223 t
= make_node (RECORD_TYPE
);
8225 /* Let the front end know this is a pointer to member function. */
8226 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
8228 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
8231 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
8233 DECL_CHAIN (field
) = fields
;
8236 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
8238 /* Zap out the name so that the back end will give us the debugging
8239 information for this anonymous RECORD_TYPE. */
8240 TYPE_NAME (t
) = NULL_TREE
;
8242 /* Cache this pointer-to-member type so that we can find it again
8244 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
8246 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
8247 SET_TYPE_STRUCTURAL_EQUALITY (t
);
8248 else if (TYPE_CANONICAL (type
) != type
)
8249 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
8254 /* Create and return a pointer to data member type. */
8257 build_ptrmem_type (tree class_type
, tree member_type
)
8259 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8261 cp_cv_quals quals
= type_memfn_quals (member_type
);
8262 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8263 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8264 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8268 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8269 return build_offset_type (class_type
, member_type
);
8273 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8274 Check to see that the definition is valid. Issue appropriate error
8275 messages. Return 1 if the definition is particularly bad, or 0
8279 check_static_variable_definition (tree decl
, tree type
)
8281 /* Can't check yet if we don't know the type. */
8282 if (dependent_type_p (type
))
8284 /* If DECL is declared constexpr, we'll do the appropriate checks
8285 in check_initializer. */
8286 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8288 else if (cxx_dialect
>= cxx11
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8290 if (!COMPLETE_TYPE_P (type
))
8291 error ("in-class initialization of static data member %q#D of "
8292 "incomplete type", decl
);
8293 else if (literal_type_p (type
))
8294 permerror (input_location
,
8295 "%<constexpr%> needed for in-class initialization of "
8296 "static data member %q#D of non-integral type", decl
);
8298 error ("in-class initialization of static data member %q#D of "
8299 "non-literal type", decl
);
8303 /* Motion 10 at San Diego: If a static const integral data member is
8304 initialized with an integral constant expression, the initializer
8305 may appear either in the declaration (within the class), or in
8306 the definition, but not both. If it appears in the class, the
8307 member is a member constant. The file-scope definition is always
8309 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8311 error ("invalid in-class initialization of static data member "
8312 "of non-integral type %qT",
8316 else if (!CP_TYPE_CONST_P (type
))
8317 error ("ISO C++ forbids in-class initialization of non-const "
8318 "static member %qD",
8320 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8321 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8322 "%qD of non-integral type %qT", decl
, type
);
8327 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8328 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8329 expressions out into temporary variables so that walk_tree doesn't
8330 step into them (c++/15764). */
8333 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8335 hash_set
<tree
> *pset
= (hash_set
<tree
> *)data
;
8336 tree expr
= *expr_p
;
8337 if (TREE_CODE (expr
) == SAVE_EXPR
)
8339 tree op
= TREE_OPERAND (expr
, 0);
8340 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8341 if (TREE_SIDE_EFFECTS (op
))
8342 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8345 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8350 /* Entry point for the above. */
8353 stabilize_vla_size (tree size
)
8355 hash_set
<tree
> pset
;
8356 /* Break out any function calls into temporary variables. */
8357 cp_walk_tree (&size
, stabilize_save_expr_r
, &pset
, &pset
);
8360 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8361 not inside of SAVE_EXPR and fold them. */
8364 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8366 tree expr
= *expr_p
;
8367 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8369 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8371 *(bool *)data
= true;
8372 if (SIZEOF_EXPR_TYPE_P (expr
))
8373 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8374 SIZEOF_EXPR
, false);
8375 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8376 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8379 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8381 if (expr
== error_mark_node
)
8382 expr
= size_one_node
;
8389 /* Given the SIZE (i.e., number of elements) in an array, compute an
8390 appropriate index type for the array. If non-NULL, NAME is the
8391 name of the thing being declared. */
8394 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8399 if (error_operand_p (size
))
8400 return error_mark_node
;
8402 if (!type_dependent_expression_p (size
))
8404 tree type
= TREE_TYPE (size
);
8406 mark_rvalue_use (size
);
8408 if (cxx_dialect
< cxx11
&& TREE_CODE (size
) == NOP_EXPR
8409 && TREE_SIDE_EFFECTS (size
))
8410 /* In C++98, we mark a non-constant array bound with a magic
8411 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8414 size
= instantiate_non_dependent_expr_sfinae (size
, complain
);
8416 if (CLASS_TYPE_P (type
)
8417 && CLASSTYPE_LITERAL_P (type
))
8419 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8422 if (!(complain
& tf_error
))
8423 return error_mark_node
;
8425 error ("size of array %qD has non-integral type %qT",
8428 error ("size of array has non-integral type %qT", type
);
8429 size
= integer_one_node
;
8431 if (size
== error_mark_node
)
8432 return error_mark_node
;
8433 type
= TREE_TYPE (size
);
8436 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8437 size
= maybe_constant_value (size
);
8439 if (!TREE_CONSTANT (size
))
8443 if (error_operand_p (size
))
8444 return error_mark_node
;
8446 /* The array bound must be an integer type. */
8447 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8449 if (!(complain
& tf_error
))
8450 return error_mark_node
;
8452 error ("size of array %qD has non-integral type %qT", name
, type
);
8454 error ("size of array has non-integral type %qT", type
);
8455 size
= integer_one_node
;
8456 type
= TREE_TYPE (size
);
8460 /* A type is dependent if it is...an array type constructed from any
8461 dependent type or whose size is specified by a constant expression
8462 that is value-dependent. */
8463 /* We can only call value_dependent_expression_p on integral constant
8464 expressions; treat non-constant expressions as dependent, too. */
8465 if (processing_template_decl
8466 && (type_dependent_expression_p (size
)
8467 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8469 /* We cannot do any checking for a SIZE that isn't known to be
8470 constant. Just build the index type and mark that it requires
8471 structural equality checks. */
8472 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8473 size
, size_one_node
));
8474 TYPE_DEPENDENT_P (itype
) = 1;
8475 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8476 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8480 /* Normally, the array-bound will be a constant. */
8481 if (TREE_CODE (size
) == INTEGER_CST
)
8483 /* Check to see if the array bound overflowed. Make that an
8484 error, no matter how generous we're being. */
8485 constant_expression_error (size
);
8487 /* An array must have a positive number of elements. */
8488 if (tree_int_cst_lt (size
, integer_zero_node
))
8490 if (!(complain
& tf_error
))
8491 return error_mark_node
;
8493 error ("size of array %qD is negative", name
);
8495 error ("size of array is negative");
8496 size
= integer_one_node
;
8498 /* As an extension we allow zero-sized arrays. */
8499 else if (integer_zerop (size
))
8501 if (!(complain
& tf_error
))
8502 /* We must fail if performing argument deduction (as
8503 indicated by the state of complain), so that
8504 another substitution can be found. */
8505 return error_mark_node
;
8506 else if (in_system_header_at (input_location
))
8507 /* Allow them in system headers because glibc uses them. */;
8509 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8511 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8514 else if (TREE_CONSTANT (size
)
8515 /* We don't allow VLAs at non-function scopes, or during
8516 tentative template substitution. */
8517 || !at_function_scope_p ()
8518 || (cxx_dialect
< cxx14
&& !(complain
& tf_error
)))
8520 if (!(complain
& tf_error
))
8521 return error_mark_node
;
8522 /* `(int) &fn' is not a valid array bound. */
8524 error ("size of array %qD is not an integral constant-expression",
8527 error ("size of array is not an integral constant-expression");
8528 size
= integer_one_node
;
8530 else if (cxx_dialect
< cxx14
&& pedantic
&& warn_vla
!= 0)
8533 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8535 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8537 else if (warn_vla
> 0)
8541 "variable length array %qD is used", name
);
8544 "variable length array is used");
8547 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8548 /* A variable sized array. */
8549 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8552 HOST_WIDE_INT saved_processing_template_decl
;
8554 /* Compute the index of the largest element in the array. It is
8555 one less than the number of elements in the array. We save
8556 and restore PROCESSING_TEMPLATE_DECL so that computations in
8557 cp_build_binary_op will be appropriately folded. */
8558 saved_processing_template_decl
= processing_template_decl
;
8559 processing_template_decl
= 0;
8560 itype
= cp_build_binary_op (input_location
,
8562 cp_convert (ssizetype
, size
, complain
),
8563 cp_convert (ssizetype
, integer_one_node
,
8566 itype
= fold (itype
);
8567 processing_template_decl
= saved_processing_template_decl
;
8569 if (!TREE_CONSTANT (itype
))
8571 /* A variable sized array. */
8572 itype
= variable_size (itype
);
8574 if (TREE_CODE (itype
) != SAVE_EXPR
)
8576 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8577 they might survive till gimplification. */
8578 tree newitype
= itype
;
8580 cp_walk_tree_without_duplicates (&newitype
,
8581 fold_sizeof_expr_r
, &found
);
8583 itype
= variable_size (fold (newitype
));
8586 stabilize_vla_size (itype
);
8588 if (cxx_dialect
>= cxx14
&& flag_exceptions
)
8590 /* If the VLA bound is larger than half the address space,
8591 or less than zero, throw std::bad_array_length. */
8592 tree comp
= build2 (LT_EXPR
, boolean_type_node
, itype
,
8594 comp
= build3 (COND_EXPR
, void_type_node
, comp
,
8595 throw_bad_array_length (), void_node
);
8596 finish_expr_stmt (comp
);
8598 else if (flag_sanitize
& SANITIZE_VLA
8599 && current_function_decl
!= NULL_TREE
8600 && !lookup_attribute ("no_sanitize_undefined",
8602 (current_function_decl
)))
8604 /* From C++14 onwards, we throw an exception on a negative
8605 length size of an array; see above. */
8607 /* We have to add 1 -- in the ubsan routine we generate
8608 LE_EXPR rather than LT_EXPR. */
8609 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8610 build_one_cst (TREE_TYPE (itype
)));
8611 t
= ubsan_instrument_vla (input_location
, t
);
8612 finish_expr_stmt (t
);
8615 /* Make sure that there was no overflow when creating to a signed
8616 index type. (For example, on a 32-bit machine, an array with
8617 size 2^32 - 1 is too big.) */
8618 else if (TREE_CODE (itype
) == INTEGER_CST
8619 && TREE_OVERFLOW (itype
))
8621 if (!(complain
& tf_error
))
8622 return error_mark_node
;
8623 error ("overflow in array dimension");
8624 TREE_OVERFLOW (itype
) = 0;
8628 /* Create and return the appropriate index type. */
8629 itype
= build_index_type (itype
);
8631 /* If the index type were dependent, we would have returned early, so
8632 remember that it isn't. */
8633 TYPE_DEPENDENT_P (itype
) = 0;
8634 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8638 /* Returns the scope (if any) in which the entity declared by
8639 DECLARATOR will be located. If the entity was declared with an
8640 unqualified name, NULL_TREE is returned. */
8643 get_scope_of_declarator (const cp_declarator
*declarator
)
8645 while (declarator
&& declarator
->kind
!= cdk_id
)
8646 declarator
= declarator
->declarator
;
8648 /* If the declarator-id is a SCOPE_REF, the scope in which the
8649 declaration occurs is the first operand. */
8651 && declarator
->u
.id
.qualifying_scope
)
8652 return declarator
->u
.id
.qualifying_scope
;
8654 /* Otherwise, the declarator is not a qualified name; the entity will
8655 be declared in the current scope. */
8659 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8660 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8664 create_array_type_for_decl (tree name
, tree type
, tree size
)
8666 tree itype
= NULL_TREE
;
8668 /* If things have already gone awry, bail now. */
8669 if (type
== error_mark_node
|| size
== error_mark_node
)
8670 return error_mark_node
;
8672 /* 8.3.4/1: If the type of the identifier of D contains the auto
8673 type-specifier, the program is ill-formed. */
8674 if (type_uses_auto (type
))
8676 error ("%qD declared as array of %qT", name
, type
);
8677 return error_mark_node
;
8680 /* If there are some types which cannot be array elements,
8681 issue an error-message and return. */
8682 switch (TREE_CODE (type
))
8686 error ("declaration of %qD as array of void", name
);
8688 error ("creating array of void");
8689 return error_mark_node
;
8693 error ("declaration of %qD as array of functions", name
);
8695 error ("creating array of functions");
8696 return error_mark_node
;
8698 case REFERENCE_TYPE
:
8700 error ("declaration of %qD as array of references", name
);
8702 error ("creating array of references");
8703 return error_mark_node
;
8707 error ("declaration of %qD as array of function members", name
);
8709 error ("creating array of function members");
8710 return error_mark_node
;
8718 The constant expressions that specify the bounds of the arrays
8719 can be omitted only for the first member of the sequence. */
8720 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8723 error ("declaration of %qD as multidimensional array must "
8724 "have bounds for all dimensions except the first",
8727 error ("multidimensional array must have bounds for all "
8728 "dimensions except the first");
8730 return error_mark_node
;
8733 if (cxx_dialect
>= cxx14
&& array_of_runtime_bound_p (type
)
8734 && (flag_iso
|| warn_vla
> 0))
8735 pedwarn (input_location
, OPT_Wvla
, "array of array of runtime bound");
8737 /* Figure out the index type for the array. */
8739 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8742 T is called the array element type; this type shall not be [...] an
8743 abstract class type. */
8744 abstract_virtuals_error (name
, type
);
8746 return build_cplus_array_type (type
, itype
);
8749 /* Check that it's OK to declare a function with the indicated TYPE.
8750 SFK indicates the kind of special function (if any) that this
8751 function is. OPTYPE is the type given in a conversion operator
8752 declaration, or the class type for a constructor/destructor.
8753 Returns the actual return type of the function; that
8754 may be different than TYPE if an error occurs, or for certain
8755 special functions. */
8758 check_special_function_return_type (special_function_kind sfk
,
8764 case sfk_constructor
:
8766 error ("return type specification for constructor invalid");
8768 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8769 type
= build_pointer_type (optype
);
8771 type
= void_type_node
;
8774 case sfk_destructor
:
8776 error ("return type specification for destructor invalid");
8777 /* We can't use the proper return type here because we run into
8778 problems with ambiguous bases and covariant returns.
8779 Java classes are left unchanged because (void *) isn't a valid
8780 Java type, and we don't want to change the Java ABI. */
8781 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8782 type
= build_pointer_type (void_type_node
);
8784 type
= void_type_node
;
8787 case sfk_conversion
:
8789 error ("return type specified for %<operator %T%>", optype
);
8800 /* A variable or data member (whose unqualified name is IDENTIFIER)
8801 has been declared with the indicated TYPE. If the TYPE is not
8802 acceptable, issue an error message and return a type to use for
8803 error-recovery purposes. */
8806 check_var_type (tree identifier
, tree type
)
8808 if (VOID_TYPE_P (type
))
8811 error ("unnamed variable or field declared void");
8812 else if (identifier_p (identifier
))
8814 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8815 error ("variable or field %qE declared void", identifier
);
8818 error ("variable or field declared void");
8819 type
= error_mark_node
;
8825 /* Given declspecs and a declarator (abstract or otherwise), determine
8826 the name and type of the object declared and construct a DECL node
8829 DECLSPECS points to the representation of declaration-specifier
8830 sequence that precedes declarator.
8832 DECL_CONTEXT says which syntactic context this declaration is in:
8833 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8834 FUNCDEF for a function definition. Like NORMAL but a few different
8835 error messages in each case. Return value may be zero meaning
8836 this definition is too screwy to try to parse.
8837 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8838 handle member functions (which have FIELD context).
8839 Return value may be zero meaning this definition is too screwy to
8841 PARM for a parameter declaration (either within a function prototype
8842 or before a function body). Make a PARM_DECL, or return void_type_node.
8843 TPARM for a template parameter declaration.
8844 CATCHPARM for a parameter declaration before a catch clause.
8845 TYPENAME if for a typename (in a cast or sizeof).
8846 Don't make a DECL node; just return the ..._TYPE node.
8847 FIELD for a struct or union field; make a FIELD_DECL.
8848 BITFIELD for a field with specified width.
8850 INITIALIZED is as for start_decl.
8852 ATTRLIST is a pointer to the list of attributes, which may be NULL
8853 if there are none; *ATTRLIST may be modified if attributes from inside
8854 the declarator should be applied to the declaration.
8856 When this function is called, scoping variables (such as
8857 CURRENT_CLASS_TYPE) should reflect the scope in which the
8858 declaration occurs, not the scope in which the new declaration will
8859 be placed. For example, on:
8863 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8866 Returns a DECL (if a declarator is present), a TYPE (if there is no
8867 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8871 grokdeclarator (const cp_declarator
*declarator
,
8872 cp_decl_specifier_seq
*declspecs
,
8873 enum decl_context decl_context
,
8877 tree type
= NULL_TREE
;
8879 int explicit_intN
= 0;
8880 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8881 int explicit_int
= 0;
8882 int explicit_char
= 0;
8883 int defaulted_int
= 0;
8885 tree typedef_decl
= NULL_TREE
;
8886 const char *name
= NULL
;
8887 tree typedef_type
= NULL_TREE
;
8888 /* True if this declarator is a function definition. */
8889 bool funcdef_flag
= false;
8890 cp_declarator_kind innermost_code
= cdk_error
;
8893 /* See the code below that used this. */
8894 tree decl_attr
= NULL_TREE
;
8897 /* Keep track of what sort of function is being processed
8898 so that we can warn about default return values, or explicit
8899 return values which do not match prescribed defaults. */
8900 special_function_kind sfk
= sfk_none
;
8902 tree dname
= NULL_TREE
;
8903 tree ctor_return_type
= NULL_TREE
;
8904 enum overload_flags flags
= NO_SPECIAL
;
8905 /* cv-qualifiers that apply to the declarator, for a declaration of
8906 a member function. */
8907 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8908 /* virt-specifiers that apply to the declarator, for a declaration of
8909 a member function. */
8910 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8911 /* ref-qualifier that applies to the declarator, for a declaration of
8912 a member function. */
8913 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
8914 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8916 tree raises
= NULL_TREE
;
8917 int template_count
= 0;
8918 tree returned_attrs
= NULL_TREE
;
8919 tree parms
= NULL_TREE
;
8920 const cp_declarator
*id_declarator
;
8921 /* The unqualified name of the declarator; either an
8922 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8923 tree unqualified_id
;
8924 /* The class type, if any, in which this entity is located,
8925 or NULL_TREE if none. Note that this value may be different from
8926 the current class type; for example if an attempt is made to declare
8927 "A::f" inside "B", this value will be "A". */
8928 tree ctype
= current_class_type
;
8929 /* The NAMESPACE_DECL for the namespace in which this entity is
8930 located. If an unqualified name is used to declare the entity,
8931 this value will be NULL_TREE, even if the entity is located at
8933 tree in_namespace
= NULL_TREE
;
8934 cp_storage_class storage_class
;
8935 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8936 bool type_was_error_mark_node
= false;
8937 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8938 bool template_type_arg
= false;
8939 bool template_parm_flag
= false;
8940 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
8941 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8942 bool late_return_type_p
= false;
8943 bool array_parameter_p
= false;
8944 source_location saved_loc
= input_location
;
8947 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8948 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8949 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8950 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8951 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8952 explicit_intN
= declspecs
->explicit_intN_p
;
8953 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8955 if (decl_context
== FUNCDEF
)
8956 funcdef_flag
= true, decl_context
= NORMAL
;
8957 else if (decl_context
== MEMFUNCDEF
)
8958 funcdef_flag
= true, decl_context
= FIELD
;
8959 else if (decl_context
== BITFIELD
)
8960 bitfield
= 1, decl_context
= FIELD
;
8961 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8962 template_type_arg
= true, decl_context
= TYPENAME
;
8963 else if (decl_context
== TPARM
)
8964 template_parm_flag
= true, decl_context
= PARM
;
8966 if (initialized
> 1)
8967 funcdef_flag
= true;
8969 /* Look inside a declarator for the name being declared
8970 and get it as a string, for an error message. */
8971 for (id_declarator
= declarator
;
8973 id_declarator
= id_declarator
->declarator
)
8975 if (id_declarator
->kind
!= cdk_id
)
8976 innermost_code
= id_declarator
->kind
;
8978 switch (id_declarator
->kind
)
8981 if (id_declarator
->declarator
8982 && id_declarator
->declarator
->kind
== cdk_id
)
8984 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8985 if (sfk
== sfk_destructor
)
8992 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8993 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8996 if (qualifying_scope
)
8998 if (at_function_scope_p ())
9002 A declarator-id shall not be qualified except
9005 None of the cases are permitted in block
9007 if (qualifying_scope
== global_namespace
)
9008 error ("invalid use of qualified-name %<::%D%>",
9010 else if (TYPE_P (qualifying_scope
))
9011 error ("invalid use of qualified-name %<%T::%D%>",
9012 qualifying_scope
, decl
);
9014 error ("invalid use of qualified-name %<%D::%D%>",
9015 qualifying_scope
, decl
);
9016 return error_mark_node
;
9018 else if (TYPE_P (qualifying_scope
))
9020 ctype
= qualifying_scope
;
9021 if (!MAYBE_CLASS_TYPE_P (ctype
))
9023 error ("%q#T is not a class or a namespace", ctype
);
9026 else if (innermost_code
!= cdk_function
9027 && current_class_type
9028 && !uniquely_derived_from_p (ctype
,
9029 current_class_type
))
9031 error ("invalid use of qualified-name %<%T::%D%>",
9032 qualifying_scope
, decl
);
9033 return error_mark_node
;
9036 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
9037 in_namespace
= qualifying_scope
;
9039 switch (TREE_CODE (decl
))
9045 if (innermost_code
!= cdk_function
)
9047 error ("declaration of %qD as non-function", decl
);
9048 return error_mark_node
;
9050 else if (!qualifying_scope
9051 && !(current_class_type
&& at_class_scope_p ()))
9053 error ("declaration of %qD as non-member", decl
);
9054 return error_mark_node
;
9057 type
= TREE_OPERAND (decl
, 0);
9059 type
= constructor_name (type
);
9060 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
9065 case TEMPLATE_ID_EXPR
:
9067 tree fns
= TREE_OPERAND (decl
, 0);
9070 if (!identifier_p (dname
))
9072 if (variable_template_p (dname
))
9073 dname
= DECL_NAME (dname
);
9076 gcc_assert (is_overloaded_fn (dname
));
9077 dname
= DECL_NAME (get_first_fn (dname
));
9083 case IDENTIFIER_NODE
:
9084 if (identifier_p (decl
))
9087 if (C_IS_RESERVED_WORD (dname
))
9089 error ("declarator-id missing; using reserved word %qD",
9091 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9093 else if (!IDENTIFIER_TYPENAME_P (dname
))
9094 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9097 gcc_assert (flags
== NO_SPECIAL
);
9098 flags
= TYPENAME_FLAG
;
9099 ctor_return_type
= TREE_TYPE (dname
);
9100 sfk
= sfk_conversion
;
9101 if (is_typename_at_global_scope (dname
))
9102 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9104 name
= "<invalid operator>";
9121 return error_mark_node
;
9126 if (id_declarator
->kind
== cdk_id
)
9132 The declarator in a function-definition shall have the form
9133 D1 ( parameter-declaration-clause) ... */
9134 if (funcdef_flag
&& innermost_code
!= cdk_function
)
9136 error ("function definition does not declare parameters");
9137 return error_mark_node
;
9140 if (flags
== TYPENAME_FLAG
9141 && innermost_code
!= cdk_function
9142 && ! (ctype
&& !declspecs
->any_specifiers_p
))
9144 error ("declaration of %qD as non-function", dname
);
9145 return error_mark_node
;
9149 && identifier_p (dname
)
9150 && UDLIT_OPER_P (dname
)
9151 && innermost_code
!= cdk_function
)
9153 error ("declaration of %qD as non-function", dname
);
9154 return error_mark_node
;
9157 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9161 error ("declaration of %qD as %<typedef%>", dname
);
9162 return error_mark_node
;
9164 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9166 error ("declaration of %qD as parameter", dname
);
9167 return error_mark_node
;
9171 /* Anything declared one level down from the top level
9172 must be one of the parameters of a function
9173 (because the body is at least two levels down). */
9175 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9176 by not allowing C++ class definitions to specify their parameters
9177 with xdecls (must be spec.d in the parmlist).
9179 Since we now wait to push a class scope until we are sure that
9180 we are in a legitimate method context, we must set oldcname
9181 explicitly (since current_class_name is not yet alive).
9183 We also want to avoid calling this a PARM if it is in a namespace. */
9185 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9187 cp_binding_level
*b
= current_binding_level
;
9188 current_binding_level
= b
->level_chain
;
9189 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9190 decl_context
= PARM
;
9191 current_binding_level
= b
;
9195 name
= decl_context
== PARM
? "parameter" : "type name";
9197 if (constexpr_p
&& typedef_p
)
9199 error ("%<constexpr%> cannot appear in a typedef declaration");
9200 return error_mark_node
;
9203 /* If there were multiple types specified in the decl-specifier-seq,
9204 issue an error message. */
9205 if (declspecs
->multiple_types_p
)
9207 error ("two or more data types in declaration of %qs", name
);
9208 return error_mark_node
;
9211 if (declspecs
->conflicting_specifiers_p
)
9213 error ("conflicting specifiers in declaration of %qs", name
);
9214 return error_mark_node
;
9217 /* Extract the basic type from the decl-specifier-seq. */
9218 type
= declspecs
->type
;
9219 if (type
== error_mark_node
)
9222 type_was_error_mark_node
= true;
9224 /* If the entire declaration is itself tagged as deprecated then
9225 suppress reports of deprecated items. */
9226 if (type
&& TREE_DEPRECATED (type
)
9227 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9228 warn_deprecated_use (type
, NULL_TREE
);
9229 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9231 typedef_decl
= type
;
9232 type
= TREE_TYPE (typedef_decl
);
9233 if (TREE_DEPRECATED (type
)
9234 && DECL_ARTIFICIAL (typedef_decl
)
9235 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9236 warn_deprecated_use (type
, NULL_TREE
);
9238 /* No type at all: default to `int', and set DEFAULTED_INT
9239 because it was not a user-defined typedef. */
9240 if (type
== NULL_TREE
)
9242 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
9244 /* These imply 'int'. */
9245 type
= integer_type_node
;
9248 /* If we just have "complex", it is equivalent to "complex double". */
9249 else if (!longlong
&& !explicit_intN
9250 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9252 type
= double_type_node
;
9253 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
9254 "ISO C++ does not support plain %<complex%> meaning "
9255 "%<double complex%>");
9259 explicit_int
= declspecs
->explicit_int_p
;
9260 explicit_char
= declspecs
->explicit_char_p
;
9263 /* See the code below that used this. */
9265 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9267 typedef_type
= type
;
9270 if (sfk
!= sfk_conversion
)
9271 ctor_return_type
= ctype
;
9273 if (sfk
!= sfk_none
)
9274 type
= check_special_function_return_type (sfk
, type
,
9276 else if (type
== NULL_TREE
)
9282 /* We handle `main' specially here, because 'main () { }' is so
9283 common. With no options, it is allowed. With -Wreturn-type,
9284 it is a warning. It is only an error with -pedantic-errors. */
9285 is_main
= (funcdef_flag
9286 && dname
&& identifier_p (dname
)
9287 && MAIN_NAME_P (dname
)
9288 && ctype
== NULL_TREE
9289 && in_namespace
== NULL_TREE
9290 && current_namespace
== global_namespace
);
9292 if (type_was_error_mark_node
)
9293 /* We've already issued an error, don't complain more. */;
9294 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9295 /* Allow it, sigh. */;
9297 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9299 pedwarn (input_location
, OPT_Wpedantic
,
9300 "ISO C++ forbids declaration of %qs with no type", name
);
9302 warning (OPT_Wreturn_type
,
9303 "ISO C++ forbids declaration of %qs with no type", name
);
9305 type
= integer_type_node
;
9312 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
9314 error ("%<__int%d%> is not supported by this target",
9315 int_n_data
[declspecs
->int_n_idx
].bitsize
);
9316 explicit_intN
= false;
9318 else if (pedantic
&& ! in_system_header_at (input_location
))
9319 pedwarn (input_location
, OPT_Wpedantic
,
9320 "ISO C++ does not support %<__int%d%> for %qs",
9321 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
9324 /* Now process the modifiers that were specified
9325 and check for invalid combinations. */
9327 /* Long double is a special combination. */
9328 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9331 type
= cp_build_qualified_type (long_double_type_node
,
9332 cp_type_quals (type
));
9335 /* Check all other uses of type modifiers. */
9337 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9341 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9342 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9343 else if (signed_p
&& unsigned_p
)
9344 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9345 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9346 error ("%<long long%> invalid for %qs", name
);
9347 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9348 error ("%<long%> invalid for %qs", name
);
9349 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9350 error ("%<short%> invalid for %qs", name
);
9351 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9352 error ("%<long%> or %<short%> invalid for %qs", name
);
9353 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
9354 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9355 else if ((long_p
|| short_p
) && explicit_char
)
9356 error ("%<long%> or %<short%> specified with char for %qs", name
);
9357 else if (long_p
&& short_p
)
9358 error ("%<long%> and %<short%> specified together for %qs", name
);
9359 else if (type
== char16_type_node
|| type
== char32_type_node
)
9361 if (signed_p
|| unsigned_p
)
9362 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9363 else if (short_p
|| long_p
)
9364 error ("%<short%> or %<long%> invalid for %qs", name
);
9369 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
9371 pedwarn (input_location
, OPT_Wpedantic
,
9372 "long, short, signed or unsigned used invalidly for %qs",
9374 if (flag_pedantic_errors
)
9379 /* Discard the type modifiers if they are invalid. */
9390 /* Decide whether an integer type is signed or not.
9391 Optionally treat bitfields as signed by default. */
9395 It is implementation-defined whether a plain (neither
9396 explicitly signed or unsigned) char, short, int, or long
9397 bit-field is signed or unsigned.
9399 Naturally, we extend this to long long as well. Note that
9400 this does not include wchar_t. */
9401 || (bitfield
&& !flag_signed_bitfields
9403 /* A typedef for plain `int' without `signed' can be
9404 controlled just like plain `int', but a typedef for
9405 `signed int' cannot be so controlled. */
9407 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9408 && TREE_CODE (type
) == INTEGER_TYPE
9409 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9412 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
9414 type
= long_long_unsigned_type_node
;
9416 type
= long_unsigned_type_node
;
9418 type
= short_unsigned_type_node
;
9419 else if (type
== char_type_node
)
9420 type
= unsigned_char_type_node
;
9421 else if (typedef_decl
)
9422 type
= unsigned_type_for (type
);
9424 type
= unsigned_type_node
;
9426 else if (signed_p
&& type
== char_type_node
)
9427 type
= signed_char_type_node
;
9428 else if (explicit_intN
)
9429 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
9431 type
= long_long_integer_type_node
;
9433 type
= long_integer_type_node
;
9435 type
= short_integer_type_node
;
9437 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9439 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9440 error ("complex invalid for %qs", name
);
9441 /* If a modifier is specified, the resulting complex is the complex
9442 form of TYPE. E.g, "complex short" is "complex short int". */
9443 else if (type
== integer_type_node
)
9444 type
= complex_integer_type_node
;
9445 else if (type
== float_type_node
)
9446 type
= complex_float_type_node
;
9447 else if (type
== double_type_node
)
9448 type
= complex_double_type_node
;
9449 else if (type
== long_double_type_node
)
9450 type
= complex_long_double_type_node
;
9452 type
= build_complex_type (type
);
9455 type_quals
= TYPE_UNQUALIFIED
;
9456 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9457 type_quals
|= TYPE_QUAL_CONST
;
9458 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9459 type_quals
|= TYPE_QUAL_VOLATILE
;
9460 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9461 type_quals
|= TYPE_QUAL_RESTRICT
;
9462 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9463 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9466 /* If we're using the injected-class-name to form a compound type or a
9467 declaration, replace it with the underlying class so we don't get
9468 redundant typedefs in the debug output. But if we are returning the
9469 type unchanged, leave it alone so that it's available to
9470 maybe_get_template_decl_from_type_decl. */
9471 if (CLASS_TYPE_P (type
)
9472 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9473 && type
== TREE_TYPE (TYPE_NAME (type
))
9474 && (declarator
|| type_quals
))
9475 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9477 type_quals
|= cp_type_quals (type
);
9478 type
= cp_build_qualified_type_real
9479 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
9480 || declspecs
->decltype_p
)
9481 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9482 /* We might have ignored or rejected some of the qualifiers. */
9483 type_quals
= cp_type_quals (type
);
9486 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9487 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9488 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9490 storage_class
= declspecs
->storage_class
;
9491 if (storage_class
== sc_static
)
9492 staticp
= 1 + (decl_context
== FIELD
);
9494 if (virtualp
&& staticp
== 2)
9496 error ("member %qD cannot be declared both virtual and static", dname
);
9497 storage_class
= sc_none
;
9500 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9502 /* Issue errors about use of storage classes for parameters. */
9503 if (decl_context
== PARM
)
9507 error ("typedef declaration invalid in parameter declaration");
9508 return error_mark_node
;
9510 else if (template_parm_flag
&& storage_class
!= sc_none
)
9512 error ("storage class specified for template parameter %qs", name
);
9513 return error_mark_node
;
9515 else if (storage_class
== sc_static
9516 || storage_class
== sc_extern
9518 error ("storage class specifiers invalid in parameter declarations");
9520 /* Function parameters cannot be constexpr. If we saw one, moan
9521 and pretend it wasn't there. */
9524 error ("a parameter cannot be declared %<constexpr%>");
9529 /* Give error if `virtual' is used outside of class declaration. */
9531 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9533 error ("%<virtual%> outside class declaration");
9537 /* Static anonymous unions are dealt with here. */
9538 if (staticp
&& decl_context
== TYPENAME
9540 && ANON_AGGR_TYPE_P (declspecs
->type
))
9541 decl_context
= FIELD
;
9543 /* Warn about storage classes that are invalid for certain
9544 kinds of declarations (parameters, typenames, etc.). */
9547 && storage_class
!= sc_extern
9548 && storage_class
!= sc_static
)
9551 error ("multiple storage classes in declaration of %qs", name
);
9554 if (decl_context
!= NORMAL
9555 && ((storage_class
!= sc_none
9556 && storage_class
!= sc_mutable
)
9559 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9560 && (storage_class
== sc_register
9561 || storage_class
== sc_auto
))
9565 else if (decl_context
== FIELD
9566 /* C++ allows static class elements. */
9567 && storage_class
== sc_static
)
9568 /* C++ also allows inlines and signed and unsigned elements,
9569 but in those cases we don't come in here. */
9573 if (decl_context
== FIELD
)
9574 error ("storage class specified for %qs", name
);
9577 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9578 error ("storage class specified for parameter %qs", name
);
9580 error ("storage class specified for typename");
9582 if (storage_class
== sc_register
9583 || storage_class
== sc_auto
9584 || storage_class
== sc_extern
9586 storage_class
= sc_none
;
9589 else if (storage_class
== sc_extern
&& funcdef_flag
9590 && ! toplevel_bindings_p ())
9591 error ("nested function %qs declared %<extern%>", name
);
9592 else if (toplevel_bindings_p ())
9594 if (storage_class
== sc_auto
)
9595 error ("top-level declaration of %qs specifies %<auto%>", name
);
9598 && storage_class
!= sc_extern
9599 && storage_class
!= sc_static
)
9601 if (declspecs
->gnu_thread_keyword_p
)
9602 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9603 "declared %<__thread%>", name
);
9605 /* When thread_local is applied to a variable of block scope the
9606 storage-class-specifier static is implied if it does not appear
9608 storage_class
= declspecs
->storage_class
= sc_static
;
9612 if (storage_class
&& friendp
)
9614 error ("storage class specifiers invalid in friend function declarations");
9615 storage_class
= sc_none
;
9620 unqualified_id
= NULL_TREE
;
9623 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9624 switch (TREE_CODE (unqualified_id
))
9627 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9628 if (TYPE_P (unqualified_id
))
9629 unqualified_id
= constructor_name (unqualified_id
);
9632 case IDENTIFIER_NODE
:
9633 case TEMPLATE_ID_EXPR
:
9641 if (declspecs
->std_attributes
)
9643 /* Apply the c++11 attributes to the type preceding them. */
9644 input_location
= declspecs
->locations
[ds_std_attribute
];
9645 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9646 input_location
= saved_loc
;
9649 /* Determine the type of the entity declared by recurring on the
9651 for (; declarator
; declarator
= declarator
->declarator
)
9653 const cp_declarator
*inner_declarator
;
9656 if (type
== error_mark_node
)
9657 return error_mark_node
;
9659 attrs
= declarator
->attributes
;
9665 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9666 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9667 if (declarator
->kind
== cdk_function
)
9668 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9669 if (declarator
->kind
== cdk_array
)
9670 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9671 returned_attrs
= decl_attributes (&type
,
9672 chainon (returned_attrs
, attrs
),
9676 if (declarator
->kind
== cdk_id
)
9679 inner_declarator
= declarator
->declarator
;
9681 switch (declarator
->kind
)
9684 type
= create_array_type_for_decl (dname
, type
,
9685 declarator
->u
.array
.bounds
);
9686 if (declarator
->std_attributes
)
9689 The optional attribute-specifier-seq appertains to the
9691 returned_attrs
= chainon (returned_attrs
,
9692 declarator
->std_attributes
);
9700 /* Declaring a function type.
9701 Make sure we have a valid type for the function to return. */
9703 if (type_quals
!= TYPE_UNQUALIFIED
)
9705 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9706 warning (OPT_Wignored_qualifiers
,
9707 "type qualifiers ignored on function return type");
9708 /* We now know that the TYPE_QUALS don't apply to the
9709 decl, but to its return type. */
9710 type_quals
= TYPE_UNQUALIFIED
;
9712 errmsg
= targetm
.invalid_return_type (type
);
9716 type
= integer_type_node
;
9719 /* Error about some types functions can't return. */
9721 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9723 error ("%qs declared as function returning a function", name
);
9724 return error_mark_node
;
9726 if (TREE_CODE (type
) == ARRAY_TYPE
)
9728 error ("%qs declared as function returning an array", name
);
9729 return error_mark_node
;
9732 input_location
= declspecs
->locations
[ds_type_spec
];
9733 abstract_virtuals_error (ACU_RETURN
, type
);
9734 input_location
= saved_loc
;
9736 /* Pick up type qualifiers which should be applied to `this'. */
9737 memfn_quals
= declarator
->u
.function
.qualifiers
;
9738 /* Pick up virt-specifiers. */
9739 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9740 /* And ref-qualifier, too */
9741 rqual
= declarator
->u
.function
.ref_qualifier
;
9742 /* Pick up the exception specifications. */
9743 raises
= declarator
->u
.function
.exception_specification
;
9744 /* If the exception-specification is ill-formed, let's pretend
9745 there wasn't one. */
9746 if (raises
== error_mark_node
)
9749 /* Say it's a definition only for the CALL_EXPR
9750 closest to the identifier. */
9751 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9753 /* Handle a late-specified return type. */
9756 if (type_uses_auto (type
))
9758 if (!declarator
->u
.function
.late_return_type
)
9760 if (current_class_type
9761 && LAMBDA_TYPE_P (current_class_type
))
9762 /* OK for C++11 lambdas. */;
9763 else if (cxx_dialect
< cxx14
)
9765 error ("%qs function uses "
9766 "%<auto%> type specifier without trailing "
9767 "return type", name
);
9768 inform (input_location
, "deduced return type "
9769 "only available with -std=c++14 or "
9774 error ("virtual function cannot "
9775 "have deduced return type");
9779 else if (!is_auto (type
))
9781 error ("%qs function with trailing return type has"
9782 " %qT as its type rather than plain %<auto%>",
9784 return error_mark_node
;
9787 else if (declarator
->u
.function
.late_return_type
)
9789 if (cxx_dialect
< cxx11
)
9790 /* Not using maybe_warn_cpp0x because this should
9791 always be an error. */
9792 error ("trailing return type only available with "
9793 "-std=c++11 or -std=gnu++11");
9795 error ("%qs function with trailing return type not "
9796 "declared with %<auto%> type specifier", name
);
9797 return error_mark_node
;
9800 type
= splice_late_return_type
9801 (type
, declarator
->u
.function
.late_return_type
);
9802 if (type
== error_mark_node
)
9803 return error_mark_node
;
9805 if (declarator
->u
.function
.late_return_type
)
9806 late_return_type_p
= true;
9808 if (ctype
== NULL_TREE
9809 && decl_context
== FIELD
9812 ctype
= current_class_type
;
9814 if (ctype
&& (sfk
== sfk_constructor
9815 || sfk
== sfk_destructor
))
9817 /* We are within a class's scope. If our declarator name
9818 is the same as the class name, and we are defining
9819 a function, then it is a constructor/destructor, and
9820 therefore returns a void type. */
9822 /* ISO C++ 12.4/2. A destructor may not be declared
9823 const or volatile. A destructor may not be static.
9824 A destructor may not be declared with ref-qualifier.
9826 ISO C++ 12.1. A constructor may not be declared
9827 const or volatile. A constructor may not be
9828 virtual. A constructor may not be static.
9829 A constructor may not be declared with ref-qualifier. */
9831 error ((flags
== DTOR_FLAG
)
9832 ? G_("destructor cannot be static member function")
9833 : G_("constructor cannot be static member function"));
9836 error ((flags
== DTOR_FLAG
)
9837 ? G_("destructors may not be cv-qualified")
9838 : G_("constructors may not be cv-qualified"));
9839 memfn_quals
= TYPE_UNQUALIFIED
;
9844 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
9845 error ((flags
== DTOR_FLAG
)
9846 ? "destructors may not be ref-qualified"
9847 : "constructors may not be ref-qualified");
9848 rqual
= REF_QUAL_NONE
;
9851 if (decl_context
== FIELD
9852 && !member_function_or_else (ctype
,
9855 return error_mark_node
;
9857 if (flags
!= DTOR_FLAG
)
9859 /* It's a constructor. */
9864 permerror (input_location
, "constructors cannot be declared virtual");
9867 if (decl_context
== FIELD
9868 && sfk
!= sfk_constructor
)
9869 return error_mark_node
;
9871 if (decl_context
== FIELD
)
9878 /* Cannot be both friend and virtual. */
9879 error ("virtual functions cannot be friends");
9882 if (decl_context
== NORMAL
)
9883 error ("friend declaration not in class definition");
9884 if (current_function_decl
&& funcdef_flag
)
9885 error ("can%'t define friend function %qs in a local "
9889 else if (ctype
&& sfk
== sfk_conversion
)
9893 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9898 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9901 if (inner_declarator
9902 && inner_declarator
->kind
== cdk_id
9903 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9904 && arg_types
!= void_list_node
)
9906 error ("destructors may not have parameters");
9907 arg_types
= void_list_node
;
9911 type
= build_function_type (type
, arg_types
);
9912 if (declarator
->std_attributes
)
9915 The optional attribute-specifier-seq appertains to
9916 the function type. */
9917 decl_attributes (&type
, declarator
->std_attributes
,
9925 /* Filter out pointers-to-references and references-to-references.
9926 We can get these if a TYPE_DECL is used. */
9928 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9930 if (declarator
->kind
!= cdk_reference
)
9932 error ("cannot declare pointer to %q#T", type
);
9933 type
= TREE_TYPE (type
);
9936 /* In C++0x, we allow reference to reference declarations
9937 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9938 and template type arguments [14.3.1/4 temp.arg.type]. The
9939 check for direct reference to reference declarations, which
9940 are still forbidden, occurs below. Reasoning behind the change
9941 can be found in DR106, DR540, and the rvalue reference
9943 else if (cxx_dialect
== cxx98
)
9945 error ("cannot declare reference to %q#T", type
);
9946 type
= TREE_TYPE (type
);
9949 else if (VOID_TYPE_P (type
))
9951 if (declarator
->kind
== cdk_reference
)
9952 error ("cannot declare reference to %q#T", type
);
9953 else if (declarator
->kind
== cdk_ptrmem
)
9954 error ("cannot declare pointer to %q#T member", type
);
9957 /* We now know that the TYPE_QUALS don't apply to the decl,
9958 but to the target of the pointer. */
9959 type_quals
= TYPE_UNQUALIFIED
;
9961 /* This code used to handle METHOD_TYPE, but I don't think it's
9962 possible to get it here anymore. */
9963 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9964 if (declarator
->kind
== cdk_ptrmem
9965 && TREE_CODE (type
) == FUNCTION_TYPE
)
9967 memfn_quals
|= type_memfn_quals (type
);
9968 type
= build_memfn_type (type
,
9969 declarator
->u
.pointer
.class_type
,
9972 if (type
== error_mark_node
)
9973 return error_mark_node
;
9975 rqual
= REF_QUAL_NONE
;
9976 memfn_quals
= TYPE_UNQUALIFIED
;
9979 if (TREE_CODE (type
) == FUNCTION_TYPE
9980 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
9981 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
9982 error (declarator
->kind
== cdk_reference
9983 ? G_("cannot declare reference to qualified function type %qT")
9984 : G_("cannot declare pointer to qualified function type %qT"),
9987 if (cxx_dialect
>= cxx14
&& array_of_runtime_bound_p (type
)
9988 && (flag_iso
|| warn_vla
> 0))
9989 pedwarn (input_location
, OPT_Wvla
,
9990 declarator
->kind
== cdk_reference
9991 ? G_("reference to array of runtime bound")
9992 : G_("pointer to array of runtime bound"));
9994 /* When the pointed-to type involves components of variable size,
9995 care must be taken to ensure that the size evaluation code is
9996 emitted early enough to dominate all the possible later uses
9997 and late enough for the variables on which it depends to have
10000 This is expected to happen automatically when the pointed-to
10001 type has a name/declaration of it's own, but special attention
10002 is required if the type is anonymous.
10004 We handle the NORMAL and FIELD contexts here by inserting a
10005 dummy statement that just evaluates the size at a safe point
10006 and ensures it is not deferred until e.g. within a deeper
10007 conditional context (c++/43555).
10009 We expect nothing to be needed here for PARM or TYPENAME.
10010 Evaluating the size at this point for TYPENAME would
10011 actually be incorrect, as we might be in the middle of an
10012 expression with side effects on the pointed-to type size
10013 "arguments" prior to the pointer declaration point and the
10014 size evaluation could end up prior to the side effects. */
10016 if (!TYPE_NAME (type
)
10017 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
10018 && at_function_scope_p ()
10019 && variably_modified_type_p (type
, NULL_TREE
))
10020 /* Force evaluation of the SAVE_EXPR. */
10021 finish_expr_stmt (TYPE_SIZE (type
));
10023 if (declarator
->kind
== cdk_reference
)
10025 /* In C++0x, the type we are creating a reference to might be
10026 a typedef which is itself a reference type. In that case,
10027 we follow the reference collapsing rules in
10028 [7.1.3/8 dcl.typedef] to create the final reference type:
10030 "If a typedef TD names a type that is a reference to a type
10031 T, an attempt to create the type 'lvalue reference to cv TD'
10032 creates the type 'lvalue reference to T,' while an attempt
10033 to create the type "rvalue reference to cv TD' creates the
10036 if (VOID_TYPE_P (type
))
10037 /* We already gave an error. */;
10038 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10040 if (declarator
->u
.reference
.rvalue_ref
)
10041 /* Leave type alone. */;
10043 type
= cp_build_reference_type (TREE_TYPE (type
), false);
10046 type
= cp_build_reference_type
10047 (type
, declarator
->u
.reference
.rvalue_ref
);
10049 /* In C++0x, we need this check for direct reference to
10050 reference declarations, which are forbidden by
10051 [8.3.2/5 dcl.ref]. Reference to reference declarations
10052 are only allowed indirectly through typedefs and template
10053 type arguments. Example:
10055 void foo(int & &); // invalid ref-to-ref decl
10057 typedef int & int_ref;
10058 void foo(int_ref &); // valid ref-to-ref decl
10060 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
10061 error ("cannot declare reference to %q#T, which is not "
10062 "a typedef or a template type argument", type
);
10064 else if (TREE_CODE (type
) == METHOD_TYPE
)
10065 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10066 else if (declarator
->kind
== cdk_ptrmem
)
10068 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
10069 != NAMESPACE_DECL
);
10070 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
10071 /* We will already have complained. */
10072 type
= error_mark_node
;
10074 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
10078 type
= build_pointer_type (type
);
10080 /* Process a list of type modifier keywords (such as
10081 const or volatile) that were given inside the `*' or `&'. */
10083 if (declarator
->u
.pointer
.qualifiers
)
10086 = cp_build_qualified_type (type
,
10087 declarator
->u
.pointer
.qualifiers
);
10088 type_quals
= cp_type_quals (type
);
10091 /* Apply C++11 attributes to the pointer, and not to the
10092 type pointed to. This is unlike what is done for GNU
10093 attributes above. It is to comply with [dcl.ptr]/1:
10095 [the optional attribute-specifier-seq (7.6.1) appertains
10096 to the pointer and not to the object pointed to]. */
10097 if (declarator
->std_attributes
)
10098 decl_attributes (&type
, declarator
->std_attributes
,
10108 gcc_unreachable ();
10112 /* A `constexpr' specifier used in an object declaration declares
10113 the object as `const'. */
10114 if (constexpr_p
&& innermost_code
!= cdk_function
)
10116 if (type_quals
& TYPE_QUAL_VOLATILE
)
10117 error ("both %<volatile%> and %<constexpr%> cannot be used here");
10118 if (TREE_CODE (type
) != REFERENCE_TYPE
)
10120 type_quals
|= TYPE_QUAL_CONST
;
10121 type
= cp_build_qualified_type (type
, type_quals
);
10125 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
10126 && TREE_CODE (type
) != FUNCTION_TYPE
10127 && TREE_CODE (type
) != METHOD_TYPE
10128 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
10130 error ("template-id %qD used as a declarator",
10132 unqualified_id
= dname
;
10135 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10136 qualified with a class-name, turn it into a METHOD_TYPE, unless
10137 we know that the function is static. We take advantage of this
10138 opportunity to do other processing that pertains to entities
10139 explicitly declared to be class members. Note that if DECLARATOR
10140 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10141 would not have exited the loop above. */
10143 && declarator
->u
.id
.qualifying_scope
10144 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
10146 ctype
= declarator
->u
.id
.qualifying_scope
;
10147 ctype
= TYPE_MAIN_VARIANT (ctype
);
10148 template_count
= num_template_headers_for_class (ctype
);
10150 if (ctype
== current_class_type
)
10154 permerror (input_location
, "member functions are implicitly friends of their class");
10158 permerror (declarator
->id_loc
,
10159 "extra qualification %<%T::%> on member %qs",
10162 else if (/* If the qualifying type is already complete, then we
10163 can skip the following checks. */
10164 !COMPLETE_TYPE_P (ctype
)
10165 && (/* If the function is being defined, then
10166 qualifying type must certainly be complete. */
10168 /* A friend declaration of "T::f" is OK, even if
10169 "T" is a template parameter. But, if this
10170 function is not a friend, the qualifying type
10171 must be a class. */
10172 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10173 /* For a declaration, the type need not be
10174 complete, if either it is dependent (since there
10175 is no meaningful definition of complete in that
10176 case) or the qualifying class is currently being
10178 || !(dependent_type_p (ctype
)
10179 || currently_open_class (ctype
)))
10180 /* Check that the qualifying type is complete. */
10181 && !complete_type_or_else (ctype
, NULL_TREE
))
10182 return error_mark_node
;
10183 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10185 if (current_class_type
10186 && (!friendp
|| funcdef_flag
))
10188 error (funcdef_flag
10189 ? G_("cannot define member function %<%T::%s%> "
10191 : G_("cannot declare member function %<%T::%s%> "
10193 ctype
, name
, current_class_type
);
10194 return error_mark_node
;
10197 else if (typedef_p
&& current_class_type
)
10199 error ("cannot declare member %<%T::%s%> within %qT",
10200 ctype
, name
, current_class_type
);
10201 return error_mark_node
;
10205 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10206 ctype
= current_class_type
;
10208 /* Now TYPE has the actual type. */
10210 if (returned_attrs
)
10213 *attrlist
= chainon (returned_attrs
, *attrlist
);
10215 attrlist
= &returned_attrs
;
10219 && declarator
->kind
== cdk_id
10220 && declarator
->std_attributes
)
10221 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10222 a declarator-id appertains to the entity that is declared. */
10223 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10225 /* Handle parameter packs. */
10226 if (parameter_pack_p
)
10228 if (decl_context
== PARM
)
10229 /* Turn the type into a pack expansion.*/
10230 type
= make_pack_expansion (type
);
10232 error ("non-parameter %qs cannot be a parameter pack", name
);
10235 /* Did array size calculations overflow or does the array cover more
10236 than half of the address-space? */
10237 if (TREE_CODE (type
) == ARRAY_TYPE
10238 && COMPLETE_TYPE_P (type
)
10239 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
10240 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
10242 error ("size of array %qs is too large", name
);
10243 /* If we proceed with the array type as it is, we'll eventually
10244 crash in tree_to_[su]hwi(). */
10245 type
= error_mark_node
;
10248 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10249 && !processing_template_decl
10250 && variably_modified_type_p (type
, NULL_TREE
))
10252 if (decl_context
== FIELD
)
10253 error ("data member may not have variably modified type %qT", type
);
10255 error ("parameter may not have variably modified type %qT", type
);
10256 type
= error_mark_node
;
10259 if (explicitp
== 1 || (explicitp
&& friendp
))
10261 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10262 in the declaration of a constructor or conversion function within
10263 a class definition. */
10264 if (!current_class_type
)
10265 error ("%<explicit%> outside class declaration");
10267 error ("%<explicit%> in friend declaration");
10269 error ("only declarations of constructors and conversion operators "
10270 "can be %<explicit%>");
10274 if (storage_class
== sc_mutable
)
10276 if (decl_context
!= FIELD
|| friendp
)
10278 error ("non-member %qs cannot be declared %<mutable%>", name
);
10279 storage_class
= sc_none
;
10281 else if (decl_context
== TYPENAME
|| typedef_p
)
10283 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10284 storage_class
= sc_none
;
10286 else if (TREE_CODE (type
) == FUNCTION_TYPE
10287 || TREE_CODE (type
) == METHOD_TYPE
)
10289 error ("function %qs cannot be declared %<mutable%>", name
);
10290 storage_class
= sc_none
;
10294 error ("static %qs cannot be declared %<mutable%>", name
);
10295 storage_class
= sc_none
;
10297 else if (type_quals
& TYPE_QUAL_CONST
)
10299 error ("const %qs cannot be declared %<mutable%>", name
);
10300 storage_class
= sc_none
;
10302 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10304 permerror (input_location
, "reference %qs cannot be declared "
10305 "%<mutable%>", name
);
10306 storage_class
= sc_none
;
10310 /* If this is declaring a typedef name, return a TYPE_DECL. */
10311 if (typedef_p
&& decl_context
!= TYPENAME
)
10315 /* Note that the grammar rejects storage classes
10316 in typenames, fields or parameters. */
10317 if (current_lang_name
== lang_name_java
)
10318 TYPE_FOR_JAVA (type
) = 1;
10320 /* This declaration:
10322 typedef void f(int) const;
10324 declares a function type which is not a member of any
10325 particular class, but which is cv-qualified; for
10326 example "f S::*" declares a pointer to a const-qualified
10327 member function of S. We record the cv-qualification in the
10329 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10331 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10333 /* We have now dealt with these qualifiers. */
10334 memfn_quals
= TYPE_UNQUALIFIED
;
10335 rqual
= REF_QUAL_NONE
;
10338 if (type_uses_auto (type
))
10340 error ("typedef declared %<auto%>");
10341 type
= error_mark_node
;
10344 if (cxx_dialect
>= cxx14
&& array_of_runtime_bound_p (type
)
10345 && (flag_iso
|| warn_vla
> 0))
10346 pedwarn (input_location
, OPT_Wvla
,
10347 "typedef naming array of runtime bound");
10349 if (decl_context
== FIELD
)
10350 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10352 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10353 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10354 error_at (DECL_SOURCE_LOCATION (decl
),
10355 "typedef name may not be a nested-name-specifier");
10356 TREE_TYPE (decl
) = error_mark_node
;
10359 if (decl_context
!= FIELD
)
10361 if (!current_function_decl
)
10362 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10363 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10364 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10365 (current_function_decl
)))
10366 /* The TYPE_DECL is "abstract" because there will be
10367 clones of this constructor/destructor, and there will
10368 be copies of this TYPE_DECL generated in those
10369 clones. The decloning optimization (for space) may
10370 revert this subsequently if it determines that
10371 the clones should share a common implementation. */
10372 DECL_ABSTRACT_P (decl
) = true;
10374 else if (current_class_type
10375 && constructor_name_p (unqualified_id
, current_class_type
))
10376 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10377 "as enclosing class",
10380 /* If the user declares "typedef struct {...} foo" then the
10381 struct will have an anonymous name. Fill that name in now.
10382 Nothing can refer to it, so nothing needs know about the name
10384 if (type
!= error_mark_node
10386 && TYPE_NAME (type
)
10387 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10388 && TYPE_ANONYMOUS_P (type
)
10389 && declspecs
->type_definition_p
10390 && attributes_naming_typedef_ok (*attrlist
)
10391 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10395 /* Replace the anonymous name with the real name everywhere. */
10396 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10398 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10399 /* We do not rename the debug info representing the
10400 anonymous tagged type because the standard says in
10401 [dcl.typedef] that the naming applies only for
10402 linkage purposes. */
10403 /*debug_hooks->set_name (t, decl);*/
10404 TYPE_NAME (t
) = decl
;
10407 if (TYPE_LANG_SPECIFIC (type
))
10408 TYPE_WAS_ANONYMOUS (type
) = 1;
10410 /* If this is a typedef within a template class, the nested
10411 type is a (non-primary) template. The name for the
10412 template needs updating as well. */
10413 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10414 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10415 = TYPE_IDENTIFIER (type
);
10417 /* Adjust linkage now that we aren't anonymous anymore. */
10418 reset_type_linkage (type
);
10420 /* FIXME remangle member functions; member functions of a
10421 type with external linkage have external linkage. */
10425 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10426 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10428 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10429 memfn_quals
!= TYPE_UNQUALIFIED
,
10430 inlinep
, friendp
, raises
!= NULL_TREE
);
10432 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10433 /* Acknowledge that this was written:
10434 `using analias = atype;'. */
10435 TYPE_DECL_ALIAS_P (decl
) = 1;
10440 /* Detect the case of an array type of unspecified size
10441 which came, as such, direct from a typedef name.
10442 We must copy the type, so that the array's domain can be
10443 individually set by the object's initializer. */
10445 if (type
&& typedef_type
10446 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10447 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10448 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10450 /* Detect where we're using a typedef of function type to declare a
10451 function. PARMS will not be set, so we must create it now. */
10453 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10455 tree decls
= NULL_TREE
;
10458 for (args
= TYPE_ARG_TYPES (type
);
10459 args
&& args
!= void_list_node
;
10460 args
= TREE_CHAIN (args
))
10462 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10464 DECL_CHAIN (decl
) = decls
;
10468 parms
= nreverse (decls
);
10470 if (decl_context
!= TYPENAME
)
10472 /* The qualifiers on the function type become the qualifiers on
10473 the non-static member function. */
10474 memfn_quals
|= type_memfn_quals (type
);
10475 rqual
= type_memfn_rqual (type
);
10476 type_quals
= TYPE_UNQUALIFIED
;
10480 /* If this is a type name (such as, in a cast or sizeof),
10481 compute the type and return it now. */
10483 if (decl_context
== TYPENAME
)
10485 /* Note that the grammar rejects storage classes
10486 in typenames, fields or parameters. */
10487 if (type_quals
!= TYPE_UNQUALIFIED
)
10488 type_quals
= TYPE_UNQUALIFIED
;
10490 /* Special case: "friend class foo" looks like a TYPENAME context. */
10493 if (type_quals
!= TYPE_UNQUALIFIED
)
10495 error ("type qualifiers specified for friend class declaration");
10496 type_quals
= TYPE_UNQUALIFIED
;
10500 error ("%<inline%> specified for friend class declaration");
10506 /* Don't allow friend declaration without a class-key. */
10507 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10508 permerror (input_location
, "template parameters cannot be friends");
10509 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10510 permerror (input_location
, "friend declaration requires class-key, "
10511 "i.e. %<friend class %T::%D%>",
10512 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10514 permerror (input_location
, "friend declaration requires class-key, "
10515 "i.e. %<friend %#T%>",
10519 /* Only try to do this stuff if we didn't already give up. */
10520 if (type
!= integer_type_node
)
10522 /* A friendly class? */
10523 if (current_class_type
)
10524 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10525 /*complain=*/true);
10527 error ("trying to make class %qT a friend of global scope",
10530 type
= void_type_node
;
10533 else if (memfn_quals
|| rqual
)
10535 if (ctype
== NULL_TREE
10536 && TREE_CODE (type
) == METHOD_TYPE
)
10537 ctype
= TYPE_METHOD_BASETYPE (type
);
10540 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10541 /* Core issue #547: need to allow this in template type args.
10542 Allow it in general in C++11 for alias-declarations. */
10543 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10544 && TREE_CODE (type
) == FUNCTION_TYPE
)
10545 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10547 error ("invalid qualifiers on non-member function type");
10552 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10553 && decl_context
!= CATCHPARM
10554 && TREE_CODE (type
) != UNION_TYPE
10557 error ("abstract declarator %qT used as declaration", type
);
10558 return error_mark_node
;
10561 /* Only functions may be declared using an operator-function-id. */
10563 && IDENTIFIER_OPNAME_P (unqualified_id
)
10564 && TREE_CODE (type
) != FUNCTION_TYPE
10565 && TREE_CODE (type
) != METHOD_TYPE
)
10567 error ("declaration of %qD as non-function", unqualified_id
);
10568 return error_mark_node
;
10571 /* We don't check parameter types here because we can emit a better
10572 error message later. */
10573 if (decl_context
!= PARM
)
10575 type
= check_var_type (unqualified_id
, type
);
10576 if (type
== error_mark_node
)
10577 return error_mark_node
;
10580 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10581 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10583 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10585 if (ctype
|| in_namespace
)
10586 error ("cannot use %<::%> in parameter declaration");
10588 if (type_uses_auto (type
))
10590 if (cxx_dialect
>= cxx14
)
10591 error ("%<auto%> parameter not permitted in this context");
10593 error ("parameter declared %<auto%>");
10594 type
= error_mark_node
;
10597 /* A parameter declared as an array of T is really a pointer to T.
10598 One declared as a function is really a pointer to a function.
10599 One declared as a member is really a pointer to member. */
10601 if (TREE_CODE (type
) == ARRAY_TYPE
)
10603 /* Transfer const-ness of array into that of type pointed to. */
10604 type
= build_pointer_type (TREE_TYPE (type
));
10605 type_quals
= TYPE_UNQUALIFIED
;
10606 array_parameter_p
= true;
10608 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10609 type
= build_pointer_type (type
);
10612 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10613 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10615 cp_cv_quals real_quals
= memfn_quals
;
10616 if (cxx_dialect
< cxx14
&& constexpr_p
10617 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10618 real_quals
|= TYPE_QUAL_CONST
;
10619 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10625 if (decl_context
== PARM
)
10627 decl
= cp_build_parm_decl (unqualified_id
, type
);
10628 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
10630 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10631 memfn_quals
!= TYPE_UNQUALIFIED
,
10632 inlinep
, friendp
, raises
!= NULL_TREE
);
10634 else if (decl_context
== FIELD
)
10636 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10637 && type_uses_auto (type
))
10639 error ("non-static data member declared %<auto%>");
10640 type
= error_mark_node
;
10643 /* The C99 flexible array extension. */
10644 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10645 && TYPE_DOMAIN (type
) == NULL_TREE
)
10647 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10648 tf_warning_or_error
);
10649 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10652 if (type
== error_mark_node
)
10654 /* Happens when declaring arrays of sizes which
10655 are error_mark_node, for example. */
10658 else if (in_namespace
&& !friendp
)
10660 /* Something like struct S { int N::j; }; */
10661 error ("invalid use of %<::%>");
10662 return error_mark_node
;
10664 else if (TREE_CODE (type
) == FUNCTION_TYPE
10665 || TREE_CODE (type
) == METHOD_TYPE
)
10668 tree function_context
;
10672 /* This should never happen in pure C++ (the check
10673 could be an assert). It could happen in
10674 Objective-C++ if someone writes invalid code that
10675 uses a function declaration for an instance
10676 variable or property (instance variables and
10677 properties are parsed as FIELD_DECLs, but they are
10678 part of an Objective-C class, not a C++ class).
10679 That code is invalid and is caught by this
10683 error ("declaration of function %qD in invalid context",
10685 return error_mark_node
;
10688 /* ``A union may [ ... ] not [ have ] virtual functions.''
10690 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10692 error ("function %qD declared virtual inside a union",
10694 return error_mark_node
;
10697 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10701 error ("%qD cannot be declared virtual, since it "
10702 "is always static",
10709 /* Check that the name used for a destructor makes sense. */
10710 if (sfk
== sfk_destructor
)
10712 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10716 gcc_assert (friendp
);
10717 error ("expected qualified name in friend declaration "
10718 "for destructor %qD", uqname
);
10719 return error_mark_node
;
10722 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10724 error ("declaration of %qD as member of %qT",
10726 return error_mark_node
;
10730 error ("a destructor cannot be %<constexpr%>");
10731 return error_mark_node
;
10734 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10736 error ("expected qualified name in friend declaration "
10737 "for constructor %qD",
10738 id_declarator
->u
.id
.unqualified_name
);
10739 return error_mark_node
;
10742 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10744 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
10745 if (variable_template_p (tmpl
))
10747 error ("specialization of variable template %qD "
10748 "declared as function", tmpl
);
10749 inform (DECL_SOURCE_LOCATION (tmpl
),
10750 "variable template declared here");
10751 return error_mark_node
;
10755 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10756 function_context
= (ctype
!= NULL_TREE
) ?
10757 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10758 publicp
= (! friendp
|| ! staticp
)
10759 && function_context
== NULL_TREE
;
10761 if (late_return_type_p
)
10762 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
10764 decl
= grokfndecl (ctype
, type
,
10765 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10766 ? unqualified_id
: dname
,
10769 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10770 friendp
? -1 : 0, friendp
, publicp
,
10771 inlinep
| (2 * constexpr_p
),
10773 funcdef_flag
, template_count
, in_namespace
,
10774 attrlist
, declarator
->id_loc
);
10775 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10776 if (decl
== NULL_TREE
)
10777 return error_mark_node
;
10779 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10780 /* The decl and setting of decl_attr is also turned off. */
10781 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10784 /* [class.conv.ctor]
10786 A constructor declared without the function-specifier
10787 explicit that can be called with a single parameter
10788 specifies a conversion from the type of its first
10789 parameter to the type of its class. Such a constructor
10790 is called a converting constructor. */
10791 if (explicitp
== 2)
10792 DECL_NONCONVERTING_P (decl
) = 1;
10794 else if (!staticp
&& !dependent_type_p (type
)
10795 && !COMPLETE_TYPE_P (complete_type (type
))
10796 && (TREE_CODE (type
) != ARRAY_TYPE
10797 || !COMPLETE_TYPE_P (TREE_TYPE (type
))
10798 || initialized
== 0))
10800 if (unqualified_id
)
10802 error ("field %qD has incomplete type %qT",
10803 unqualified_id
, type
);
10804 cxx_incomplete_type_inform (strip_array_types (type
));
10807 error ("name %qT has incomplete type", type
);
10809 type
= error_mark_node
;
10816 error ("%qE is neither function nor member function; "
10817 "cannot be declared friend", unqualified_id
);
10825 /* Friends are treated specially. */
10826 if (ctype
== current_class_type
)
10827 ; /* We already issued a permerror. */
10828 else if (decl
&& DECL_NAME (decl
))
10830 if (template_class_depth (current_class_type
) == 0)
10832 decl
= check_explicit_specialization
10833 (unqualified_id
, decl
, template_count
,
10834 2 * funcdef_flag
+ 4);
10835 if (decl
== error_mark_node
)
10836 return error_mark_node
;
10839 decl
= do_friend (ctype
, unqualified_id
, decl
,
10845 return error_mark_node
;
10848 /* Structure field. It may not be a function, except for C++. */
10850 if (decl
== NULL_TREE
)
10854 /* C++ allows static class members. All other work
10855 for this is done by grokfield. */
10856 decl
= build_lang_decl_loc (declarator
10857 ? declarator
->id_loc
10859 VAR_DECL
, unqualified_id
, type
);
10860 set_linkage_for_static_data_member (decl
);
10861 /* Even if there is an in-class initialization, DECL
10862 is considered undefined until an out-of-class
10863 definition is provided. */
10864 DECL_EXTERNAL (decl
) = 1;
10868 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
10869 if (declspecs
->gnu_thread_keyword_p
)
10870 DECL_GNU_TLS_P (decl
) = true;
10873 if (constexpr_p
&& !initialized
)
10875 error ("constexpr static data member %qD must have an "
10876 "initializer", decl
);
10877 constexpr_p
= false;
10884 error ("non-static data member %qE declared %<constexpr%>",
10886 constexpr_p
= false;
10888 decl
= build_decl (input_location
,
10889 FIELD_DECL
, unqualified_id
, type
);
10890 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10891 if (bitfield
&& !unqualified_id
)
10892 TREE_NO_WARNING (decl
) = 1;
10894 if (storage_class
== sc_mutable
)
10896 DECL_MUTABLE_P (decl
) = 1;
10897 storage_class
= sc_none
;
10902 /* An attempt is being made to initialize a non-static
10903 member. This is new in C++11. */
10904 maybe_warn_cpp0x (CPP0X_NSDMI
);
10906 /* If this has been parsed with static storage class, but
10907 errors forced staticp to be cleared, ensure NSDMI is
10909 if (declspecs
->storage_class
== sc_static
)
10910 DECL_INITIAL (decl
) = error_mark_node
;
10914 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10915 memfn_quals
!= TYPE_UNQUALIFIED
,
10916 inlinep
, friendp
, raises
!= NULL_TREE
);
10919 else if (TREE_CODE (type
) == FUNCTION_TYPE
10920 || TREE_CODE (type
) == METHOD_TYPE
)
10922 tree original_name
;
10925 if (!unqualified_id
)
10926 return error_mark_node
;
10928 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10929 original_name
= dname
;
10931 original_name
= unqualified_id
;
10933 if (storage_class
== sc_auto
)
10934 error ("storage class %<auto%> invalid for function %qs", name
);
10935 else if (storage_class
== sc_register
)
10936 error ("storage class %<register%> invalid for function %qs", name
);
10939 if (declspecs
->gnu_thread_keyword_p
)
10940 error ("storage class %<__thread%> invalid for function %qs",
10943 error ("storage class %<thread_local%> invalid for function %qs",
10947 if (virt_specifiers
)
10948 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10949 /* Function declaration not at top level.
10950 Storage classes other than `extern' are not allowed
10951 and `extern' makes no difference. */
10952 if (! toplevel_bindings_p ()
10953 && (storage_class
== sc_static
10954 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10957 if (storage_class
== sc_static
)
10958 pedwarn (input_location
, OPT_Wpedantic
,
10959 "%<static%> specified invalid for function %qs "
10960 "declared out of global scope", name
);
10962 pedwarn (input_location
, OPT_Wpedantic
,
10963 "%<inline%> specifier invalid for function %qs "
10964 "declared out of global scope", name
);
10967 if (ctype
== NULL_TREE
)
10971 error ("virtual non-class function %qs", name
);
10974 else if (sfk
== sfk_constructor
10975 || sfk
== sfk_destructor
)
10977 error (funcdef_flag
10978 ? G_("%qs defined in a non-class scope")
10979 : G_("%qs declared in a non-class scope"), name
);
10984 /* Record whether the function is public. */
10985 publicp
= (ctype
!= NULL_TREE
10986 || storage_class
!= sc_static
);
10988 if (late_return_type_p
)
10989 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
10991 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10992 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10994 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10996 template_count
, in_namespace
, attrlist
,
10997 declarator
->id_loc
);
10998 if (decl
== NULL_TREE
)
10999 return error_mark_node
;
11003 int invalid_static
= 0;
11005 /* Don't allow a static member function in a class, and forbid
11006 declaring main to be static. */
11007 if (TREE_CODE (type
) == METHOD_TYPE
)
11009 permerror (input_location
, "cannot declare member function %qD to have "
11010 "static linkage", decl
);
11011 invalid_static
= 1;
11013 else if (current_function_decl
)
11015 /* FIXME need arm citation */
11016 error ("cannot declare static function inside another function");
11017 invalid_static
= 1;
11020 if (invalid_static
)
11023 storage_class
= sc_none
;
11029 /* It's a variable. */
11031 /* An uninitialized decl with `extern' is a reference. */
11032 decl
= grokvardecl (type
, dname
, unqualified_id
,
11035 (type_quals
& TYPE_QUAL_CONST
) != 0,
11037 ctype
? ctype
: in_namespace
);
11038 if (decl
== NULL_TREE
)
11039 return error_mark_node
;
11041 bad_specifiers (decl
, BSP_VAR
, virtualp
,
11042 memfn_quals
!= TYPE_UNQUALIFIED
,
11043 inlinep
, friendp
, raises
!= NULL_TREE
);
11047 DECL_CONTEXT (decl
) = ctype
;
11050 permerror (input_location
, "%<static%> may not be used when defining "
11051 "(as opposed to declaring) a static data member");
11053 storage_class
= sc_none
;
11055 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
11057 error ("static member %qD declared %<register%>", decl
);
11058 storage_class
= sc_none
;
11060 if (storage_class
== sc_extern
&& pedantic
)
11062 pedwarn (input_location
, OPT_Wpedantic
,
11063 "cannot explicitly declare member %q#D to have "
11064 "extern linkage", decl
);
11065 storage_class
= sc_none
;
11068 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
11070 error ("declaration of constexpr variable %qD is not a definition",
11072 constexpr_p
= false;
11076 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
11078 if (toplevel_bindings_p ())
11080 /* It's common practice (and completely valid) to have a const
11081 be initialized and declared extern. */
11082 if (!(type_quals
& TYPE_QUAL_CONST
))
11083 warning (0, "%qs initialized and declared %<extern%>", name
);
11087 error ("%qs has both %<extern%> and initializer", name
);
11088 return error_mark_node
;
11092 /* Record `register' declaration for warnings on &
11093 and in case doing stupid register allocation. */
11095 if (storage_class
== sc_register
)
11096 DECL_REGISTER (decl
) = 1;
11097 else if (storage_class
== sc_extern
)
11098 DECL_THIS_EXTERN (decl
) = 1;
11099 else if (storage_class
== sc_static
)
11100 DECL_THIS_STATIC (decl
) = 1;
11102 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11103 if (constexpr_p
&& VAR_P (decl
))
11104 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
11106 /* Record constancy and volatility on the DECL itself . There's
11107 no need to do this when processing a template; we'll do this
11108 for the instantiated declaration based on the type of DECL. */
11109 if (!processing_template_decl
)
11110 cp_apply_type_quals_to_decl (type_quals
, decl
);
11116 /* Subroutine of start_function. Ensure that each of the parameter
11117 types (as listed in PARMS) is complete, as is required for a
11118 function definition. */
11121 require_complete_types_for_parms (tree parms
)
11123 for (; parms
; parms
= DECL_CHAIN (parms
))
11125 if (dependent_type_p (TREE_TYPE (parms
)))
11127 if (!VOID_TYPE_P (TREE_TYPE (parms
))
11128 && complete_type_or_else (TREE_TYPE (parms
), parms
))
11130 relayout_decl (parms
);
11131 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
11134 /* grokparms or complete_type_or_else will have already issued
11136 TREE_TYPE (parms
) = error_mark_node
;
11140 /* Returns nonzero if T is a local variable. */
11143 local_variable_p (const_tree t
)
11146 /* A VAR_DECL with a context that is a _TYPE is a static data
11148 && !TYPE_P (CP_DECL_CONTEXT (t
))
11149 /* Any other non-local variable must be at namespace scope. */
11150 && !DECL_NAMESPACE_SCOPE_P (t
))
11151 || (TREE_CODE (t
) == PARM_DECL
))
11157 /* Like local_variable_p, but suitable for use as a tree-walking
11161 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
11164 if (local_variable_p (*tp
)
11165 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
11167 else if (TYPE_P (*tp
))
11168 *walk_subtrees
= 0;
11173 /* Check that ARG, which is a default-argument expression for a
11174 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11175 something goes wrong. DECL may also be a _TYPE node, rather than a
11176 DECL, if there is no DECL available. */
11179 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
11184 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11185 /* We get a DEFAULT_ARG when looking at an in-class declaration
11186 with a default argument. Ignore the argument for now; we'll
11187 deal with it after the class is complete. */
11196 decl_type
= TREE_TYPE (decl
);
11198 if (arg
== error_mark_node
11199 || decl
== error_mark_node
11200 || TREE_TYPE (arg
) == error_mark_node
11201 || decl_type
== error_mark_node
)
11202 /* Something already went wrong. There's no need to check
11204 return error_mark_node
;
11206 /* [dcl.fct.default]
11208 A default argument expression is implicitly converted to the
11210 ++cp_unevaluated_operand
;
11211 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
11213 --cp_unevaluated_operand
;
11215 if (warn_zero_as_null_pointer_constant
11216 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
11217 && null_ptr_cst_p (arg
)
11218 && (complain
& tf_warning
)
11219 && maybe_warn_zero_as_null_pointer_constant (arg
, input_location
))
11220 return nullptr_node
;
11222 /* [dcl.fct.default]
11224 Local variables shall not be used in default argument
11227 The keyword `this' shall not be used in a default argument of a
11228 member function. */
11229 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11232 if (complain
& tf_warning_or_error
)
11234 if (DECL_NAME (var
) == this_identifier
)
11235 permerror (input_location
, "default argument %qE uses %qD",
11238 error ("default argument %qE uses local variable %qD", arg
, var
);
11240 return error_mark_node
;
11247 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11250 type_is_deprecated (tree type
)
11252 enum tree_code code
;
11253 if (TREE_DEPRECATED (type
))
11255 if (TYPE_NAME (type
)
11256 && TREE_DEPRECATED (TYPE_NAME (type
)))
11259 /* Do warn about using typedefs to a deprecated class. */
11260 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11261 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11263 code
= TREE_CODE (type
);
11265 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11266 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11267 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11268 return type_is_deprecated (TREE_TYPE (type
));
11270 if (TYPE_PTRMEMFUNC_P (type
))
11271 return type_is_deprecated
11272 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11277 /* Decode the list of parameter types for a function type.
11278 Given the list of things declared inside the parens,
11279 return a list of types.
11281 If this parameter does not end with an ellipsis, we append
11284 *PARMS is set to the chain of PARM_DECLs created. */
11287 grokparms (tree parmlist
, tree
*parms
)
11289 tree result
= NULL_TREE
;
11290 tree decls
= NULL_TREE
;
11294 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11296 tree type
= NULL_TREE
;
11297 tree init
= TREE_PURPOSE (parm
);
11298 tree decl
= TREE_VALUE (parm
);
11299 const char *errmsg
;
11301 if (parm
== void_list_node
)
11304 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11307 type
= TREE_TYPE (decl
);
11308 if (VOID_TYPE_P (type
))
11310 if (same_type_p (type
, void_type_node
)
11312 && !DECL_NAME (decl
) && !result
11313 && TREE_CHAIN (parm
) == void_list_node
)
11314 /* DR 577: A parameter list consisting of a single
11315 unnamed parameter of non-dependent type 'void'. */
11317 else if (cv_qualified_p (type
))
11318 error_at (DECL_SOURCE_LOCATION (decl
),
11319 "invalid use of cv-qualified type %qT in "
11320 "parameter declaration", type
);
11322 error_at (DECL_SOURCE_LOCATION (decl
),
11323 "invalid use of type %<void%> in parameter "
11325 /* It's not a good idea to actually create parameters of
11326 type `void'; other parts of the compiler assume that a
11327 void type terminates the parameter list. */
11328 type
= error_mark_node
;
11329 TREE_TYPE (decl
) = error_mark_node
;
11332 if (type
!= error_mark_node
11333 && TYPE_FOR_JAVA (type
)
11334 && MAYBE_CLASS_TYPE_P (type
))
11336 error ("parameter %qD has Java class type", decl
);
11337 type
= error_mark_node
;
11338 TREE_TYPE (decl
) = error_mark_node
;
11342 if (type
!= error_mark_node
11343 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11346 type
= error_mark_node
;
11347 TREE_TYPE (decl
) = error_mark_node
;
11350 if (type
!= error_mark_node
)
11352 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11354 tree deptype
= type_is_deprecated (type
);
11356 warn_deprecated_use (deptype
, NULL_TREE
);
11359 /* Top-level qualifiers on the parameters are
11360 ignored for function types. */
11361 type
= cp_build_qualified_type (type
, 0);
11362 if (TREE_CODE (type
) == METHOD_TYPE
)
11364 error ("parameter %qD invalidly declared method type", decl
);
11365 type
= build_pointer_type (type
);
11366 TREE_TYPE (decl
) = type
;
11368 else if (abstract_virtuals_error (decl
, type
))
11369 any_error
= 1; /* Seems like a good idea. */
11370 else if (POINTER_TYPE_P (type
))
11372 /* [dcl.fct]/6, parameter types cannot contain pointers
11373 (references) to arrays of unknown bound. */
11374 tree t
= TREE_TYPE (type
);
11375 int ptr
= TYPE_PTR_P (type
);
11379 if (TYPE_PTR_P (t
))
11381 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11383 else if (!TYPE_DOMAIN (t
))
11387 if (TREE_CODE (t
) == ARRAY_TYPE
)
11389 ? G_("parameter %qD includes pointer to array of "
11390 "unknown bound %qT")
11391 : G_("parameter %qD includes reference to array of "
11392 "unknown bound %qT"),
11398 else if (init
&& !processing_template_decl
)
11399 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11402 DECL_CHAIN (decl
) = decls
;
11404 result
= tree_cons (init
, type
, result
);
11406 decls
= nreverse (decls
);
11407 result
= nreverse (result
);
11409 result
= chainon (result
, void_list_node
);
11416 /* D is a constructor or overloaded `operator='.
11418 Let T be the class in which D is declared. Then, this function
11421 -1 if D's is an ill-formed constructor or copy assignment operator
11422 whose first parameter is of type `T'.
11423 0 if D is not a copy constructor or copy assignment
11425 1 if D is a copy constructor or copy assignment operator whose
11426 first parameter is a reference to non-const qualified T.
11427 2 if D is a copy constructor or copy assignment operator whose
11428 first parameter is a reference to const qualified T.
11430 This function can be used as a predicate. Positive values indicate
11431 a copy constructor and nonzero values indicate a copy assignment
11435 copy_fn_p (const_tree d
)
11441 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11443 if (TREE_CODE (d
) == TEMPLATE_DECL
11444 || (DECL_TEMPLATE_INFO (d
)
11445 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11446 /* Instantiations of template member functions are never copy
11447 functions. Note that member functions of templated classes are
11448 represented as template functions internally, and we must
11449 accept those as copy functions. */
11452 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11456 arg_type
= TREE_VALUE (args
);
11457 if (arg_type
== error_mark_node
)
11460 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11462 /* Pass by value copy assignment operator. */
11465 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11466 && !TYPE_REF_IS_RVALUE (arg_type
)
11467 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11469 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11475 args
= TREE_CHAIN (args
);
11477 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11478 /* There are more non-optional args. */
11484 /* D is a constructor or overloaded `operator='.
11486 Let T be the class in which D is declared. Then, this function
11487 returns true when D is a move constructor or move assignment
11488 operator, false otherwise. */
11491 move_fn_p (const_tree d
)
11493 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11495 if (cxx_dialect
== cxx98
)
11496 /* There are no move constructors if we are in C++98 mode. */
11499 if (TREE_CODE (d
) == TEMPLATE_DECL
11500 || (DECL_TEMPLATE_INFO (d
)
11501 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11502 /* Instantiations of template member functions are never move
11503 functions. Note that member functions of templated classes are
11504 represented as template functions internally, and we must
11505 accept those as move functions. */
11508 return move_signature_fn_p (d
);
11511 /* D is a constructor or overloaded `operator='.
11513 Then, this function returns true when D has the same signature as a move
11514 constructor or move assignment operator (because either it is such a
11515 ctor/op= or it is a template specialization with the same signature),
11516 false otherwise. */
11519 move_signature_fn_p (const_tree d
)
11523 bool result
= false;
11525 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11529 arg_type
= TREE_VALUE (args
);
11530 if (arg_type
== error_mark_node
)
11533 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11534 && TYPE_REF_IS_RVALUE (arg_type
)
11535 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11539 args
= TREE_CHAIN (args
);
11541 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11542 /* There are more non-optional args. */
11548 /* Remember any special properties of member function DECL. */
11551 grok_special_member_properties (tree decl
)
11555 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11558 class_type
= DECL_CONTEXT (decl
);
11559 if (DECL_CONSTRUCTOR_P (decl
))
11561 int ctor
= copy_fn_p (decl
);
11563 if (!DECL_ARTIFICIAL (decl
))
11564 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11570 A non-template constructor for class X is a copy
11571 constructor if its first parameter is of type X&, const
11572 X&, volatile X& or const volatile X&, and either there
11573 are no other parameters or else all other parameters have
11574 default arguments. */
11575 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11576 if (user_provided_p (decl
))
11577 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11579 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11581 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11582 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11583 else if (move_fn_p (decl
) && user_provided_p (decl
))
11584 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11585 else if (is_list_ctor (decl
))
11586 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11588 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11589 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11590 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11592 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11596 A non-template assignment operator for class X is a copy
11597 assignment operator if its parameter is of type X, X&, const
11598 X&, volatile X& or const volatile X&. */
11600 int assop
= copy_fn_p (decl
);
11604 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11605 if (user_provided_p (decl
))
11606 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11608 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11610 else if (move_fn_p (decl
) && user_provided_p (decl
))
11611 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11613 /* Destructors are handled in check_methods. */
11616 /* Check a constructor DECL has the correct form. Complains
11617 if the class has a constructor of the form X(X). */
11620 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11622 int ctor_parm
= copy_fn_p (decl
);
11628 A declaration of a constructor for a class X is ill-formed if
11629 its first parameter is of type (optionally cv-qualified) X
11630 and either there are no other parameters or else all other
11631 parameters have default arguments.
11633 We *don't* complain about member template instantiations that
11634 have this form, though; they can occur as we try to decide
11635 what constructor to use during overload resolution. Since
11636 overload resolution will never prefer such a constructor to
11637 the non-template copy constructor (which is either explicitly
11638 or implicitly defined), there's no need to worry about their
11639 existence. Theoretically, they should never even be
11640 instantiated, but that's hard to forestall. */
11641 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11649 /* An operator with this code is unary, but can also be binary. */
11652 ambi_op_p (enum tree_code code
)
11654 return (code
== INDIRECT_REF
11655 || code
== ADDR_EXPR
11656 || code
== UNARY_PLUS_EXPR
11657 || code
== NEGATE_EXPR
11658 || code
== PREINCREMENT_EXPR
11659 || code
== PREDECREMENT_EXPR
);
11662 /* An operator with this name can only be unary. */
11665 unary_op_p (enum tree_code code
)
11667 return (code
== TRUTH_NOT_EXPR
11668 || code
== BIT_NOT_EXPR
11669 || code
== COMPONENT_REF
11670 || code
== TYPE_EXPR
);
11673 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11674 errors are issued for invalid declarations. */
11677 grok_op_properties (tree decl
, bool complain
)
11679 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11681 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11682 tree name
= DECL_NAME (decl
);
11683 enum tree_code operator_code
;
11688 /* Count the number of arguments and check for ellipsis. */
11689 for (argtype
= argtypes
, arity
= 0;
11690 argtype
&& argtype
!= void_list_node
;
11691 argtype
= TREE_CHAIN (argtype
))
11693 ellipsis_p
= !argtype
;
11695 class_type
= DECL_CONTEXT (decl
);
11696 if (class_type
&& !CLASS_TYPE_P (class_type
))
11697 class_type
= NULL_TREE
;
11699 if (DECL_CONV_FN_P (decl
))
11700 operator_code
= TYPE_EXPR
;
11704 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11705 if (ansi_opname (CODE) == name) \
11707 operator_code = (CODE); \
11710 else if (ansi_assopname (CODE) == name) \
11712 operator_code = (CODE); \
11713 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11717 #include "operators.def"
11718 #undef DEF_OPERATOR
11720 gcc_unreachable ();
11723 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11724 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11727 switch (operator_code
)
11730 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11734 TYPE_GETS_DELETE (class_type
) |= 1;
11738 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11741 case VEC_DELETE_EXPR
:
11742 TYPE_GETS_DELETE (class_type
) |= 2;
11749 /* [basic.std.dynamic.allocation]/1:
11751 A program is ill-formed if an allocation function is declared
11752 in a namespace scope other than global scope or declared static
11755 The same also holds true for deallocation functions. */
11756 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11757 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11759 if (DECL_NAMESPACE_SCOPE_P (decl
))
11761 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11763 error ("%qD may not be declared within a namespace", decl
);
11766 else if (!TREE_PUBLIC (decl
))
11768 error ("%qD may not be declared as static", decl
);
11774 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11776 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11777 DECL_IS_OPERATOR_NEW (decl
) = 1;
11779 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11780 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11783 /* An operator function must either be a non-static member function
11784 or have at least one parameter of a class, a reference to a class,
11785 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11786 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11788 if (operator_code
== TYPE_EXPR
11789 || operator_code
== CALL_EXPR
11790 || operator_code
== COMPONENT_REF
11791 || operator_code
== ARRAY_REF
11792 || operator_code
== NOP_EXPR
)
11794 error ("%qD must be a nonstatic member function", decl
);
11801 if (DECL_STATIC_FUNCTION_P (decl
))
11803 error ("%qD must be either a non-static member "
11804 "function or a non-member function", decl
);
11808 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11810 tree arg
= non_reference (TREE_VALUE (p
));
11811 if (arg
== error_mark_node
)
11814 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11815 because these checks are performed even on
11816 template functions. */
11817 if (MAYBE_CLASS_TYPE_P (arg
)
11818 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11822 if (!p
|| p
== void_list_node
)
11825 error ("%qD must have an argument of class or "
11826 "enumerated type", decl
);
11832 /* There are no restrictions on the arguments to an overloaded
11834 if (operator_code
== CALL_EXPR
)
11837 /* Warn about conversion operators that will never be used. */
11838 if (IDENTIFIER_TYPENAME_P (name
)
11839 && ! DECL_TEMPLATE_INFO (decl
)
11841 /* Warn only declaring the function; there is no need to
11842 warn again about out-of-class definitions. */
11843 && class_type
== current_class_type
)
11845 tree t
= TREE_TYPE (name
);
11846 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11849 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11851 if (VOID_TYPE_P (t
))
11852 warning (OPT_Wconversion
,
11854 ? G_("conversion to a reference to void "
11855 "will never use a type conversion operator")
11856 : G_("conversion to void "
11857 "will never use a type conversion operator"));
11858 else if (class_type
)
11860 if (t
== class_type
)
11861 warning (OPT_Wconversion
,
11863 ? G_("conversion to a reference to the same type "
11864 "will never use a type conversion operator")
11865 : G_("conversion to the same type "
11866 "will never use a type conversion operator"));
11867 /* Don't force t to be complete here. */
11868 else if (MAYBE_CLASS_TYPE_P (t
)
11869 && COMPLETE_TYPE_P (t
)
11870 && DERIVED_FROM_P (t
, class_type
))
11871 warning (OPT_Wconversion
,
11873 ? G_("conversion to a reference to a base class "
11874 "will never use a type conversion operator")
11875 : G_("conversion to a base class "
11876 "will never use a type conversion operator"));
11881 if (operator_code
== COND_EXPR
)
11884 error ("ISO C++ prohibits overloading operator ?:");
11887 else if (ellipsis_p
)
11889 error ("%qD must not have variable number of arguments", decl
);
11892 else if (ambi_op_p (operator_code
))
11895 /* We pick the one-argument operator codes by default, so
11896 we don't have to change anything. */
11898 else if (arity
== 2)
11900 /* If we thought this was a unary operator, we now know
11901 it to be a binary operator. */
11902 switch (operator_code
)
11905 operator_code
= MULT_EXPR
;
11909 operator_code
= BIT_AND_EXPR
;
11912 case UNARY_PLUS_EXPR
:
11913 operator_code
= PLUS_EXPR
;
11917 operator_code
= MINUS_EXPR
;
11920 case PREINCREMENT_EXPR
:
11921 operator_code
= POSTINCREMENT_EXPR
;
11924 case PREDECREMENT_EXPR
:
11925 operator_code
= POSTDECREMENT_EXPR
;
11929 gcc_unreachable ();
11932 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11934 if ((operator_code
== POSTINCREMENT_EXPR
11935 || operator_code
== POSTDECREMENT_EXPR
)
11936 && ! processing_template_decl
11937 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11940 error ("postfix %qD must take %<int%> as its argument",
11943 error ("postfix %qD must take %<int%> as its second "
11951 error ("%qD must take either zero or one argument", decl
);
11953 error ("%qD must take either one or two arguments", decl
);
11957 /* More Effective C++ rule 6. */
11959 && (operator_code
== POSTINCREMENT_EXPR
11960 || operator_code
== POSTDECREMENT_EXPR
11961 || operator_code
== PREINCREMENT_EXPR
11962 || operator_code
== PREDECREMENT_EXPR
))
11964 tree arg
= TREE_VALUE (argtypes
);
11965 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11966 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11967 arg
= TREE_TYPE (arg
);
11968 arg
= TYPE_MAIN_VARIANT (arg
);
11969 if (operator_code
== PREINCREMENT_EXPR
11970 || operator_code
== PREDECREMENT_EXPR
)
11972 if (TREE_CODE (ret
) != REFERENCE_TYPE
11973 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11975 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11976 build_reference_type (arg
));
11980 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11981 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11985 else if (unary_op_p (operator_code
))
11990 error ("%qD must take %<void%>", decl
);
11992 error ("%qD must take exactly one argument", decl
);
11996 else /* if (binary_op_p (operator_code)) */
12001 error ("%qD must take exactly one argument", decl
);
12003 error ("%qD must take exactly two arguments", decl
);
12007 /* More Effective C++ rule 7. */
12009 && (operator_code
== TRUTH_ANDIF_EXPR
12010 || operator_code
== TRUTH_ORIF_EXPR
12011 || operator_code
== COMPOUND_EXPR
))
12012 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
12016 /* Effective C++ rule 23. */
12019 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
12020 && (operator_code
== PLUS_EXPR
12021 || operator_code
== MINUS_EXPR
12022 || operator_code
== TRUNC_DIV_EXPR
12023 || operator_code
== MULT_EXPR
12024 || operator_code
== TRUNC_MOD_EXPR
)
12025 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
12026 warning (OPT_Weffc__
, "%qD should return by value", decl
);
12028 /* [over.oper]/8 */
12029 for (; argtypes
&& argtypes
!= void_list_node
;
12030 argtypes
= TREE_CHAIN (argtypes
))
12031 if (TREE_PURPOSE (argtypes
))
12033 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12034 if (operator_code
== POSTINCREMENT_EXPR
12035 || operator_code
== POSTDECREMENT_EXPR
)
12037 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
12042 error ("%qD cannot have default arguments", decl
);
12050 /* Return a string giving the keyword associate with CODE. */
12052 static const char *
12053 tag_name (enum tag_types code
)
12065 case typename_type
:
12068 gcc_unreachable ();
12072 /* Name lookup in an elaborated-type-specifier (after the keyword
12073 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12074 elaborated-type-specifier is invalid, issue a diagnostic and return
12075 error_mark_node; otherwise, return the *_TYPE to which it referred.
12076 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12079 check_elaborated_type_specifier (enum tag_types tag_code
,
12081 bool allow_template_p
)
12087 struct S { struct S *p; };
12089 name lookup will find the TYPE_DECL for the implicit "S::S"
12090 typedef. Adjust for that here. */
12091 if (DECL_SELF_REFERENCE_P (decl
))
12092 decl
= TYPE_NAME (TREE_TYPE (decl
));
12094 type
= TREE_TYPE (decl
);
12096 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12097 is false for this case as well. */
12098 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12100 error ("using template type parameter %qT after %qs",
12101 type
, tag_name (tag_code
));
12102 return error_mark_node
;
12104 /* Accept template template parameters. */
12105 else if (allow_template_p
12106 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
12107 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
12111 If the identifier resolves to a typedef-name or the
12112 simple-template-id resolves to an alias template
12113 specialization, the elaborated-type-specifier is ill-formed.
12115 In other words, the only legitimate declaration to use in the
12116 elaborated type specifier is the implicit typedef created when
12117 the type is declared. */
12118 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
12119 && !DECL_SELF_REFERENCE_P (decl
)
12120 && tag_code
!= typename_type
)
12122 if (alias_template_specialization_p (type
))
12123 error ("using alias template specialization %qT after %qs",
12124 type
, tag_name (tag_code
));
12126 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
12127 inform (DECL_SOURCE_LOCATION (decl
),
12128 "%qD has a previous declaration here", decl
);
12129 return error_mark_node
;
12131 else if (TREE_CODE (type
) != RECORD_TYPE
12132 && TREE_CODE (type
) != UNION_TYPE
12133 && tag_code
!= enum_type
12134 && tag_code
!= typename_type
)
12136 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
12137 inform (input_location
, "%q+T has a previous declaration here", type
);
12138 return error_mark_node
;
12140 else if (TREE_CODE (type
) != ENUMERAL_TYPE
12141 && tag_code
== enum_type
)
12143 error ("%qT referred to as enum", type
);
12144 inform (input_location
, "%q+T has a previous declaration here", type
);
12145 return error_mark_node
;
12147 else if (!allow_template_p
12148 && TREE_CODE (type
) == RECORD_TYPE
12149 && CLASSTYPE_IS_TEMPLATE (type
))
12151 /* If a class template appears as elaborated type specifier
12152 without a template header such as:
12154 template <class T> class C {};
12155 void f(class C); // No template header here
12157 then the required template argument is missing. */
12158 error ("template argument required for %<%s %T%>",
12159 tag_name (tag_code
),
12160 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
12161 return error_mark_node
;
12167 /* Lookup NAME in elaborate type specifier in scope according to
12168 SCOPE and issue diagnostics if necessary.
12169 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12170 found, and ERROR_MARK_NODE for type error. */
12173 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
12174 tag_scope scope
, bool template_header_p
)
12178 if (scope
== ts_global
)
12180 /* First try ordinary name lookup, ignoring hidden class name
12181 injected via friend declaration. */
12182 decl
= lookup_name_prefer_type (name
, 2);
12183 /* If that fails, the name will be placed in the smallest
12184 non-class, non-function-prototype scope according to 3.3.1/5.
12185 We may already have a hidden name declared as friend in this
12186 scope. So lookup again but not ignoring hidden names.
12187 If we find one, that name will be made visible rather than
12188 creating a new tag. */
12190 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
12193 decl
= lookup_type_scope (name
, scope
);
12196 && (DECL_CLASS_TEMPLATE_P (decl
)
12197 /* If scope is ts_current we're defining a class, so ignore a
12198 template template parameter. */
12199 || (scope
!= ts_current
12200 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
12201 decl
= DECL_TEMPLATE_RESULT (decl
);
12203 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
12205 /* Look for invalid nested type:
12209 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
12211 error ("%qD has the same name as the class in which it is "
12214 return error_mark_node
;
12217 /* Two cases we need to consider when deciding if a class
12218 template is allowed as an elaborated type specifier:
12219 1. It is a self reference to its own class.
12220 2. It comes with a template header.
12224 template <class T> class C {
12225 class C *c1; // DECL_SELF_REFERENCE_P is true
12228 template <class U> class C; // template_header_p is true
12229 template <class T> class C<T>::D {
12230 class C *c2; // DECL_SELF_REFERENCE_P is true
12233 t
= check_elaborated_type_specifier (tag_code
,
12236 | DECL_SELF_REFERENCE_P (decl
));
12239 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12241 error ("reference to %qD is ambiguous", name
);
12242 print_candidates (decl
);
12243 return error_mark_node
;
12249 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12250 Define the tag as a forward-reference if it is not defined.
12252 If a declaration is given, process it here, and report an error if
12253 multiple declarations are not identical.
12255 SCOPE is TS_CURRENT when this is also a definition. Only look in
12256 the current frame for the name (since C++ allows new names in any
12257 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12258 declaration. Only look beginning from the current scope outward up
12259 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12261 TEMPLATE_HEADER_P is true when this declaration is preceded by
12262 a set of template parameters. */
12265 xref_tag_1 (enum tag_types tag_code
, tree name
,
12266 tag_scope orig_scope
, bool template_header_p
)
12268 enum tree_code code
;
12270 tree context
= NULL_TREE
;
12273 gcc_assert (identifier_p (name
));
12279 code
= RECORD_TYPE
;
12285 code
= ENUMERAL_TYPE
;
12288 gcc_unreachable ();
12291 if (orig_scope
== ts_lambda
)
12292 scope
= ts_current
;
12294 scope
= orig_scope
;
12296 /* In case of anonymous name, xref_tag is only called to
12297 make type node and push name. Name lookup is not required. */
12298 if (ANON_AGGRNAME_P (name
))
12301 t
= lookup_and_check_tag (tag_code
, name
,
12302 scope
, template_header_p
);
12304 if (t
== error_mark_node
)
12305 return error_mark_node
;
12307 if (scope
!= ts_current
&& t
&& current_class_type
12308 && template_class_depth (current_class_type
)
12309 && template_header_p
)
12311 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12314 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12315 definition of this tag. Since, in addition, we are currently
12316 processing a (member) template declaration of a template
12317 class, we must be very careful; consider:
12324 { template <class V>
12325 friend struct S1; };
12327 Here, the S2::S1 declaration should not be confused with the
12328 outer declaration. In particular, the inner version should
12329 have a template parameter of level 2, not level 1. This
12330 would be particularly important if the member declaration
12333 template <class V = U> friend struct S1;
12335 say, when we should tsubst into `U' when instantiating
12336 S2. On the other hand, when presented with:
12346 we must find the inner binding eventually. We
12347 accomplish this by making sure that the new type we
12348 create to represent this declaration has the right
12350 context
= TYPE_CONTEXT (t
);
12356 /* If no such tag is yet defined, create a forward-reference node
12357 and record it as the "definition".
12358 When a real declaration of this type is found,
12359 the forward-reference will be altered into a real type. */
12360 if (code
== ENUMERAL_TYPE
)
12362 error ("use of enum %q#D without previous declaration", name
);
12363 return error_mark_node
;
12367 t
= make_class_type (code
);
12368 TYPE_CONTEXT (t
) = context
;
12369 if (orig_scope
== ts_lambda
)
12370 /* Remember that we're declaring a lambda to avoid bogus errors
12371 in push_template_decl. */
12372 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12373 t
= pushtag (name
, t
, scope
);
12378 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12380 if (!redeclare_class_template (t
, current_template_parms
))
12381 return error_mark_node
;
12383 else if (!processing_template_decl
12384 && CLASS_TYPE_P (t
)
12385 && CLASSTYPE_IS_TEMPLATE (t
))
12387 error ("redeclaration of %qT as a non-template", t
);
12388 error ("previous declaration %q+D", t
);
12389 return error_mark_node
;
12392 /* Make injected friend class visible. */
12393 if (scope
!= ts_within_enclosing_non_class
12394 && hidden_name_p (TYPE_NAME (t
)))
12396 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12397 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12399 if (TYPE_TEMPLATE_INFO (t
))
12401 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12402 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12410 /* Wrapper for xref_tag_1. */
12413 xref_tag (enum tag_types tag_code
, tree name
,
12414 tag_scope scope
, bool template_header_p
)
12418 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12419 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12420 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12426 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12428 enum tag_types tag_kind
;
12430 if (TREE_CODE (old
) == RECORD_TYPE
)
12431 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12433 tag_kind
= union_type
;
12435 if (id
== NULL_TREE
)
12436 id
= TYPE_IDENTIFIER (old
);
12438 return xref_tag (tag_kind
, id
, scope
, false);
12441 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12442 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12443 access_* node, and the TREE_VALUE is the type of the base-class.
12444 Non-NULL TREE_TYPE indicates virtual inheritance.
12446 Returns true if the binfo hierarchy was successfully created,
12447 false if an error was detected. */
12450 xref_basetypes (tree ref
, tree base_list
)
12453 tree binfo
, base_binfo
;
12454 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12455 unsigned max_bases
= 0; /* Maximum direct bases. */
12457 tree default_access
;
12458 tree igo_prev
; /* Track Inheritance Graph Order. */
12460 if (ref
== error_mark_node
)
12463 /* The base of a derived class is private by default, all others are
12465 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12466 && CLASSTYPE_DECLARED_CLASS (ref
)
12467 ? access_private_node
: access_public_node
);
12469 /* First, make sure that any templates in base-classes are
12470 instantiated. This ensures that if we call ourselves recursively
12471 we do not get confused about which classes are marked and which
12473 basep
= &base_list
;
12476 tree basetype
= TREE_VALUE (*basep
);
12478 /* The dependent_type_p call below should really be dependent_scope_p
12479 so that we give a hard error about using an incomplete type as a
12480 base, but we allow it with a pedwarn for backward
12482 if (processing_template_decl
12483 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12484 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12485 if (!dependent_type_p (basetype
)
12486 && !complete_type_or_else (basetype
, NULL
))
12487 /* An incomplete type. Remove it from the list. */
12488 *basep
= TREE_CHAIN (*basep
);
12492 if (TREE_TYPE (*basep
))
12494 if (CLASS_TYPE_P (basetype
))
12495 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12496 basep
= &TREE_CHAIN (*basep
);
12500 TYPE_MARKED_P (ref
) = 1;
12502 /* The binfo slot should be empty, unless this is an (ill-formed)
12504 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12506 error ("redefinition of %q#T", ref
);
12510 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12512 binfo
= make_tree_binfo (max_bases
);
12514 TYPE_BINFO (ref
) = binfo
;
12515 BINFO_OFFSET (binfo
) = size_zero_node
;
12516 BINFO_TYPE (binfo
) = ref
;
12518 /* Apply base-class info set up to the variants of this type. */
12519 fixup_type_variants (ref
);
12523 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12524 /* An aggregate cannot have baseclasses. */
12525 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12527 if (TREE_CODE (ref
) == UNION_TYPE
)
12529 error ("derived union %qT invalid", ref
);
12536 if (TYPE_FOR_JAVA (ref
))
12538 error ("Java class %qT cannot have multiple bases", ref
);
12545 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12547 if (TYPE_FOR_JAVA (ref
))
12549 error ("Java class %qT cannot have virtual bases", ref
);
12554 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12556 tree access
= TREE_PURPOSE (base_list
);
12557 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12558 tree basetype
= TREE_VALUE (base_list
);
12560 if (access
== access_default_node
)
12561 access
= default_access
;
12563 if (PACK_EXPANSION_P (basetype
))
12564 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12565 if (TREE_CODE (basetype
) == TYPE_DECL
)
12566 basetype
= TREE_TYPE (basetype
);
12567 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12569 error ("base type %qT fails to be a struct or class type",
12574 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12575 TYPE_FOR_JAVA (ref
) = 1;
12577 base_binfo
= NULL_TREE
;
12578 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12580 base_binfo
= TYPE_BINFO (basetype
);
12581 /* The original basetype could have been a typedef'd type. */
12582 basetype
= BINFO_TYPE (base_binfo
);
12584 /* Inherit flags from the base. */
12585 TYPE_HAS_NEW_OPERATOR (ref
)
12586 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12587 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12588 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12589 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12590 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12591 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12592 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12593 CLASSTYPE_REPEATED_BASE_P (ref
)
12594 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12597 /* We must do this test after we've seen through a typedef
12599 if (TYPE_MARKED_P (basetype
))
12601 if (basetype
== ref
)
12602 error ("recursive type %qT undefined", basetype
);
12604 error ("duplicate base type %qT invalid", basetype
);
12608 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12609 /* Regenerate the pack expansion for the bases. */
12610 basetype
= make_pack_expansion (basetype
);
12612 TYPE_MARKED_P (basetype
) = 1;
12614 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12615 &igo_prev
, via_virtual
);
12616 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12617 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12619 BINFO_BASE_APPEND (binfo
, base_binfo
);
12620 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12623 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12624 /* If we didn't get max_vbases vbases, we must have shared at
12625 least one of them, and are therefore diamond shaped. */
12626 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12628 /* Unmark all the types. */
12629 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12630 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12631 TYPE_MARKED_P (ref
) = 0;
12633 /* Now see if we have a repeated base type. */
12634 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12636 for (base_binfo
= binfo
; base_binfo
;
12637 base_binfo
= TREE_CHAIN (base_binfo
))
12639 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12641 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12644 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12646 for (base_binfo
= binfo
; base_binfo
;
12647 base_binfo
= TREE_CHAIN (base_binfo
))
12648 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12649 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12658 /* Copies the enum-related properties from type SRC to type DST.
12659 Used with the underlying type of an enum and the enum itself. */
12661 copy_type_enum (tree dst
, tree src
)
12664 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12666 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12667 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12668 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12669 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12670 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12671 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12672 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12673 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12674 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12678 /* Begin compiling the definition of an enumeration type.
12681 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12683 UNDERLYING_TYPE is the type that will be used as the storage for
12684 the enumeration type. This should be NULL_TREE if no storage type
12687 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12689 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12691 Returns the type object, as yet incomplete.
12692 Also records info about it so that build_enumerator
12693 may be used to declare the individual values as they are read. */
12696 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12697 bool scoped_enum_p
, bool *is_new
)
12699 tree prevtype
= NULL_TREE
;
12700 gcc_assert (identifier_p (name
));
12704 /* [C++0x dcl.enum]p5:
12706 If not explicitly specified, the underlying type of a scoped
12707 enumeration type is int. */
12708 if (!underlying_type
&& scoped_enum_p
)
12709 underlying_type
= integer_type_node
;
12711 if (underlying_type
)
12712 underlying_type
= cv_unqualified (underlying_type
);
12714 /* If this is the real definition for a previous forward reference,
12715 fill in the contents in the same object that used to be the
12716 forward reference. */
12718 enumtype
= lookup_and_check_tag (enum_type
, name
,
12719 /*tag_scope=*/ts_current
,
12720 /*template_header_p=*/false);
12722 /* In case of a template_decl, the only check that should be deferred
12723 to instantiation time is the comparison of underlying types. */
12724 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12726 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12728 error_at (input_location
, "scoped/unscoped mismatch "
12729 "in enum %q#T", enumtype
);
12730 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12731 "previous definition here");
12732 enumtype
= error_mark_node
;
12734 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12736 error_at (input_location
, "underlying type mismatch "
12737 "in enum %q#T", enumtype
);
12738 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12739 "previous definition here");
12740 enumtype
= error_mark_node
;
12742 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12743 && !dependent_type_p (underlying_type
)
12744 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12745 && !same_type_p (underlying_type
,
12746 ENUM_UNDERLYING_TYPE (enumtype
)))
12748 error_at (input_location
, "different underlying type "
12749 "in enum %q#T", enumtype
);
12750 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12751 "previous definition here");
12752 underlying_type
= NULL_TREE
;
12756 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12757 || processing_template_decl
)
12759 /* In case of error, make a dummy enum to allow parsing to
12761 if (enumtype
== error_mark_node
)
12763 name
= make_anon_name ();
12764 enumtype
= NULL_TREE
;
12767 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12768 of an opaque enum, or an opaque enum of an already defined
12769 enumeration (C++0x only).
12770 In any other case, it'll be NULL_TREE. */
12776 prevtype
= enumtype
;
12778 /* Do not push the decl more than once, unless we need to
12779 compare underlying types at instantiation time */
12781 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12782 || (underlying_type
12783 && dependent_type_p (underlying_type
))
12784 || (ENUM_UNDERLYING_TYPE (enumtype
)
12785 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12787 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12788 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12791 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12794 if (enumtype
== error_mark_node
)
12795 return error_mark_node
;
12797 /* The enum is considered opaque until the opening '{' of the
12798 enumerator list. */
12799 SET_OPAQUE_ENUM_P (enumtype
, true);
12800 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12803 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12805 if (underlying_type
)
12807 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12809 copy_type_enum (enumtype
, underlying_type
);
12810 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12812 else if (dependent_type_p (underlying_type
))
12813 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12815 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12816 underlying_type
, enumtype
);
12819 /* If into a template class, the returned enum is always the first
12820 declaration (opaque or not) seen. This way all the references to
12821 this type will be to the same declaration. The following ones are used
12822 only to check for definition errors. */
12823 if (prevtype
&& processing_template_decl
)
12829 /* After processing and defining all the values of an enumeration type,
12830 install their decls in the enumeration type.
12831 ENUMTYPE is the type object. */
12834 finish_enum_value_list (tree enumtype
)
12837 tree underlying_type
;
12840 tree minnode
, maxnode
;
12843 bool fixed_underlying_type_p
12844 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12846 /* We built up the VALUES in reverse order. */
12847 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12849 /* For an enum defined in a template, just set the type of the values;
12850 all further processing is postponed until the template is
12851 instantiated. We need to set the type so that tsubst of a CONST_DECL
12853 if (processing_template_decl
)
12855 for (values
= TYPE_VALUES (enumtype
);
12857 values
= TREE_CHAIN (values
))
12858 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12862 /* Determine the minimum and maximum values of the enumerators. */
12863 if (TYPE_VALUES (enumtype
))
12865 minnode
= maxnode
= NULL_TREE
;
12867 for (values
= TYPE_VALUES (enumtype
);
12869 values
= TREE_CHAIN (values
))
12871 decl
= TREE_VALUE (values
);
12873 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12874 each enumerator has the type of its enumeration. Prior to the
12875 closing brace, the type of each enumerator is the type of its
12876 initializing value. */
12877 TREE_TYPE (decl
) = enumtype
;
12879 /* Update the minimum and maximum values, if appropriate. */
12880 value
= DECL_INITIAL (decl
);
12881 if (value
== error_mark_node
)
12882 value
= integer_zero_node
;
12883 /* Figure out what the minimum and maximum values of the
12884 enumerators are. */
12886 minnode
= maxnode
= value
;
12887 else if (tree_int_cst_lt (maxnode
, value
))
12889 else if (tree_int_cst_lt (value
, minnode
))
12896 If the enumerator-list is empty, the underlying type is as if
12897 the enumeration had a single enumerator with value 0. */
12898 minnode
= maxnode
= integer_zero_node
;
12900 if (!fixed_underlying_type_p
)
12902 /* Compute the number of bits require to represent all values of the
12903 enumeration. We must do this before the type of MINNODE and
12904 MAXNODE are transformed, since tree_int_cst_min_precision relies
12905 on the TREE_TYPE of the value it is passed. */
12906 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
12907 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
12908 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
12909 int precision
= MAX (lowprec
, highprec
);
12911 bool use_short_enum
;
12913 /* Determine the underlying type of the enumeration.
12917 The underlying type of an enumeration is an integral type that
12918 can represent all the enumerator values defined in the
12919 enumeration. It is implementation-defined which integral type is
12920 used as the underlying type for an enumeration except that the
12921 underlying type shall not be larger than int unless the value of
12922 an enumerator cannot fit in an int or unsigned int.
12924 We use "int" or an "unsigned int" as the underlying type, even if
12925 a smaller integral type would work, unless the user has
12926 explicitly requested that we use the smallest possible type. The
12927 user can request that for all enumerations with a command line
12928 flag, or for just one enumeration with an attribute. */
12930 use_short_enum
= flag_short_enums
12931 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12933 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12937 underlying_type
= integer_types
[itk
];
12938 if (underlying_type
!= NULL_TREE
12939 && TYPE_PRECISION (underlying_type
) >= precision
12940 && TYPE_SIGN (underlying_type
) == sgn
)
12943 if (itk
== itk_none
)
12947 IF no integral type can represent all the enumerator values, the
12948 enumeration is ill-formed. */
12949 error ("no integral type can represent all of the enumerator values "
12950 "for %qT", enumtype
);
12951 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12952 underlying_type
= integer_types
[itk_unsigned_long_long
];
12957 The value of sizeof() applied to an enumeration type, an object
12958 of an enumeration type, or an enumerator, is the value of sizeof()
12959 applied to the underlying type. */
12960 copy_type_enum (enumtype
, underlying_type
);
12962 /* Compute the minimum and maximum values for the type.
12966 For an enumeration where emin is the smallest enumerator and emax
12967 is the largest, the values of the enumeration are the values of the
12968 underlying type in the range bmin to bmax, where bmin and bmax are,
12969 respectively, the smallest and largest values of the smallest bit-
12970 field that can store emin and emax. */
12972 /* The middle-end currently assumes that types with TYPE_PRECISION
12973 narrower than their underlying type are suitably zero or sign
12974 extended to fill their mode. Similarly, it assumes that the front
12975 end assures that a value of a particular type must be within
12976 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12978 We used to set these fields based on bmin and bmax, but that led
12979 to invalid assumptions like optimizing away bounds checking. So
12980 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12981 TYPE_MAX_VALUE to the values for the mode above and only restrict
12982 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12983 ENUM_UNDERLYING_TYPE (enumtype
)
12984 = build_distinct_type_copy (underlying_type
);
12985 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12986 set_min_and_max_values_for_integral_type
12987 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
12989 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12990 if (flag_strict_enums
)
12991 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
12994 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12996 /* Convert each of the enumerators to the type of the underlying
12997 type of the enumeration. */
12998 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
13000 location_t saved_location
;
13002 decl
= TREE_VALUE (values
);
13003 saved_location
= input_location
;
13004 input_location
= DECL_SOURCE_LOCATION (decl
);
13005 if (fixed_underlying_type_p
)
13006 /* If the enumeration type has a fixed underlying type, we
13007 already checked all of the enumerator values. */
13008 value
= DECL_INITIAL (decl
);
13010 value
= perform_implicit_conversion (underlying_type
,
13011 DECL_INITIAL (decl
),
13012 tf_warning_or_error
);
13013 input_location
= saved_location
;
13015 /* Do not clobber shared ints. */
13016 value
= copy_node (value
);
13018 TREE_TYPE (value
) = enumtype
;
13019 DECL_INITIAL (decl
) = value
;
13022 /* Fix up all variant types of this enum type. */
13023 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
13024 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
13026 if (at_class_scope_p ()
13027 && COMPLETE_TYPE_P (current_class_type
)
13028 && UNSCOPED_ENUM_P (enumtype
))
13029 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
13030 current_class_type
);
13032 /* Finish debugging output for this type. */
13033 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13036 /* Finishes the enum type. This is called only the first time an
13037 enumeration is seen, be it opaque or odinary.
13038 ENUMTYPE is the type object. */
13041 finish_enum (tree enumtype
)
13043 if (processing_template_decl
)
13045 if (at_function_scope_p ())
13046 add_stmt (build_min (TAG_DEFN
, enumtype
));
13050 /* If this is a forward declaration, there should not be any variants,
13051 though we can get a variant in the middle of an enum-specifier with
13052 wacky code like 'enum E { e = sizeof(const E*) };' */
13053 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
13054 && (TYPE_VALUES (enumtype
)
13055 || !TYPE_NEXT_VARIANT (enumtype
)));
13058 /* Build and install a CONST_DECL for an enumeration constant of the
13059 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13060 LOC is the location of NAME.
13061 Assignment of sequential values by default is handled here. */
13064 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
13070 /* scalar_constant_value will pull out this expression, so make sure
13071 it's folded as appropriate. */
13072 if (processing_template_decl
)
13073 value
= fold_non_dependent_expr (value
);
13075 /* If the VALUE was erroneous, pretend it wasn't there; that will
13076 result in the enum being assigned the next value in sequence. */
13077 if (value
== error_mark_node
)
13080 /* Remove no-op casts from the value. */
13082 STRIP_TYPE_NOPS (value
);
13084 if (! processing_template_decl
)
13086 /* Validate and default VALUE. */
13087 if (value
!= NULL_TREE
)
13089 if (!ENUM_UNDERLYING_TYPE (enumtype
))
13091 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
13096 else if (! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13097 value
= perform_implicit_conversion_flags
13098 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
13099 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
13101 if (value
== error_mark_node
)
13104 if (value
!= NULL_TREE
)
13106 value
= cxx_constant_value (value
);
13108 if (TREE_CODE (value
) != INTEGER_CST
13109 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13111 error ("enumerator value for %qD is not an integer constant",
13118 /* Default based on previous value. */
13119 if (value
== NULL_TREE
)
13121 if (TYPE_VALUES (enumtype
))
13126 /* C++03 7.2/4: If no initializer is specified for the first
13127 enumerator, the type is an unspecified integral
13128 type. Otherwise the type is the same as the type of the
13129 initializing value of the preceding enumerator unless the
13130 incremented value is not representable in that type, in
13131 which case the type is an unspecified integral type
13132 sufficient to contain the incremented value. */
13133 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13134 if (error_operand_p (prev_value
))
13135 value
= error_mark_node
;
13138 tree type
= TREE_TYPE (prev_value
);
13139 signop sgn
= TYPE_SIGN (type
);
13140 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
13144 bool pos
= !wi::neg_p (wi
, sgn
);
13145 if (!wi::fits_to_tree_p (wi
, type
))
13148 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
13150 type
= integer_types
[itk
];
13151 if (type
!= NULL_TREE
13152 && (pos
|| !TYPE_UNSIGNED (type
))
13153 && wi::fits_to_tree_p (wi
, type
))
13156 if (type
&& cxx_dialect
< cxx11
13157 && itk
> itk_unsigned_long
)
13158 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
13159 incremented enumerator value is too large for %<unsigned long%>" : "\
13160 incremented enumerator value is too large for %<long%>");
13162 if (type
== NULL_TREE
)
13165 value
= wide_int_to_tree (type
, wi
);
13170 error ("overflow in enumeration values at %qD", name
);
13171 value
= error_mark_node
;
13176 value
= integer_zero_node
;
13179 /* Remove no-op casts from the value. */
13180 STRIP_TYPE_NOPS (value
);
13182 /* If the underlying type of the enum is fixed, check whether
13183 the enumerator values fits in the underlying type. If it
13184 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13185 if (ENUM_UNDERLYING_TYPE (enumtype
)
13187 && TREE_CODE (value
) == INTEGER_CST
)
13189 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
13190 error ("enumerator value %E is outside the range of underlying "
13191 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
13193 /* Convert the value to the appropriate type. */
13194 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
13198 /* C++ associates enums with global, function, or class declarations. */
13199 context
= current_scope ();
13201 /* Build the actual enumeration constant. Note that the enumeration
13202 constants have the underlying type of the enum (if it is fixed)
13203 or the type of their initializer (if the underlying type of the
13204 enum is not fixed):
13208 If the underlying type is fixed, the type of each enumerator
13209 prior to the closing brace is the underlying type; if the
13210 initializing value of an enumerator cannot be represented by
13211 the underlying type, the program is ill-formed. If the
13212 underlying type is not fixed, the type of each enumerator is
13213 the type of its initializing value.
13215 If the underlying type is not fixed, it will be computed by
13216 finish_enum and we will reset the type of this enumerator. Of
13217 course, if we're processing a template, there may be no value. */
13218 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13220 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
13222 DECL_CONTEXT (decl
) = enumtype
;
13223 TREE_CONSTANT (decl
) = 1;
13224 TREE_READONLY (decl
) = 1;
13225 DECL_INITIAL (decl
) = value
;
13227 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
13228 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13229 on the TYPE_FIELDS list for `S'. (That's so that you can say
13230 things like `S::i' later.) */
13231 finish_member_declaration (decl
);
13235 /* Add this enumeration constant to the list for this type. */
13236 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13239 /* Look for an enumerator with the given NAME within the enumeration
13240 type ENUMTYPE. This routine is used primarily for qualified name
13241 lookup into an enumerator in C++0x, e.g.,
13243 enum class Color { Red, Green, Blue };
13245 Color color = Color::Red;
13247 Returns the value corresponding to the enumerator, or
13248 NULL_TREE if no such enumerator was found. */
13250 lookup_enumerator (tree enumtype
, tree name
)
13253 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13255 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13256 return e
? TREE_VALUE (e
) : NULL_TREE
;
13260 /* We're defining DECL. Make sure that its type is OK. */
13263 check_function_type (tree decl
, tree current_function_parms
)
13265 tree fntype
= TREE_TYPE (decl
);
13266 tree return_type
= complete_type (TREE_TYPE (fntype
));
13268 /* In a function definition, arg types must be complete. */
13269 require_complete_types_for_parms (current_function_parms
);
13271 if (dependent_type_p (return_type
)
13272 || type_uses_auto (return_type
))
13274 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13275 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13277 tree args
= TYPE_ARG_TYPES (fntype
);
13279 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13280 error ("return type %q#T is incomplete", return_type
);
13282 error ("return type has Java class type %q#T", return_type
);
13284 /* Make it return void instead. */
13285 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13286 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13288 TREE_CHAIN (args
));
13290 fntype
= build_function_type (void_type_node
, args
);
13292 = build_exception_variant (fntype
,
13293 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13294 fntype
= (cp_build_type_attribute_variant
13295 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13296 TREE_TYPE (decl
) = fntype
;
13299 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13302 /* Create the FUNCTION_DECL for a function definition.
13303 DECLSPECS and DECLARATOR are the parts of the declaration;
13304 they describe the function's name and the type it returns,
13305 but twisted together in a fashion that parallels the syntax of C.
13307 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13308 DECLARATOR is really the DECL for the function we are about to
13309 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13310 indicating that the function is an inline defined in-class.
13312 This function creates a binding context for the function body
13313 as well as setting up the FUNCTION_DECL in current_function_decl.
13315 For C++, we must first check whether that datum makes any sense.
13316 For example, "class A local_a(1,2);" means that variable local_a
13317 is an aggregate of type A, which should have a constructor
13318 applied to it with the argument list [1, 2].
13320 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13321 or may be a BLOCK if the function has been defined previously
13322 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13323 error_mark_node if the function has never been defined, or
13324 a BLOCK if the function has been defined somewhere. */
13327 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13329 tree ctype
= NULL_TREE
;
13332 int doing_friend
= 0;
13333 cp_binding_level
*bl
;
13334 tree current_function_parms
;
13335 struct c_fileinfo
*finfo
13336 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13337 bool honor_interface
;
13339 /* Sanity check. */
13340 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13341 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13343 fntype
= TREE_TYPE (decl1
);
13344 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13345 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13347 /* ISO C++ 11.4/5. A friend function defined in a class is in
13348 the (lexical) scope of the class in which it is defined. */
13349 if (!ctype
&& DECL_FRIEND_P (decl1
))
13351 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13353 /* CTYPE could be null here if we're dealing with a template;
13354 for example, `inline friend float foo()' inside a template
13355 will have no CTYPE set. */
13356 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13362 if (DECL_DECLARED_INLINE_P (decl1
)
13363 && lookup_attribute ("noinline", attrs
))
13364 warning (0, "inline function %q+D given attribute noinline", decl1
);
13366 /* Handle gnu_inline attribute. */
13367 if (GNU_INLINE_P (decl1
))
13369 DECL_EXTERNAL (decl1
) = 1;
13370 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13371 DECL_INTERFACE_KNOWN (decl1
) = 1;
13372 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13375 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13376 /* This is a constructor, we must ensure that any default args
13377 introduced by this definition are propagated to the clones
13378 now. The clones are used directly in overload resolution. */
13379 adjust_clone_args (decl1
);
13381 /* Sometimes we don't notice that a function is a static member, and
13382 build a METHOD_TYPE for it. Fix that up now. */
13383 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13384 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13386 /* Set up current_class_type, and enter the scope of the class, if
13389 push_nested_class (ctype
);
13390 else if (DECL_STATIC_FUNCTION_P (decl1
))
13391 push_nested_class (DECL_CONTEXT (decl1
));
13393 /* Now that we have entered the scope of the class, we must restore
13394 the bindings for any template parameters surrounding DECL1, if it
13395 is an inline member template. (Order is important; consider the
13396 case where a template parameter has the same name as a field of
13397 the class.) It is not until after this point that
13398 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13399 if (flags
& SF_INCLASS_INLINE
)
13400 maybe_begin_member_template_processing (decl1
);
13402 /* Effective C++ rule 15. */
13404 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13405 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13406 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13408 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13409 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13410 if (!DECL_INITIAL (decl1
))
13411 DECL_INITIAL (decl1
) = error_mark_node
;
13413 /* This function exists in static storage.
13414 (This does not mean `static' in the C sense!) */
13415 TREE_STATIC (decl1
) = 1;
13417 /* We must call push_template_decl after current_class_type is set
13418 up. (If we are processing inline definitions after exiting a
13419 class scope, current_class_type will be NULL_TREE until set above
13420 by push_nested_class.) */
13421 if (processing_template_decl
)
13423 tree newdecl1
= push_template_decl (decl1
);
13424 if (newdecl1
== error_mark_node
)
13426 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13427 pop_nested_class ();
13433 /* We are now in the scope of the function being defined. */
13434 current_function_decl
= decl1
;
13436 /* Save the parm names or decls from this function's declarator
13437 where store_parm_decls will find them. */
13438 current_function_parms
= DECL_ARGUMENTS (decl1
);
13440 /* Make sure the parameter and return types are reasonable. When
13441 you declare a function, these types can be incomplete, but they
13442 must be complete when you define the function. */
13443 check_function_type (decl1
, current_function_parms
);
13445 /* Build the return declaration for the function. */
13446 restype
= TREE_TYPE (fntype
);
13448 if (DECL_RESULT (decl1
) == NULL_TREE
)
13452 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13453 DECL_ARTIFICIAL (resdecl
) = 1;
13454 DECL_IGNORED_P (resdecl
) = 1;
13455 DECL_RESULT (decl1
) = resdecl
;
13457 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13460 /* Let the user know we're compiling this function. */
13461 announce_function (decl1
);
13463 /* Record the decl so that the function name is defined.
13464 If we already have a decl for this name, and it is a FUNCTION_DECL,
13465 use the old decl. */
13466 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13468 /* A specialization is not used to guide overload resolution. */
13469 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13470 && !(DECL_USE_TEMPLATE (decl1
) &&
13471 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13473 tree olddecl
= pushdecl (decl1
);
13475 if (olddecl
== error_mark_node
)
13476 /* If something went wrong when registering the declaration,
13477 use DECL1; we have to have a FUNCTION_DECL to use when
13478 parsing the body of the function. */
13482 /* Otherwise, OLDDECL is either a previous declaration
13483 of the same function or DECL1 itself. */
13485 if (warn_missing_declarations
13486 && olddecl
== decl1
13487 && !DECL_MAIN_P (decl1
)
13488 && TREE_PUBLIC (decl1
)
13489 && !DECL_DECLARED_INLINE_P (decl1
))
13493 /* Check whether DECL1 is in an anonymous
13495 for (context
= DECL_CONTEXT (decl1
);
13497 context
= DECL_CONTEXT (context
))
13499 if (TREE_CODE (context
) == NAMESPACE_DECL
13500 && DECL_NAME (context
) == NULL_TREE
)
13504 if (context
== NULL
)
13505 warning (OPT_Wmissing_declarations
,
13506 "no previous declaration for %q+D", decl1
);
13514 /* We need to set the DECL_CONTEXT. */
13515 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13516 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13518 fntype
= TREE_TYPE (decl1
);
13519 restype
= TREE_TYPE (fntype
);
13521 /* If #pragma weak applies, mark the decl appropriately now.
13522 The pragma only applies to global functions. Because
13523 determining whether or not the #pragma applies involves
13524 computing the mangled name for the declaration, we cannot
13525 apply the pragma until after we have merged this declaration
13526 with any previous declarations; if the original declaration
13527 has a linkage specification, that specification applies to
13528 the definition as well, and may affect the mangled name. */
13529 if (DECL_FILE_SCOPE_P (decl1
))
13530 maybe_apply_pragma_weak (decl1
);
13533 /* Reset this in case the call to pushdecl changed it. */
13534 current_function_decl
= decl1
;
13536 gcc_assert (DECL_INITIAL (decl1
));
13538 /* This function may already have been parsed, in which case just
13539 return; our caller will skip over the body without parsing. */
13540 if (DECL_INITIAL (decl1
) != error_mark_node
)
13543 /* Initialize RTL machinery. We cannot do this until
13544 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13545 even when processing a template; this is how we get
13546 CFUN set up, and our per-function variables initialized.
13547 FIXME factor out the non-RTL stuff. */
13548 bl
= current_binding_level
;
13549 allocate_struct_function (decl1
, processing_template_decl
);
13551 /* Initialize the language data structures. Whenever we start
13552 a new function, we destroy temporaries in the usual way. */
13553 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
13554 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13555 current_binding_level
= bl
;
13557 if (!processing_template_decl
&& type_uses_auto (restype
))
13559 FNDECL_USED_AUTO (decl1
) = true;
13560 current_function_auto_return_pattern
= restype
;
13563 /* Start the statement-tree, start the tree now. */
13564 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13566 /* If we are (erroneously) defining a function that we have already
13567 defined before, wipe out what we knew before. */
13568 if (!DECL_PENDING_INLINE_P (decl1
))
13569 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13571 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13573 /* We know that this was set up by `grokclassfn'. We do not
13574 wait until `store_parm_decls', since evil parse errors may
13575 never get us to that point. Here we keep the consistency
13576 between `current_class_type' and `current_class_ptr'. */
13577 tree t
= DECL_ARGUMENTS (decl1
);
13579 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13580 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13582 cp_function_chain
->x_current_class_ref
13583 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13584 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13585 cp_function_chain
->x_current_class_ptr
= t
;
13587 /* Constructors and destructors need to know whether they're "in
13588 charge" of initializing virtual base classes. */
13589 t
= DECL_CHAIN (t
);
13590 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13592 current_in_charge_parm
= t
;
13593 t
= DECL_CHAIN (t
);
13595 if (DECL_HAS_VTT_PARM_P (decl1
))
13597 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13598 current_vtt_parm
= t
;
13602 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13603 /* Implicitly-defined methods (like the
13604 destructor for a class in which no destructor
13605 is explicitly declared) must not be defined
13606 until their definition is needed. So, we
13607 ignore interface specifications for
13608 compiler-generated functions. */
13609 && !DECL_ARTIFICIAL (decl1
));
13611 if (processing_template_decl
)
13612 /* Don't mess with interface flags. */;
13613 else if (DECL_INTERFACE_KNOWN (decl1
))
13615 tree ctx
= decl_function_context (decl1
);
13617 if (DECL_NOT_REALLY_EXTERN (decl1
))
13618 DECL_EXTERNAL (decl1
) = 0;
13620 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13621 /* This is a function in a local class in an extern inline
13622 or template function. */
13623 comdat_linkage (decl1
);
13625 /* If this function belongs to an interface, it is public.
13626 If it belongs to someone else's interface, it is also external.
13627 This only affects inlines and template instantiations. */
13628 else if (!finfo
->interface_unknown
&& honor_interface
)
13630 if (DECL_DECLARED_INLINE_P (decl1
)
13631 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13633 DECL_EXTERNAL (decl1
)
13634 = (finfo
->interface_only
13635 || (DECL_DECLARED_INLINE_P (decl1
)
13636 && ! flag_implement_inlines
13637 && !DECL_VINDEX (decl1
)));
13639 /* For WIN32 we also want to put these in linkonce sections. */
13640 maybe_make_one_only (decl1
);
13643 DECL_EXTERNAL (decl1
) = 0;
13644 DECL_INTERFACE_KNOWN (decl1
) = 1;
13645 /* If this function is in an interface implemented in this file,
13646 make sure that the back end knows to emit this function
13648 if (!DECL_EXTERNAL (decl1
))
13649 mark_needed (decl1
);
13651 else if (finfo
->interface_unknown
&& finfo
->interface_only
13652 && honor_interface
)
13654 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13655 interface, we will have both finfo->interface_unknown and
13656 finfo->interface_only set. In that case, we don't want to
13657 use the normal heuristics because someone will supply a
13658 #pragma implementation elsewhere, and deducing it here would
13659 produce a conflict. */
13660 comdat_linkage (decl1
);
13661 DECL_EXTERNAL (decl1
) = 0;
13662 DECL_INTERFACE_KNOWN (decl1
) = 1;
13663 DECL_DEFER_OUTPUT (decl1
) = 1;
13667 /* This is a definition, not a reference.
13668 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13669 if (!GNU_INLINE_P (decl1
))
13670 DECL_EXTERNAL (decl1
) = 0;
13672 if ((DECL_DECLARED_INLINE_P (decl1
)
13673 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13674 && ! DECL_INTERFACE_KNOWN (decl1
))
13675 DECL_DEFER_OUTPUT (decl1
) = 1;
13677 DECL_INTERFACE_KNOWN (decl1
) = 1;
13680 /* Determine the ELF visibility attribute for the function. We must not
13681 do this before calling "pushdecl", as we must allow "duplicate_decls"
13682 to merge any attributes appropriately. We also need to wait until
13684 if (!DECL_CLONED_FUNCTION_P (decl1
))
13685 determine_visibility (decl1
);
13687 if (!processing_template_decl
)
13688 maybe_instantiate_noexcept (decl1
);
13690 begin_scope (sk_function_parms
, decl1
);
13694 if (DECL_DESTRUCTOR_P (decl1
)
13695 || (DECL_CONSTRUCTOR_P (decl1
)
13696 && targetm
.cxx
.cdtor_returns_this ()))
13698 cdtor_label
= build_decl (input_location
,
13699 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13700 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13703 start_fname_decls ();
13705 store_parm_decls (current_function_parms
);
13711 /* Like start_preparsed_function, except that instead of a
13712 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13714 Returns true on success. If the DECLARATOR is not suitable
13715 for a function, we return false, which tells the parser to
13716 skip the entire function. */
13719 start_function (cp_decl_specifier_seq
*declspecs
,
13720 const cp_declarator
*declarator
,
13725 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13726 if (decl1
== error_mark_node
)
13728 /* If the declarator is not suitable for a function definition,
13729 cause a syntax error. */
13730 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13732 error ("invalid function declaration");
13736 if (DECL_MAIN_P (decl1
))
13737 /* main must return int. grokfndecl should have corrected it
13738 (and issued a diagnostic) if the user got it wrong. */
13739 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13740 integer_type_node
));
13742 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13745 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13749 use_eh_spec_block (tree fn
)
13751 return (flag_exceptions
&& flag_enforce_eh_specs
13752 && !processing_template_decl
13753 && !type_throw_all_p (TREE_TYPE (fn
))
13754 /* We insert the EH_SPEC_BLOCK only in the original
13755 function; then, it is copied automatically to the
13757 && !DECL_CLONED_FUNCTION_P (fn
)
13758 /* Implicitly-generated constructors and destructors have
13759 exception specifications. However, those specifications
13760 are the union of the possible exceptions specified by the
13761 constructors/destructors for bases and members, so no
13762 unallowed exception will ever reach this function. By
13763 not creating the EH_SPEC_BLOCK we save a little memory,
13764 and we avoid spurious warnings about unreachable
13766 && !DECL_DEFAULTED_FN (fn
));
13769 /* Store the parameter declarations into the current function declaration.
13770 This is called after parsing the parameter declarations, before
13771 digesting the body of the function.
13773 Also install to binding contour return value identifier, if any. */
13776 store_parm_decls (tree current_function_parms
)
13778 tree fndecl
= current_function_decl
;
13781 /* This is a chain of any other decls that came in among the parm
13782 declarations. If a parm is declared with enum {foo, bar} x;
13783 then CONST_DECLs for foo and bar are put here. */
13784 tree nonparms
= NULL_TREE
;
13786 if (current_function_parms
)
13788 /* This case is when the function was defined with an ANSI prototype.
13789 The parms already have decls, so we need not do anything here
13790 except record them as in effect
13791 and complain if any redundant old-style parm decls were written. */
13793 tree specparms
= current_function_parms
;
13796 /* Must clear this because it might contain TYPE_DECLs declared
13798 current_binding_level
->names
= NULL
;
13800 /* If we're doing semantic analysis, then we'll call pushdecl
13801 for each of these. We must do them in reverse order so that
13802 they end in the correct forward order. */
13803 specparms
= nreverse (specparms
);
13805 for (parm
= specparms
; parm
; parm
= next
)
13807 next
= DECL_CHAIN (parm
);
13808 if (TREE_CODE (parm
) == PARM_DECL
)
13810 if (DECL_NAME (parm
) == NULL_TREE
13811 || !VOID_TYPE_P (parm
))
13814 error ("parameter %qD declared void", parm
);
13818 /* If we find an enum constant or a type tag,
13819 put it aside for the moment. */
13820 TREE_CHAIN (parm
) = NULL_TREE
;
13821 nonparms
= chainon (nonparms
, parm
);
13825 /* Get the decls in their original chain order and record in the
13826 function. This is all and only the PARM_DECLs that were
13827 pushed into scope by the loop above. */
13828 DECL_ARGUMENTS (fndecl
) = getdecls ();
13831 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13833 /* Now store the final chain of decls for the arguments
13834 as the decl-chain of the current lexical scope.
13835 Put the enumerators in as well, at the front so that
13836 DECL_ARGUMENTS is not modified. */
13837 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13839 if (use_eh_spec_block (current_function_decl
))
13840 current_eh_spec_block
= begin_eh_spec_block ();
13844 /* We have finished doing semantic analysis on DECL, but have not yet
13845 generated RTL for its body. Save away our current state, so that
13846 when we want to generate RTL later we know what to do. */
13849 save_function_data (tree decl
)
13851 struct language_function
*f
;
13853 /* Save the language-specific per-function data so that we can
13854 get it back when we really expand this function. */
13855 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13858 f
= ggc_alloc
<language_function
> ();
13859 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13860 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13862 /* Clear out the bits we don't need. */
13863 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13864 f
->bindings
= NULL
;
13865 f
->x_local_names
= NULL
;
13866 f
->base
.local_typedefs
= NULL
;
13870 /* Set the return value of the constructor (if present). */
13873 finish_constructor_body (void)
13878 if (targetm
.cxx
.cdtor_returns_this ()
13879 && (! TYPE_FOR_JAVA (current_class_type
)))
13881 /* Any return from a constructor will end up here. */
13882 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13884 val
= DECL_ARGUMENTS (current_function_decl
);
13885 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13886 DECL_RESULT (current_function_decl
), val
);
13887 /* Return the address of the object. */
13888 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13889 add_stmt (exprstmt
);
13893 /* Do all the processing for the beginning of a destructor; set up the
13894 vtable pointers and cleanups for bases and members. */
13897 begin_destructor_body (void)
13899 tree compound_stmt
;
13901 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13902 issued an error message. We still want to try to process the
13903 body of the function, but initialize_vtbl_ptrs will crash if
13904 TYPE_BINFO is NULL. */
13905 if (COMPLETE_TYPE_P (current_class_type
))
13907 compound_stmt
= begin_compound_stmt (0);
13908 /* Make all virtual function table pointers in non-virtual base
13909 classes point to CURRENT_CLASS_TYPE's virtual function
13911 initialize_vtbl_ptrs (current_class_ptr
);
13912 finish_compound_stmt (compound_stmt
);
13914 /* Insert a cleanup to let the back end know that the object is dead
13915 when we exit the destructor, either normally or via exception. */
13916 tree btype
= CLASSTYPE_AS_BASE (current_class_type
);
13917 tree clobber
= build_constructor (btype
, NULL
);
13918 TREE_THIS_VOLATILE (clobber
) = true;
13919 tree bref
= build_nop (build_reference_type (btype
), current_class_ptr
);
13920 bref
= convert_from_reference (bref
);
13921 tree exprstmt
= build2 (MODIFY_EXPR
, btype
, bref
, clobber
);
13922 finish_decl_cleanup (NULL_TREE
, exprstmt
);
13924 /* And insert cleanups for our bases and members so that they
13925 will be properly destroyed if we throw. */
13926 push_base_cleanups ();
13930 /* At the end of every destructor we generate code to delete the object if
13931 necessary. Do that now. */
13934 finish_destructor_body (void)
13938 /* Any return from a destructor will end up here; that way all base
13939 and member cleanups will be run when the function returns. */
13940 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13942 /* In a virtual destructor, we must call delete. */
13943 if (DECL_VIRTUAL_P (current_function_decl
))
13946 tree virtual_size
= cxx_sizeof (current_class_type
);
13950 At the point of definition of a virtual destructor (including
13951 an implicit definition), non-placement operator delete shall
13952 be looked up in the scope of the destructor's class and if
13953 found shall be accessible and unambiguous. */
13954 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13956 /*global_p=*/false,
13957 /*placement=*/NULL_TREE
,
13958 /*alloc_fn=*/NULL_TREE
,
13959 tf_warning_or_error
);
13961 if_stmt
= begin_if_stmt ();
13962 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13963 current_in_charge_parm
,
13966 finish_expr_stmt (exprstmt
);
13967 finish_then_clause (if_stmt
);
13968 finish_if_stmt (if_stmt
);
13971 if (targetm
.cxx
.cdtor_returns_this ())
13975 val
= DECL_ARGUMENTS (current_function_decl
);
13976 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13977 DECL_RESULT (current_function_decl
), val
);
13978 /* Return the address of the object. */
13979 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13980 add_stmt (exprstmt
);
13984 /* Do the necessary processing for the beginning of a function body, which
13985 in this case includes member-initializers, but not the catch clauses of
13986 a function-try-block. Currently, this means opening a binding level
13987 for the member-initializers (in a ctor), member cleanups (in a dtor),
13988 and capture proxies (in a lambda operator()). */
13991 begin_function_body (void)
13995 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13998 if (processing_template_decl
)
13999 /* Do nothing now. */;
14001 /* Always keep the BLOCK node associated with the outermost pair of
14002 curly braces of a function. These are needed for correct
14003 operation of dwarfout.c. */
14004 keep_next_level (true);
14006 stmt
= begin_compound_stmt (BCS_FN_BODY
);
14008 if (processing_template_decl
)
14009 /* Do nothing now. */;
14010 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14011 begin_destructor_body ();
14016 /* Do the processing for the end of a function body. Currently, this means
14017 closing out the cleanups for fully-constructed bases and members, and in
14018 the case of the destructor, deleting the object if desired. Again, this
14019 is only meaningful for [cd]tors, since they are the only functions where
14020 there is a significant distinction between the main body and any
14021 function catch clauses. Handling, say, main() return semantics here
14022 would be wrong, as flowing off the end of a function catch clause for
14023 main() would also need to return 0. */
14026 finish_function_body (tree compstmt
)
14028 if (compstmt
== NULL_TREE
)
14031 /* Close the block. */
14032 finish_compound_stmt (compstmt
);
14034 if (processing_template_decl
)
14035 /* Do nothing now. */;
14036 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
14037 finish_constructor_body ();
14038 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14039 finish_destructor_body ();
14042 /* Given a function, returns the BLOCK corresponding to the outermost level
14043 of curly braces, skipping the artificial block created for constructor
14047 outer_curly_brace_block (tree fndecl
)
14049 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
14050 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
14051 /* Skip the artificial function body block. */
14052 block
= BLOCK_SUBBLOCKS (block
);
14056 /* If FNDECL is a class's key method, add the class to the list of
14057 keyed classes that should be emitted. */
14060 record_key_method_defined (tree fndecl
)
14062 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
14063 && DECL_VIRTUAL_P (fndecl
)
14064 && !processing_template_decl
)
14066 tree fnclass
= DECL_CONTEXT (fndecl
);
14067 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
14068 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
14072 /* Subroutine of finish_function.
14073 Save the body of constexpr functions for possible
14074 future compile time evaluation. */
14077 maybe_save_function_definition (tree fun
)
14079 if (!processing_template_decl
14080 && DECL_DECLARED_CONSTEXPR_P (fun
)
14081 && !cp_function_chain
->invalid_constexpr
14082 && !DECL_CLONED_FUNCTION_P (fun
))
14083 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
14086 /* Finish up a function declaration and compile that function
14087 all the way to assembler language output. The free the storage
14088 for the function definition.
14090 FLAGS is a bitwise or of the following values:
14092 We just finished processing the body of an in-class inline
14093 function definition. (This processing will have taken place
14094 after the class definition is complete.) */
14097 finish_function (int flags
)
14099 tree fndecl
= current_function_decl
;
14100 tree fntype
, ctype
= NULL_TREE
;
14101 int inclass_inline
= (flags
& 2) != 0;
14103 /* When we get some parse errors, we can end up without a
14104 current_function_decl, so cope. */
14105 if (fndecl
== NULL_TREE
)
14106 return error_mark_node
;
14108 if (c_dialect_objc ())
14109 objc_finish_function ();
14111 gcc_assert (!defer_mark_used_calls
);
14112 defer_mark_used_calls
= true;
14114 record_key_method_defined (fndecl
);
14116 fntype
= TREE_TYPE (fndecl
);
14118 /* TREE_READONLY (fndecl) = 1;
14119 This caused &foo to be of type ptr-to-const-function
14120 which then got a warning when stored in a ptr-to-function variable. */
14122 gcc_assert (building_stmt_list_p ());
14123 /* The current function is being defined, so its DECL_INITIAL should
14124 be set, and unless there's a multiple definition, it should be
14125 error_mark_node. */
14126 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
14128 /* For a cloned function, we've already got all the code we need;
14129 there's no need to add any extra bits. */
14130 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14132 /* Make it so that `main' always returns 0 by default. */
14133 if (DECL_MAIN_P (current_function_decl
))
14134 finish_return_stmt (integer_zero_node
);
14136 if (use_eh_spec_block (current_function_decl
))
14137 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14138 (TREE_TYPE (current_function_decl
)),
14139 current_eh_spec_block
);
14142 /* If we're saving up tree structure, tie off the function now. */
14143 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
14145 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
14146 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
14148 finish_fname_decls ();
14150 /* If this function can't throw any exceptions, remember that. */
14151 if (!processing_template_decl
14152 && !cp_function_chain
->can_throw
14153 && !flag_non_call_exceptions
14154 && !decl_replaceable_p (fndecl
))
14155 TREE_NOTHROW (fndecl
) = 1;
14157 /* This must come after expand_function_end because cleanups might
14158 have declarations (from inline functions) that need to go into
14159 this function's blocks. */
14161 /* If the current binding level isn't the outermost binding level
14162 for this function, either there is a bug, or we have experienced
14163 syntax errors and the statement tree is malformed. */
14164 if (current_binding_level
->kind
!= sk_function_parms
)
14166 /* Make sure we have already experienced errors. */
14167 gcc_assert (errorcount
);
14169 /* Throw away the broken statement tree and extra binding
14171 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
14173 while (current_binding_level
->kind
!= sk_function_parms
)
14175 if (current_binding_level
->kind
== sk_class
)
14176 pop_nested_class ();
14178 poplevel (0, 0, 0);
14181 poplevel (1, 0, 1);
14183 /* Statements should always be full-expressions at the outermost set
14184 of curly braces for a function. */
14185 gcc_assert (stmts_are_full_exprs_p ());
14187 /* If there are no return statements in a function with auto return type,
14188 the return type is void. But if the declared type is something like
14189 auto*, this is an error. */
14190 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
14191 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
14193 if (!is_auto (current_function_auto_return_pattern
)
14194 && !current_function_returns_value
&& !current_function_returns_null
)
14196 error ("no return statements in function returning %qT",
14197 current_function_auto_return_pattern
);
14198 inform (input_location
, "only plain %<auto%> return type can be "
14199 "deduced to %<void%>");
14201 apply_deduced_return_type (fndecl
, void_type_node
);
14202 fntype
= TREE_TYPE (fndecl
);
14205 /* Save constexpr function body before it gets munged by
14206 the NRV transformation. */
14207 maybe_save_function_definition (fndecl
);
14209 /* Set up the named return value optimization, if we can. Candidate
14210 variables are selected in check_return_expr. */
14211 if (current_function_return_value
)
14213 tree r
= current_function_return_value
;
14216 if (r
!= error_mark_node
14217 /* This is only worth doing for fns that return in memory--and
14218 simpler, since we don't have to worry about promoted modes. */
14219 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
14220 /* Only allow this for variables declared in the outer scope of
14221 the function so we know that their lifetime always ends with a
14222 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14223 we were to do this optimization in tree-ssa. */
14224 && (outer
= outer_curly_brace_block (fndecl
))
14225 && chain_member (r
, BLOCK_VARS (outer
)))
14226 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
14228 current_function_return_value
= NULL_TREE
;
14231 /* Remember that we were in class scope. */
14232 if (current_class_name
)
14233 ctype
= current_class_type
;
14235 /* Must mark the RESULT_DECL as being in this function. */
14236 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14238 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14239 to the FUNCTION_DECL node itself. */
14240 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14242 /* Save away current state, if appropriate. */
14243 if (!processing_template_decl
)
14244 save_function_data (fndecl
);
14246 /* Complain if there's just no return statement. */
14247 if (warn_return_type
14248 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14249 && !dependent_type_p (TREE_TYPE (fntype
))
14250 && !current_function_returns_value
&& !current_function_returns_null
14251 /* Don't complain if we abort or throw. */
14252 && !current_function_returns_abnormally
14253 /* Don't complain if there's an infinite loop. */
14254 && !current_function_infinite_loop
14255 /* Don't complain if we are declared noreturn. */
14256 && !TREE_THIS_VOLATILE (fndecl
)
14257 && !DECL_NAME (DECL_RESULT (fndecl
))
14258 && !TREE_NO_WARNING (fndecl
)
14259 /* Structor return values (if any) are set by the compiler. */
14260 && !DECL_CONSTRUCTOR_P (fndecl
)
14261 && !DECL_DESTRUCTOR_P (fndecl
)
14262 && targetm
.warn_func_return (fndecl
))
14264 warning (OPT_Wreturn_type
,
14265 "no return statement in function returning non-void");
14266 TREE_NO_WARNING (fndecl
) = 1;
14269 /* Store the end of the function, so that we get good line number
14270 info for the epilogue. */
14271 cfun
->function_end_locus
= input_location
;
14273 /* Complain about parameters that are only set, but never otherwise used. */
14274 if (warn_unused_but_set_parameter
14275 && !processing_template_decl
14276 && errorcount
== unused_but_set_errorcount
14277 && !DECL_CLONED_FUNCTION_P (fndecl
))
14281 for (decl
= DECL_ARGUMENTS (fndecl
);
14283 decl
= DECL_CHAIN (decl
))
14284 if (TREE_USED (decl
)
14285 && TREE_CODE (decl
) == PARM_DECL
14286 && !DECL_READ_P (decl
)
14287 && DECL_NAME (decl
)
14288 && !DECL_ARTIFICIAL (decl
)
14289 && !TREE_NO_WARNING (decl
)
14290 && !DECL_IN_SYSTEM_HEADER (decl
)
14291 && TREE_TYPE (decl
) != error_mark_node
14292 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14293 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14294 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14295 warning (OPT_Wunused_but_set_parameter
,
14296 "parameter %q+D set but not used", decl
);
14297 unused_but_set_errorcount
= errorcount
;
14300 /* Complain about locally defined typedefs that are not used in this
14302 maybe_warn_unused_local_typedefs ();
14304 /* Genericize before inlining. */
14305 if (!processing_template_decl
)
14307 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14308 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14309 cp_genericize (fndecl
);
14310 /* Clear out the bits we don't need. */
14311 f
->x_current_class_ptr
= NULL
;
14312 f
->x_current_class_ref
= NULL
;
14313 f
->x_eh_spec_block
= NULL
;
14314 f
->x_in_charge_parm
= NULL
;
14315 f
->x_vtt_parm
= NULL
;
14316 f
->x_return_value
= NULL
;
14317 f
->bindings
= NULL
;
14318 f
->extern_decl_map
= NULL
;
14319 f
->infinite_loops
= NULL
;
14321 /* Clear out the bits we don't need. */
14322 local_names
= NULL
;
14324 /* We're leaving the context of this function, so zap cfun. It's still in
14325 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14327 current_function_decl
= NULL
;
14329 /* If this is an in-class inline definition, we may have to pop the
14330 bindings for the template parameters that we added in
14331 maybe_begin_member_template_processing when start_function was
14333 if (inclass_inline
)
14334 maybe_end_member_template_processing ();
14336 /* Leave the scope of the class. */
14338 pop_nested_class ();
14343 current_function_decl
= NULL_TREE
;
14345 defer_mark_used_calls
= false;
14346 if (deferred_mark_used_calls
)
14351 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14353 vec_free (deferred_mark_used_calls
);
14359 /* Create the FUNCTION_DECL for a function definition.
14360 DECLSPECS and DECLARATOR are the parts of the declaration;
14361 they describe the return type and the name of the function,
14362 but twisted together in a fashion that parallels the syntax of C.
14364 This function creates a binding context for the function body
14365 as well as setting up the FUNCTION_DECL in current_function_decl.
14367 Returns a FUNCTION_DECL on success.
14369 If the DECLARATOR is not suitable for a function (it defines a datum
14370 instead), we return 0, which tells yyparse to report a parse error.
14372 May return void_type_node indicating that this method is actually
14373 a friend. See grokfield for more details.
14375 Came here with a `.pushlevel' .
14377 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14378 CHANGES TO CODE IN `grokfield'. */
14381 grokmethod (cp_decl_specifier_seq
*declspecs
,
14382 const cp_declarator
*declarator
, tree attrlist
)
14384 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14387 if (fndecl
== error_mark_node
)
14388 return error_mark_node
;
14390 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14392 error ("invalid member function declaration");
14393 return error_mark_node
;
14397 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14399 /* Pass friends other than inline friend functions back. */
14400 if (fndecl
== void_type_node
)
14403 if (DECL_IN_AGGR_P (fndecl
))
14405 if (DECL_CLASS_SCOPE_P (fndecl
))
14406 error ("%qD is already defined in class %qT", fndecl
,
14407 DECL_CONTEXT (fndecl
));
14408 return error_mark_node
;
14411 check_template_shadow (fndecl
);
14413 DECL_COMDAT (fndecl
) = 1;
14414 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14415 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14417 /* We process method specializations in finish_struct_1. */
14418 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14420 fndecl
= push_template_decl (fndecl
);
14421 if (fndecl
== error_mark_node
)
14425 if (! DECL_FRIEND_P (fndecl
))
14427 if (DECL_CHAIN (fndecl
))
14429 fndecl
= copy_node (fndecl
);
14430 TREE_CHAIN (fndecl
) = NULL_TREE
;
14434 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14436 DECL_IN_AGGR_P (fndecl
) = 1;
14441 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14442 we can lay it out later, when and if its type becomes complete.
14444 Also handle constexpr variables where the initializer involves
14445 an unlowered PTRMEM_CST because the class isn't complete yet. */
14448 maybe_register_incomplete_var (tree var
)
14450 gcc_assert (VAR_P (var
));
14452 /* Keep track of variables with incomplete types. */
14453 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14454 && DECL_EXTERNAL (var
))
14456 tree inner_type
= TREE_TYPE (var
);
14458 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14459 inner_type
= TREE_TYPE (inner_type
);
14460 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14462 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14463 /* RTTI TD entries are created while defining the type_info. */
14464 || (TYPE_LANG_SPECIFIC (inner_type
)
14465 && TYPE_BEING_DEFINED (inner_type
)))
14467 incomplete_var iv
= {var
, inner_type
};
14468 vec_safe_push (incomplete_vars
, iv
);
14470 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
14471 && decl_constant_var_p (var
)
14472 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
14474 /* When the outermost open class is complete we can resolve any
14475 pointers-to-members. */
14476 tree context
= outermost_open_class ();
14477 incomplete_var iv
= {var
, context
};
14478 vec_safe_push (incomplete_vars
, iv
);
14483 /* Called when a class type (given by TYPE) is defined. If there are
14484 any existing VAR_DECLs whose type has been completed by this
14485 declaration, update them now. */
14488 complete_vars (tree type
)
14491 incomplete_var
*iv
;
14493 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14495 if (same_type_p (type
, iv
->incomplete_type
))
14497 tree var
= iv
->decl
;
14498 tree type
= TREE_TYPE (var
);
14500 if (TYPE_MAIN_VARIANT (strip_array_types (type
))
14501 == iv
->incomplete_type
)
14503 /* Complete the type of the variable. The VAR_DECL itself
14504 will be laid out in expand_expr. */
14505 complete_type (type
);
14506 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14509 if (DECL_INITIAL (var
)
14510 && decl_constant_var_p (var
))
14511 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14513 /* Remove this entry from the list. */
14514 incomplete_vars
->unordered_remove (ix
);
14520 /* Check for pending declarations which may have abstract type. */
14521 complete_type_check_abstract (type
);
14524 /* If DECL is of a type which needs a cleanup, build and return an
14525 expression to perform that cleanup here. Return NULL_TREE if no
14526 cleanup need be done. */
14529 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14535 /* Assume no cleanup is required. */
14536 cleanup
= NULL_TREE
;
14538 if (error_operand_p (decl
))
14541 /* Handle "__attribute__((cleanup))". We run the cleanup function
14542 before the destructor since the destructor is what actually
14543 terminates the lifetime of the object. */
14544 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14551 /* Get the name specified by the user for the cleanup function. */
14552 id
= TREE_VALUE (TREE_VALUE (attr
));
14553 /* Look up the name to find the cleanup function to call. It is
14554 important to use lookup_name here because that is what is
14555 used in c-common.c:handle_cleanup_attribute when performing
14556 initial checks on the attribute. Note that those checks
14557 include ensuring that the function found is not an overloaded
14558 function, or an object with an overloaded call operator,
14559 etc.; we can rely on the fact that the function found is an
14560 ordinary FUNCTION_DECL. */
14561 fn
= lookup_name (id
);
14562 arg
= build_address (decl
);
14564 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14565 if (cleanup
== error_mark_node
)
14566 return error_mark_node
;
14568 /* Handle ordinary C++ destructors. */
14569 type
= TREE_TYPE (decl
);
14570 if (type_build_dtor_call (type
))
14572 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14576 if (TREE_CODE (type
) == ARRAY_TYPE
)
14579 addr
= build_address (decl
);
14581 call
= build_delete (TREE_TYPE (addr
), addr
,
14582 sfk_complete_destructor
, flags
, 0, complain
);
14583 if (call
== error_mark_node
)
14584 cleanup
= error_mark_node
;
14585 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14586 /* Discard the call. */;
14588 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14593 /* build_delete sets the location of the destructor call to the
14594 current location, even though the destructor is going to be
14595 called later, at the end of the current scope. This can lead to
14596 a "jumpy" behaviour for users of debuggers when they step around
14597 the end of the block. So let's unset the location of the
14598 destructor call instead. */
14599 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14600 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14603 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
))))
14604 /* Treat objects with destructors as used; the destructor may do
14605 something substantive. */
14612 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14613 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14614 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14617 static_fn_type (tree memfntype
)
14622 if (TYPE_PTRMEMFUNC_P (memfntype
))
14623 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14624 if (POINTER_TYPE_P (memfntype
)
14625 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14626 memfntype
= TREE_TYPE (memfntype
);
14627 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14629 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14630 args
= TYPE_ARG_TYPES (memfntype
);
14631 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14632 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14633 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14634 fntype
= (cp_build_type_attribute_variant
14635 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14636 fntype
= (build_exception_variant
14637 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14638 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
14639 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
14643 /* DECL was originally constructed as a non-static member function,
14644 but turned out to be static. Update it accordingly. */
14647 revert_static_member_fn (tree decl
)
14649 tree stype
= static_fn_type (decl
);
14650 cp_cv_quals quals
= type_memfn_quals (stype
);
14651 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14653 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14654 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14656 TREE_TYPE (decl
) = stype
;
14658 if (DECL_ARGUMENTS (decl
))
14659 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14660 DECL_STATIC_FUNCTION_P (decl
) = 1;
14663 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14664 one of the language-independent trees. */
14666 enum cp_tree_node_structure_enum
14667 cp_tree_node_structure (union lang_tree_node
* t
)
14669 switch (TREE_CODE (&t
->generic
))
14671 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14672 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14673 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14674 case OVERLOAD
: return TS_CP_OVERLOAD
;
14675 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14676 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14677 case BASELINK
: return TS_CP_BASELINK
;
14678 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
14679 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14680 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14681 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14682 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14683 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14684 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14685 default: return TS_CP_GENERIC
;
14689 /* Build the void_list_node (void_type_node having been created). */
14691 build_void_list_node (void)
14693 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14698 cp_missing_noreturn_ok_p (tree decl
)
14700 /* A missing noreturn is ok for the `main' function. */
14701 return DECL_MAIN_P (decl
);
14704 /* Return the decl used to identify the COMDAT group into which DECL should
14708 cxx_comdat_group (tree decl
)
14710 /* Virtual tables, construction virtual tables, and virtual table
14711 tables all go in a single COMDAT group, named after the primary
14713 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14714 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
14715 /* For all other DECLs, the COMDAT group is the mangled name of the
14716 declaration itself. */
14719 while (DECL_THUNK_P (decl
))
14721 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14722 into the same section as the target function. In that case
14723 we must return target's name. */
14724 tree target
= THUNK_TARGET (decl
);
14725 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14726 && DECL_SECTION_NAME (target
) != NULL
14727 && DECL_ONE_ONLY (target
))
14737 /* Returns the return type for FN as written by the user, which may include
14738 a placeholder for a deduced return type. */
14741 fndecl_declared_return_type (tree fn
)
14743 fn
= STRIP_TEMPLATE (fn
);
14744 if (FNDECL_USED_AUTO (fn
))
14746 struct language_function
*f
= NULL
;
14747 if (DECL_STRUCT_FUNCTION (fn
))
14748 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
14750 f
= DECL_SAVED_FUNCTION_DATA (fn
);
14751 return f
->x_auto_return_pattern
;
14753 return TREE_TYPE (TREE_TYPE (fn
));
14756 /* Returns true iff DECL was declared with an auto return type and it has
14757 not yet been deduced to a real type. */
14760 undeduced_auto_decl (tree decl
)
14762 if (cxx_dialect
< cxx14
)
14764 return type_uses_auto (TREE_TYPE (decl
));
14767 /* Complain if DECL has an undeduced return type. */
14770 require_deduced_type (tree decl
)
14772 if (undeduced_auto_decl (decl
))
14773 error ("use of %qD before deduction of %<auto%>", decl
);
14776 #include "gt-cp-decl.h"