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 || !(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 (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 (flag_sanitize
& SANITIZE_VLA
8589 && current_function_decl
!= NULL_TREE
8590 && !lookup_attribute ("no_sanitize_undefined",
8592 (current_function_decl
)))
8594 /* We have to add 1 -- in the ubsan routine we generate
8595 LE_EXPR rather than LT_EXPR. */
8596 tree t
= fold_build2 (PLUS_EXPR
, TREE_TYPE (itype
), itype
,
8597 build_one_cst (TREE_TYPE (itype
)));
8598 t
= ubsan_instrument_vla (input_location
, t
);
8599 finish_expr_stmt (t
);
8602 /* Make sure that there was no overflow when creating to a signed
8603 index type. (For example, on a 32-bit machine, an array with
8604 size 2^32 - 1 is too big.) */
8605 else if (TREE_CODE (itype
) == INTEGER_CST
8606 && TREE_OVERFLOW (itype
))
8608 if (!(complain
& tf_error
))
8609 return error_mark_node
;
8610 error ("overflow in array dimension");
8611 TREE_OVERFLOW (itype
) = 0;
8615 /* Create and return the appropriate index type. */
8616 itype
= build_index_type (itype
);
8618 /* If the index type were dependent, we would have returned early, so
8619 remember that it isn't. */
8620 TYPE_DEPENDENT_P (itype
) = 0;
8621 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8625 /* Returns the scope (if any) in which the entity declared by
8626 DECLARATOR will be located. If the entity was declared with an
8627 unqualified name, NULL_TREE is returned. */
8630 get_scope_of_declarator (const cp_declarator
*declarator
)
8632 while (declarator
&& declarator
->kind
!= cdk_id
)
8633 declarator
= declarator
->declarator
;
8635 /* If the declarator-id is a SCOPE_REF, the scope in which the
8636 declaration occurs is the first operand. */
8638 && declarator
->u
.id
.qualifying_scope
)
8639 return declarator
->u
.id
.qualifying_scope
;
8641 /* Otherwise, the declarator is not a qualified name; the entity will
8642 be declared in the current scope. */
8646 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8647 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8651 create_array_type_for_decl (tree name
, tree type
, tree size
)
8653 tree itype
= NULL_TREE
;
8655 /* If things have already gone awry, bail now. */
8656 if (type
== error_mark_node
|| size
== error_mark_node
)
8657 return error_mark_node
;
8659 /* 8.3.4/1: If the type of the identifier of D contains the auto
8660 type-specifier, the program is ill-formed. */
8661 if (type_uses_auto (type
))
8663 error ("%qD declared as array of %qT", name
, type
);
8664 return error_mark_node
;
8667 /* If there are some types which cannot be array elements,
8668 issue an error-message and return. */
8669 switch (TREE_CODE (type
))
8673 error ("declaration of %qD as array of void", name
);
8675 error ("creating array of void");
8676 return error_mark_node
;
8680 error ("declaration of %qD as array of functions", name
);
8682 error ("creating array of functions");
8683 return error_mark_node
;
8685 case REFERENCE_TYPE
:
8687 error ("declaration of %qD as array of references", name
);
8689 error ("creating array of references");
8690 return error_mark_node
;
8694 error ("declaration of %qD as array of function members", name
);
8696 error ("creating array of function members");
8697 return error_mark_node
;
8705 The constant expressions that specify the bounds of the arrays
8706 can be omitted only for the first member of the sequence. */
8707 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8710 error ("declaration of %qD as multidimensional array must "
8711 "have bounds for all dimensions except the first",
8714 error ("multidimensional array must have bounds for all "
8715 "dimensions except the first");
8717 return error_mark_node
;
8720 /* Figure out the index type for the array. */
8722 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8725 T is called the array element type; this type shall not be [...] an
8726 abstract class type. */
8727 abstract_virtuals_error (name
, type
);
8729 return build_cplus_array_type (type
, itype
);
8732 /* Check that it's OK to declare a function with the indicated TYPE.
8733 SFK indicates the kind of special function (if any) that this
8734 function is. OPTYPE is the type given in a conversion operator
8735 declaration, or the class type for a constructor/destructor.
8736 Returns the actual return type of the function; that
8737 may be different than TYPE if an error occurs, or for certain
8738 special functions. */
8741 check_special_function_return_type (special_function_kind sfk
,
8747 case sfk_constructor
:
8749 error ("return type specification for constructor invalid");
8751 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8752 type
= build_pointer_type (optype
);
8754 type
= void_type_node
;
8757 case sfk_destructor
:
8759 error ("return type specification for destructor invalid");
8760 /* We can't use the proper return type here because we run into
8761 problems with ambiguous bases and covariant returns.
8762 Java classes are left unchanged because (void *) isn't a valid
8763 Java type, and we don't want to change the Java ABI. */
8764 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8765 type
= build_pointer_type (void_type_node
);
8767 type
= void_type_node
;
8770 case sfk_conversion
:
8772 error ("return type specified for %<operator %T%>", optype
);
8783 /* A variable or data member (whose unqualified name is IDENTIFIER)
8784 has been declared with the indicated TYPE. If the TYPE is not
8785 acceptable, issue an error message and return a type to use for
8786 error-recovery purposes. */
8789 check_var_type (tree identifier
, tree type
)
8791 if (VOID_TYPE_P (type
))
8794 error ("unnamed variable or field declared void");
8795 else if (identifier_p (identifier
))
8797 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8798 error ("variable or field %qE declared void", identifier
);
8801 error ("variable or field declared void");
8802 type
= error_mark_node
;
8808 /* Given declspecs and a declarator (abstract or otherwise), determine
8809 the name and type of the object declared and construct a DECL node
8812 DECLSPECS points to the representation of declaration-specifier
8813 sequence that precedes declarator.
8815 DECL_CONTEXT says which syntactic context this declaration is in:
8816 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8817 FUNCDEF for a function definition. Like NORMAL but a few different
8818 error messages in each case. Return value may be zero meaning
8819 this definition is too screwy to try to parse.
8820 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8821 handle member functions (which have FIELD context).
8822 Return value may be zero meaning this definition is too screwy to
8824 PARM for a parameter declaration (either within a function prototype
8825 or before a function body). Make a PARM_DECL, or return void_type_node.
8826 TPARM for a template parameter declaration.
8827 CATCHPARM for a parameter declaration before a catch clause.
8828 TYPENAME if for a typename (in a cast or sizeof).
8829 Don't make a DECL node; just return the ..._TYPE node.
8830 FIELD for a struct or union field; make a FIELD_DECL.
8831 BITFIELD for a field with specified width.
8833 INITIALIZED is as for start_decl.
8835 ATTRLIST is a pointer to the list of attributes, which may be NULL
8836 if there are none; *ATTRLIST may be modified if attributes from inside
8837 the declarator should be applied to the declaration.
8839 When this function is called, scoping variables (such as
8840 CURRENT_CLASS_TYPE) should reflect the scope in which the
8841 declaration occurs, not the scope in which the new declaration will
8842 be placed. For example, on:
8846 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8849 Returns a DECL (if a declarator is present), a TYPE (if there is no
8850 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8854 grokdeclarator (const cp_declarator
*declarator
,
8855 cp_decl_specifier_seq
*declspecs
,
8856 enum decl_context decl_context
,
8860 tree type
= NULL_TREE
;
8862 int explicit_intN
= 0;
8863 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8864 int explicit_int
= 0;
8865 int explicit_char
= 0;
8866 int defaulted_int
= 0;
8868 tree typedef_decl
= NULL_TREE
;
8869 const char *name
= NULL
;
8870 tree typedef_type
= NULL_TREE
;
8871 /* True if this declarator is a function definition. */
8872 bool funcdef_flag
= false;
8873 cp_declarator_kind innermost_code
= cdk_error
;
8876 /* See the code below that used this. */
8877 tree decl_attr
= NULL_TREE
;
8880 /* Keep track of what sort of function is being processed
8881 so that we can warn about default return values, or explicit
8882 return values which do not match prescribed defaults. */
8883 special_function_kind sfk
= sfk_none
;
8885 tree dname
= NULL_TREE
;
8886 tree ctor_return_type
= NULL_TREE
;
8887 enum overload_flags flags
= NO_SPECIAL
;
8888 /* cv-qualifiers that apply to the declarator, for a declaration of
8889 a member function. */
8890 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8891 /* virt-specifiers that apply to the declarator, for a declaration of
8892 a member function. */
8893 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8894 /* ref-qualifier that applies to the declarator, for a declaration of
8895 a member function. */
8896 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
8897 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8899 tree raises
= NULL_TREE
;
8900 int template_count
= 0;
8901 tree returned_attrs
= NULL_TREE
;
8902 tree parms
= NULL_TREE
;
8903 const cp_declarator
*id_declarator
;
8904 /* The unqualified name of the declarator; either an
8905 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8906 tree unqualified_id
;
8907 /* The class type, if any, in which this entity is located,
8908 or NULL_TREE if none. Note that this value may be different from
8909 the current class type; for example if an attempt is made to declare
8910 "A::f" inside "B", this value will be "A". */
8911 tree ctype
= current_class_type
;
8912 /* The NAMESPACE_DECL for the namespace in which this entity is
8913 located. If an unqualified name is used to declare the entity,
8914 this value will be NULL_TREE, even if the entity is located at
8916 tree in_namespace
= NULL_TREE
;
8917 cp_storage_class storage_class
;
8918 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8919 bool type_was_error_mark_node
= false;
8920 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8921 bool template_type_arg
= false;
8922 bool template_parm_flag
= false;
8923 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
8924 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8925 bool late_return_type_p
= false;
8926 bool array_parameter_p
= false;
8927 source_location saved_loc
= input_location
;
8930 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8931 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8932 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8933 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8934 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8935 explicit_intN
= declspecs
->explicit_intN_p
;
8936 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8938 if (decl_context
== FUNCDEF
)
8939 funcdef_flag
= true, decl_context
= NORMAL
;
8940 else if (decl_context
== MEMFUNCDEF
)
8941 funcdef_flag
= true, decl_context
= FIELD
;
8942 else if (decl_context
== BITFIELD
)
8943 bitfield
= 1, decl_context
= FIELD
;
8944 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8945 template_type_arg
= true, decl_context
= TYPENAME
;
8946 else if (decl_context
== TPARM
)
8947 template_parm_flag
= true, decl_context
= PARM
;
8949 if (initialized
> 1)
8950 funcdef_flag
= true;
8952 /* Look inside a declarator for the name being declared
8953 and get it as a string, for an error message. */
8954 for (id_declarator
= declarator
;
8956 id_declarator
= id_declarator
->declarator
)
8958 if (id_declarator
->kind
!= cdk_id
)
8959 innermost_code
= id_declarator
->kind
;
8961 switch (id_declarator
->kind
)
8964 if (id_declarator
->declarator
8965 && id_declarator
->declarator
->kind
== cdk_id
)
8967 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8968 if (sfk
== sfk_destructor
)
8975 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8976 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8979 if (qualifying_scope
)
8981 if (at_function_scope_p ())
8985 A declarator-id shall not be qualified except
8988 None of the cases are permitted in block
8990 if (qualifying_scope
== global_namespace
)
8991 error ("invalid use of qualified-name %<::%D%>",
8993 else if (TYPE_P (qualifying_scope
))
8994 error ("invalid use of qualified-name %<%T::%D%>",
8995 qualifying_scope
, decl
);
8997 error ("invalid use of qualified-name %<%D::%D%>",
8998 qualifying_scope
, decl
);
8999 return error_mark_node
;
9001 else if (TYPE_P (qualifying_scope
))
9003 ctype
= qualifying_scope
;
9004 if (!MAYBE_CLASS_TYPE_P (ctype
))
9006 error ("%q#T is not a class or a namespace", ctype
);
9009 else if (innermost_code
!= cdk_function
9010 && current_class_type
9011 && !uniquely_derived_from_p (ctype
,
9012 current_class_type
))
9014 error ("invalid use of qualified-name %<%T::%D%>",
9015 qualifying_scope
, decl
);
9016 return error_mark_node
;
9019 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
9020 in_namespace
= qualifying_scope
;
9022 switch (TREE_CODE (decl
))
9028 if (innermost_code
!= cdk_function
)
9030 error ("declaration of %qD as non-function", decl
);
9031 return error_mark_node
;
9033 else if (!qualifying_scope
9034 && !(current_class_type
&& at_class_scope_p ()))
9036 error ("declaration of %qD as non-member", decl
);
9037 return error_mark_node
;
9040 type
= TREE_OPERAND (decl
, 0);
9042 type
= constructor_name (type
);
9043 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
9048 case TEMPLATE_ID_EXPR
:
9050 tree fns
= TREE_OPERAND (decl
, 0);
9053 if (!identifier_p (dname
))
9055 if (variable_template_p (dname
))
9056 dname
= DECL_NAME (dname
);
9059 gcc_assert (is_overloaded_fn (dname
));
9060 dname
= DECL_NAME (get_first_fn (dname
));
9066 case IDENTIFIER_NODE
:
9067 if (identifier_p (decl
))
9070 if (C_IS_RESERVED_WORD (dname
))
9072 error ("declarator-id missing; using reserved word %qD",
9074 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9076 else if (!IDENTIFIER_TYPENAME_P (dname
))
9077 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9080 gcc_assert (flags
== NO_SPECIAL
);
9081 flags
= TYPENAME_FLAG
;
9082 ctor_return_type
= TREE_TYPE (dname
);
9083 sfk
= sfk_conversion
;
9084 if (is_typename_at_global_scope (dname
))
9085 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
9087 name
= "<invalid operator>";
9104 return error_mark_node
;
9109 if (id_declarator
->kind
== cdk_id
)
9115 The declarator in a function-definition shall have the form
9116 D1 ( parameter-declaration-clause) ... */
9117 if (funcdef_flag
&& innermost_code
!= cdk_function
)
9119 error ("function definition does not declare parameters");
9120 return error_mark_node
;
9123 if (flags
== TYPENAME_FLAG
9124 && innermost_code
!= cdk_function
9125 && ! (ctype
&& !declspecs
->any_specifiers_p
))
9127 error ("declaration of %qD as non-function", dname
);
9128 return error_mark_node
;
9132 && identifier_p (dname
)
9133 && UDLIT_OPER_P (dname
)
9134 && innermost_code
!= cdk_function
)
9136 error ("declaration of %qD as non-function", dname
);
9137 return error_mark_node
;
9140 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
9144 error ("declaration of %qD as %<typedef%>", dname
);
9145 return error_mark_node
;
9147 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9149 error ("declaration of %qD as parameter", dname
);
9150 return error_mark_node
;
9154 /* Anything declared one level down from the top level
9155 must be one of the parameters of a function
9156 (because the body is at least two levels down). */
9158 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
9159 by not allowing C++ class definitions to specify their parameters
9160 with xdecls (must be spec.d in the parmlist).
9162 Since we now wait to push a class scope until we are sure that
9163 we are in a legitimate method context, we must set oldcname
9164 explicitly (since current_class_name is not yet alive).
9166 We also want to avoid calling this a PARM if it is in a namespace. */
9168 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
9170 cp_binding_level
*b
= current_binding_level
;
9171 current_binding_level
= b
->level_chain
;
9172 if (current_binding_level
!= 0 && toplevel_bindings_p ())
9173 decl_context
= PARM
;
9174 current_binding_level
= b
;
9178 name
= decl_context
== PARM
? "parameter" : "type name";
9180 if (constexpr_p
&& typedef_p
)
9182 error ("%<constexpr%> cannot appear in a typedef declaration");
9183 return error_mark_node
;
9186 /* If there were multiple types specified in the decl-specifier-seq,
9187 issue an error message. */
9188 if (declspecs
->multiple_types_p
)
9190 error ("two or more data types in declaration of %qs", name
);
9191 return error_mark_node
;
9194 if (declspecs
->conflicting_specifiers_p
)
9196 error ("conflicting specifiers in declaration of %qs", name
);
9197 return error_mark_node
;
9200 /* Extract the basic type from the decl-specifier-seq. */
9201 type
= declspecs
->type
;
9202 if (type
== error_mark_node
)
9205 type_was_error_mark_node
= true;
9207 /* If the entire declaration is itself tagged as deprecated then
9208 suppress reports of deprecated items. */
9209 if (type
&& TREE_DEPRECATED (type
)
9210 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9211 warn_deprecated_use (type
, NULL_TREE
);
9212 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
9214 typedef_decl
= type
;
9215 type
= TREE_TYPE (typedef_decl
);
9216 if (TREE_DEPRECATED (type
)
9217 && DECL_ARTIFICIAL (typedef_decl
)
9218 && deprecated_state
!= DEPRECATED_SUPPRESS
)
9219 warn_deprecated_use (type
, NULL_TREE
);
9221 /* No type at all: default to `int', and set DEFAULTED_INT
9222 because it was not a user-defined typedef. */
9223 if (type
== NULL_TREE
)
9225 if (signed_p
|| unsigned_p
|| long_p
|| short_p
)
9227 /* These imply 'int'. */
9228 type
= integer_type_node
;
9231 /* If we just have "complex", it is equivalent to "complex double". */
9232 else if (!longlong
&& !explicit_intN
9233 && decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9235 type
= double_type_node
;
9236 pedwarn (declspecs
->locations
[ds_complex
], OPT_Wpedantic
,
9237 "ISO C++ does not support plain %<complex%> meaning "
9238 "%<double complex%>");
9242 explicit_int
= declspecs
->explicit_int_p
;
9243 explicit_char
= declspecs
->explicit_char_p
;
9246 /* See the code below that used this. */
9248 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
9250 typedef_type
= type
;
9253 if (sfk
!= sfk_conversion
)
9254 ctor_return_type
= ctype
;
9256 if (sfk
!= sfk_none
)
9257 type
= check_special_function_return_type (sfk
, type
,
9259 else if (type
== NULL_TREE
)
9265 /* We handle `main' specially here, because 'main () { }' is so
9266 common. With no options, it is allowed. With -Wreturn-type,
9267 it is a warning. It is only an error with -pedantic-errors. */
9268 is_main
= (funcdef_flag
9269 && dname
&& identifier_p (dname
)
9270 && MAIN_NAME_P (dname
)
9271 && ctype
== NULL_TREE
9272 && in_namespace
== NULL_TREE
9273 && current_namespace
== global_namespace
);
9275 if (type_was_error_mark_node
)
9276 /* We've already issued an error, don't complain more. */;
9277 else if (in_system_header_at (input_location
) || flag_ms_extensions
)
9278 /* Allow it, sigh. */;
9280 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9282 pedwarn (input_location
, OPT_Wpedantic
,
9283 "ISO C++ forbids declaration of %qs with no type", name
);
9285 warning (OPT_Wreturn_type
,
9286 "ISO C++ forbids declaration of %qs with no type", name
);
9288 type
= integer_type_node
;
9295 if (! int_n_enabled_p
[declspecs
->int_n_idx
])
9297 error ("%<__int%d%> is not supported by this target",
9298 int_n_data
[declspecs
->int_n_idx
].bitsize
);
9299 explicit_intN
= false;
9301 else if (pedantic
&& ! in_system_header_at (input_location
))
9302 pedwarn (input_location
, OPT_Wpedantic
,
9303 "ISO C++ does not support %<__int%d%> for %qs",
9304 int_n_data
[declspecs
->int_n_idx
].bitsize
, name
);
9307 /* Now process the modifiers that were specified
9308 and check for invalid combinations. */
9310 /* Long double is a special combination. */
9311 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9314 type
= cp_build_qualified_type (long_double_type_node
,
9315 cp_type_quals (type
));
9318 /* Check all other uses of type modifiers. */
9320 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9324 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9325 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9326 else if (signed_p
&& unsigned_p
)
9327 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9328 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9329 error ("%<long long%> invalid for %qs", name
);
9330 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9331 error ("%<long%> invalid for %qs", name
);
9332 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9333 error ("%<short%> invalid for %qs", name
);
9334 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9335 error ("%<long%> or %<short%> invalid for %qs", name
);
9336 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_intN
)
9337 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9338 else if ((long_p
|| short_p
) && explicit_char
)
9339 error ("%<long%> or %<short%> specified with char for %qs", name
);
9340 else if (long_p
&& short_p
)
9341 error ("%<long%> and %<short%> specified together for %qs", name
);
9342 else if (type
== char16_type_node
|| type
== char32_type_node
)
9344 if (signed_p
|| unsigned_p
)
9345 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9346 else if (short_p
|| long_p
)
9347 error ("%<short%> or %<long%> invalid for %qs", name
);
9352 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_intN
&& pedantic
)
9354 pedwarn (input_location
, OPT_Wpedantic
,
9355 "long, short, signed or unsigned used invalidly for %qs",
9357 if (flag_pedantic_errors
)
9362 /* Discard the type modifiers if they are invalid. */
9373 /* Decide whether an integer type is signed or not.
9374 Optionally treat bitfields as signed by default. */
9378 It is implementation-defined whether a plain (neither
9379 explicitly signed or unsigned) char, short, int, or long
9380 bit-field is signed or unsigned.
9382 Naturally, we extend this to long long as well. Note that
9383 this does not include wchar_t. */
9384 || (bitfield
&& !flag_signed_bitfields
9386 /* A typedef for plain `int' without `signed' can be
9387 controlled just like plain `int', but a typedef for
9388 `signed int' cannot be so controlled. */
9390 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9391 && TREE_CODE (type
) == INTEGER_TYPE
9392 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9395 type
= int_n_trees
[declspecs
->int_n_idx
].unsigned_type
;
9397 type
= long_long_unsigned_type_node
;
9399 type
= long_unsigned_type_node
;
9401 type
= short_unsigned_type_node
;
9402 else if (type
== char_type_node
)
9403 type
= unsigned_char_type_node
;
9404 else if (typedef_decl
)
9405 type
= unsigned_type_for (type
);
9407 type
= unsigned_type_node
;
9409 else if (signed_p
&& type
== char_type_node
)
9410 type
= signed_char_type_node
;
9411 else if (explicit_intN
)
9412 type
= int_n_trees
[declspecs
->int_n_idx
].signed_type
;
9414 type
= long_long_integer_type_node
;
9416 type
= long_integer_type_node
;
9418 type
= short_integer_type_node
;
9420 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9422 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9423 error ("complex invalid for %qs", name
);
9424 /* If a modifier is specified, the resulting complex is the complex
9425 form of TYPE. E.g, "complex short" is "complex short int". */
9426 else if (type
== integer_type_node
)
9427 type
= complex_integer_type_node
;
9428 else if (type
== float_type_node
)
9429 type
= complex_float_type_node
;
9430 else if (type
== double_type_node
)
9431 type
= complex_double_type_node
;
9432 else if (type
== long_double_type_node
)
9433 type
= complex_long_double_type_node
;
9435 type
= build_complex_type (type
);
9438 type_quals
= TYPE_UNQUALIFIED
;
9439 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9440 type_quals
|= TYPE_QUAL_CONST
;
9441 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9442 type_quals
|= TYPE_QUAL_VOLATILE
;
9443 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9444 type_quals
|= TYPE_QUAL_RESTRICT
;
9445 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9446 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9449 /* If we're using the injected-class-name to form a compound type or a
9450 declaration, replace it with the underlying class so we don't get
9451 redundant typedefs in the debug output. But if we are returning the
9452 type unchanged, leave it alone so that it's available to
9453 maybe_get_template_decl_from_type_decl. */
9454 if (CLASS_TYPE_P (type
)
9455 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9456 && type
== TREE_TYPE (TYPE_NAME (type
))
9457 && (declarator
|| type_quals
))
9458 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9460 type_quals
|= cp_type_quals (type
);
9461 type
= cp_build_qualified_type_real
9462 (type
, type_quals
, ((((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
))
9463 || declspecs
->decltype_p
)
9464 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9465 /* We might have ignored or rejected some of the qualifiers. */
9466 type_quals
= cp_type_quals (type
);
9469 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9470 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9471 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9473 storage_class
= declspecs
->storage_class
;
9474 if (storage_class
== sc_static
)
9475 staticp
= 1 + (decl_context
== FIELD
);
9477 if (virtualp
&& staticp
== 2)
9479 error ("member %qD cannot be declared both virtual and static", dname
);
9480 storage_class
= sc_none
;
9483 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9485 /* Issue errors about use of storage classes for parameters. */
9486 if (decl_context
== PARM
)
9490 error ("typedef declaration invalid in parameter declaration");
9491 return error_mark_node
;
9493 else if (template_parm_flag
&& storage_class
!= sc_none
)
9495 error ("storage class specified for template parameter %qs", name
);
9496 return error_mark_node
;
9498 else if (storage_class
== sc_static
9499 || storage_class
== sc_extern
9501 error ("storage class specifiers invalid in parameter declarations");
9503 /* Function parameters cannot be constexpr. If we saw one, moan
9504 and pretend it wasn't there. */
9507 error ("a parameter cannot be declared %<constexpr%>");
9512 /* Give error if `virtual' is used outside of class declaration. */
9514 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9516 error ("%<virtual%> outside class declaration");
9520 /* Static anonymous unions are dealt with here. */
9521 if (staticp
&& decl_context
== TYPENAME
9523 && ANON_AGGR_TYPE_P (declspecs
->type
))
9524 decl_context
= FIELD
;
9526 /* Warn about storage classes that are invalid for certain
9527 kinds of declarations (parameters, typenames, etc.). */
9530 && storage_class
!= sc_extern
9531 && storage_class
!= sc_static
)
9534 error ("multiple storage classes in declaration of %qs", name
);
9537 if (decl_context
!= NORMAL
9538 && ((storage_class
!= sc_none
9539 && storage_class
!= sc_mutable
)
9542 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9543 && (storage_class
== sc_register
9544 || storage_class
== sc_auto
))
9548 else if (decl_context
== FIELD
9549 /* C++ allows static class elements. */
9550 && storage_class
== sc_static
)
9551 /* C++ also allows inlines and signed and unsigned elements,
9552 but in those cases we don't come in here. */
9556 if (decl_context
== FIELD
)
9557 error ("storage class specified for %qs", name
);
9560 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9561 error ("storage class specified for parameter %qs", name
);
9563 error ("storage class specified for typename");
9565 if (storage_class
== sc_register
9566 || storage_class
== sc_auto
9567 || storage_class
== sc_extern
9569 storage_class
= sc_none
;
9572 else if (storage_class
== sc_extern
&& funcdef_flag
9573 && ! toplevel_bindings_p ())
9574 error ("nested function %qs declared %<extern%>", name
);
9575 else if (toplevel_bindings_p ())
9577 if (storage_class
== sc_auto
)
9578 error ("top-level declaration of %qs specifies %<auto%>", name
);
9581 && storage_class
!= sc_extern
9582 && storage_class
!= sc_static
)
9584 if (declspecs
->gnu_thread_keyword_p
)
9585 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9586 "declared %<__thread%>", name
);
9588 /* When thread_local is applied to a variable of block scope the
9589 storage-class-specifier static is implied if it does not appear
9591 storage_class
= declspecs
->storage_class
= sc_static
;
9595 if (storage_class
&& friendp
)
9597 error ("storage class specifiers invalid in friend function declarations");
9598 storage_class
= sc_none
;
9603 unqualified_id
= NULL_TREE
;
9606 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9607 switch (TREE_CODE (unqualified_id
))
9610 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9611 if (TYPE_P (unqualified_id
))
9612 unqualified_id
= constructor_name (unqualified_id
);
9615 case IDENTIFIER_NODE
:
9616 case TEMPLATE_ID_EXPR
:
9624 if (declspecs
->std_attributes
)
9626 /* Apply the c++11 attributes to the type preceding them. */
9627 input_location
= declspecs
->locations
[ds_std_attribute
];
9628 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9629 input_location
= saved_loc
;
9632 /* Determine the type of the entity declared by recurring on the
9634 for (; declarator
; declarator
= declarator
->declarator
)
9636 const cp_declarator
*inner_declarator
;
9639 if (type
== error_mark_node
)
9640 return error_mark_node
;
9642 attrs
= declarator
->attributes
;
9648 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9649 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9650 if (declarator
->kind
== cdk_function
)
9651 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9652 if (declarator
->kind
== cdk_array
)
9653 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9654 returned_attrs
= decl_attributes (&type
,
9655 chainon (returned_attrs
, attrs
),
9659 if (declarator
->kind
== cdk_id
)
9662 inner_declarator
= declarator
->declarator
;
9664 switch (declarator
->kind
)
9667 type
= create_array_type_for_decl (dname
, type
,
9668 declarator
->u
.array
.bounds
);
9669 if (declarator
->std_attributes
)
9672 The optional attribute-specifier-seq appertains to the
9674 returned_attrs
= chainon (returned_attrs
,
9675 declarator
->std_attributes
);
9683 /* Declaring a function type.
9684 Make sure we have a valid type for the function to return. */
9686 if (type_quals
!= TYPE_UNQUALIFIED
)
9688 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9689 warning (OPT_Wignored_qualifiers
,
9690 "type qualifiers ignored on function return type");
9691 /* We now know that the TYPE_QUALS don't apply to the
9692 decl, but to its return type. */
9693 type_quals
= TYPE_UNQUALIFIED
;
9695 errmsg
= targetm
.invalid_return_type (type
);
9699 type
= integer_type_node
;
9702 /* Error about some types functions can't return. */
9704 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9706 error ("%qs declared as function returning a function", name
);
9707 return error_mark_node
;
9709 if (TREE_CODE (type
) == ARRAY_TYPE
)
9711 error ("%qs declared as function returning an array", name
);
9712 return error_mark_node
;
9715 input_location
= declspecs
->locations
[ds_type_spec
];
9716 abstract_virtuals_error (ACU_RETURN
, type
);
9717 input_location
= saved_loc
;
9719 /* Pick up type qualifiers which should be applied to `this'. */
9720 memfn_quals
= declarator
->u
.function
.qualifiers
;
9721 /* Pick up virt-specifiers. */
9722 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9723 /* And ref-qualifier, too */
9724 rqual
= declarator
->u
.function
.ref_qualifier
;
9725 /* Pick up the exception specifications. */
9726 raises
= declarator
->u
.function
.exception_specification
;
9727 /* If the exception-specification is ill-formed, let's pretend
9728 there wasn't one. */
9729 if (raises
== error_mark_node
)
9732 /* Say it's a definition only for the CALL_EXPR
9733 closest to the identifier. */
9734 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9736 /* Handle a late-specified return type. */
9739 if (type_uses_auto (type
))
9741 if (!declarator
->u
.function
.late_return_type
)
9743 if (current_class_type
9744 && LAMBDA_TYPE_P (current_class_type
))
9745 /* OK for C++11 lambdas. */;
9746 else if (cxx_dialect
< cxx14
)
9748 error ("%qs function uses "
9749 "%<auto%> type specifier without trailing "
9750 "return type", name
);
9751 inform (input_location
, "deduced return type "
9752 "only available with -std=c++14 or "
9757 error ("virtual function cannot "
9758 "have deduced return type");
9762 else if (!is_auto (type
))
9764 error ("%qs function with trailing return type has"
9765 " %qT as its type rather than plain %<auto%>",
9767 return error_mark_node
;
9770 else if (declarator
->u
.function
.late_return_type
)
9772 if (cxx_dialect
< cxx11
)
9773 /* Not using maybe_warn_cpp0x because this should
9774 always be an error. */
9775 error ("trailing return type only available with "
9776 "-std=c++11 or -std=gnu++11");
9778 error ("%qs function with trailing return type not "
9779 "declared with %<auto%> type specifier", name
);
9780 return error_mark_node
;
9783 type
= splice_late_return_type
9784 (type
, declarator
->u
.function
.late_return_type
);
9785 if (type
== error_mark_node
)
9786 return error_mark_node
;
9788 if (declarator
->u
.function
.late_return_type
)
9789 late_return_type_p
= true;
9791 if (ctype
== NULL_TREE
9792 && decl_context
== FIELD
9795 ctype
= current_class_type
;
9797 if (ctype
&& (sfk
== sfk_constructor
9798 || sfk
== sfk_destructor
))
9800 /* We are within a class's scope. If our declarator name
9801 is the same as the class name, and we are defining
9802 a function, then it is a constructor/destructor, and
9803 therefore returns a void type. */
9805 /* ISO C++ 12.4/2. A destructor may not be declared
9806 const or volatile. A destructor may not be static.
9807 A destructor may not be declared with ref-qualifier.
9809 ISO C++ 12.1. A constructor may not be declared
9810 const or volatile. A constructor may not be
9811 virtual. A constructor may not be static.
9812 A constructor may not be declared with ref-qualifier. */
9814 error ((flags
== DTOR_FLAG
)
9815 ? G_("destructor cannot be static member function")
9816 : G_("constructor cannot be static member function"));
9819 error ((flags
== DTOR_FLAG
)
9820 ? G_("destructors may not be cv-qualified")
9821 : G_("constructors may not be cv-qualified"));
9822 memfn_quals
= TYPE_UNQUALIFIED
;
9827 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER
);
9828 error ((flags
== DTOR_FLAG
)
9829 ? "destructors may not be ref-qualified"
9830 : "constructors may not be ref-qualified");
9831 rqual
= REF_QUAL_NONE
;
9834 if (decl_context
== FIELD
9835 && !member_function_or_else (ctype
,
9838 return error_mark_node
;
9840 if (flags
!= DTOR_FLAG
)
9842 /* It's a constructor. */
9847 permerror (input_location
, "constructors cannot be declared virtual");
9850 if (decl_context
== FIELD
9851 && sfk
!= sfk_constructor
)
9852 return error_mark_node
;
9854 if (decl_context
== FIELD
)
9861 /* Cannot be both friend and virtual. */
9862 error ("virtual functions cannot be friends");
9865 if (decl_context
== NORMAL
)
9866 error ("friend declaration not in class definition");
9867 if (current_function_decl
&& funcdef_flag
)
9868 error ("can%'t define friend function %qs in a local "
9872 else if (ctype
&& sfk
== sfk_conversion
)
9876 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9881 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9884 if (inner_declarator
9885 && inner_declarator
->kind
== cdk_id
9886 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9887 && arg_types
!= void_list_node
)
9889 error ("destructors may not have parameters");
9890 arg_types
= void_list_node
;
9894 type
= build_function_type (type
, arg_types
);
9895 if (declarator
->std_attributes
)
9898 The optional attribute-specifier-seq appertains to
9899 the function type. */
9900 decl_attributes (&type
, declarator
->std_attributes
,
9908 /* Filter out pointers-to-references and references-to-references.
9909 We can get these if a TYPE_DECL is used. */
9911 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9913 if (declarator
->kind
!= cdk_reference
)
9915 error ("cannot declare pointer to %q#T", type
);
9916 type
= TREE_TYPE (type
);
9919 /* In C++0x, we allow reference to reference declarations
9920 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9921 and template type arguments [14.3.1/4 temp.arg.type]. The
9922 check for direct reference to reference declarations, which
9923 are still forbidden, occurs below. Reasoning behind the change
9924 can be found in DR106, DR540, and the rvalue reference
9926 else if (cxx_dialect
== cxx98
)
9928 error ("cannot declare reference to %q#T", type
);
9929 type
= TREE_TYPE (type
);
9932 else if (VOID_TYPE_P (type
))
9934 if (declarator
->kind
== cdk_reference
)
9935 error ("cannot declare reference to %q#T", type
);
9936 else if (declarator
->kind
== cdk_ptrmem
)
9937 error ("cannot declare pointer to %q#T member", type
);
9940 /* We now know that the TYPE_QUALS don't apply to the decl,
9941 but to the target of the pointer. */
9942 type_quals
= TYPE_UNQUALIFIED
;
9944 /* This code used to handle METHOD_TYPE, but I don't think it's
9945 possible to get it here anymore. */
9946 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9947 if (declarator
->kind
== cdk_ptrmem
9948 && TREE_CODE (type
) == FUNCTION_TYPE
)
9950 memfn_quals
|= type_memfn_quals (type
);
9951 type
= build_memfn_type (type
,
9952 declarator
->u
.pointer
.class_type
,
9955 if (type
== error_mark_node
)
9956 return error_mark_node
;
9958 rqual
= REF_QUAL_NONE
;
9959 memfn_quals
= TYPE_UNQUALIFIED
;
9962 if (TREE_CODE (type
) == FUNCTION_TYPE
9963 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
9964 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
9965 error (declarator
->kind
== cdk_reference
9966 ? G_("cannot declare reference to qualified function type %qT")
9967 : G_("cannot declare pointer to qualified function type %qT"),
9970 /* When the pointed-to type involves components of variable size,
9971 care must be taken to ensure that the size evaluation code is
9972 emitted early enough to dominate all the possible later uses
9973 and late enough for the variables on which it depends to have
9976 This is expected to happen automatically when the pointed-to
9977 type has a name/declaration of it's own, but special attention
9978 is required if the type is anonymous.
9980 We handle the NORMAL and FIELD contexts here by inserting a
9981 dummy statement that just evaluates the size at a safe point
9982 and ensures it is not deferred until e.g. within a deeper
9983 conditional context (c++/43555).
9985 We expect nothing to be needed here for PARM or TYPENAME.
9986 Evaluating the size at this point for TYPENAME would
9987 actually be incorrect, as we might be in the middle of an
9988 expression with side effects on the pointed-to type size
9989 "arguments" prior to the pointer declaration point and the
9990 size evaluation could end up prior to the side effects. */
9992 if (!TYPE_NAME (type
)
9993 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9994 && at_function_scope_p ()
9995 && variably_modified_type_p (type
, NULL_TREE
))
9996 /* Force evaluation of the SAVE_EXPR. */
9997 finish_expr_stmt (TYPE_SIZE (type
));
9999 if (declarator
->kind
== cdk_reference
)
10001 /* In C++0x, the type we are creating a reference to might be
10002 a typedef which is itself a reference type. In that case,
10003 we follow the reference collapsing rules in
10004 [7.1.3/8 dcl.typedef] to create the final reference type:
10006 "If a typedef TD names a type that is a reference to a type
10007 T, an attempt to create the type 'lvalue reference to cv TD'
10008 creates the type 'lvalue reference to T,' while an attempt
10009 to create the type "rvalue reference to cv TD' creates the
10012 if (VOID_TYPE_P (type
))
10013 /* We already gave an error. */;
10014 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10016 if (declarator
->u
.reference
.rvalue_ref
)
10017 /* Leave type alone. */;
10019 type
= cp_build_reference_type (TREE_TYPE (type
), false);
10022 type
= cp_build_reference_type
10023 (type
, declarator
->u
.reference
.rvalue_ref
);
10025 /* In C++0x, we need this check for direct reference to
10026 reference declarations, which are forbidden by
10027 [8.3.2/5 dcl.ref]. Reference to reference declarations
10028 are only allowed indirectly through typedefs and template
10029 type arguments. Example:
10031 void foo(int & &); // invalid ref-to-ref decl
10033 typedef int & int_ref;
10034 void foo(int_ref &); // valid ref-to-ref decl
10036 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
10037 error ("cannot declare reference to %q#T, which is not "
10038 "a typedef or a template type argument", type
);
10040 else if (TREE_CODE (type
) == METHOD_TYPE
)
10041 type
= build_ptrmemfunc_type (build_pointer_type (type
));
10042 else if (declarator
->kind
== cdk_ptrmem
)
10044 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
10045 != NAMESPACE_DECL
);
10046 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
10047 /* We will already have complained. */
10048 type
= error_mark_node
;
10050 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
10054 type
= build_pointer_type (type
);
10056 /* Process a list of type modifier keywords (such as
10057 const or volatile) that were given inside the `*' or `&'. */
10059 if (declarator
->u
.pointer
.qualifiers
)
10062 = cp_build_qualified_type (type
,
10063 declarator
->u
.pointer
.qualifiers
);
10064 type_quals
= cp_type_quals (type
);
10067 /* Apply C++11 attributes to the pointer, and not to the
10068 type pointed to. This is unlike what is done for GNU
10069 attributes above. It is to comply with [dcl.ptr]/1:
10071 [the optional attribute-specifier-seq (7.6.1) appertains
10072 to the pointer and not to the object pointed to]. */
10073 if (declarator
->std_attributes
)
10074 decl_attributes (&type
, declarator
->std_attributes
,
10084 gcc_unreachable ();
10088 /* A `constexpr' specifier used in an object declaration declares
10089 the object as `const'. */
10090 if (constexpr_p
&& innermost_code
!= cdk_function
)
10092 if (type_quals
& TYPE_QUAL_VOLATILE
)
10093 error ("both %<volatile%> and %<constexpr%> cannot be used here");
10094 if (TREE_CODE (type
) != REFERENCE_TYPE
)
10096 type_quals
|= TYPE_QUAL_CONST
;
10097 type
= cp_build_qualified_type (type
, type_quals
);
10101 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
10102 && TREE_CODE (type
) != FUNCTION_TYPE
10103 && TREE_CODE (type
) != METHOD_TYPE
10104 && !variable_template_p (TREE_OPERAND (unqualified_id
, 0)))
10106 error ("template-id %qD used as a declarator",
10108 unqualified_id
= dname
;
10111 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
10112 qualified with a class-name, turn it into a METHOD_TYPE, unless
10113 we know that the function is static. We take advantage of this
10114 opportunity to do other processing that pertains to entities
10115 explicitly declared to be class members. Note that if DECLARATOR
10116 is non-NULL, we know it is a cdk_id declarator; otherwise, we
10117 would not have exited the loop above. */
10119 && declarator
->u
.id
.qualifying_scope
10120 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
10122 ctype
= declarator
->u
.id
.qualifying_scope
;
10123 ctype
= TYPE_MAIN_VARIANT (ctype
);
10124 template_count
= num_template_headers_for_class (ctype
);
10126 if (ctype
== current_class_type
)
10130 permerror (input_location
, "member functions are implicitly friends of their class");
10134 permerror (declarator
->id_loc
,
10135 "extra qualification %<%T::%> on member %qs",
10138 else if (/* If the qualifying type is already complete, then we
10139 can skip the following checks. */
10140 !COMPLETE_TYPE_P (ctype
)
10141 && (/* If the function is being defined, then
10142 qualifying type must certainly be complete. */
10144 /* A friend declaration of "T::f" is OK, even if
10145 "T" is a template parameter. But, if this
10146 function is not a friend, the qualifying type
10147 must be a class. */
10148 || (!friendp
&& !CLASS_TYPE_P (ctype
))
10149 /* For a declaration, the type need not be
10150 complete, if either it is dependent (since there
10151 is no meaningful definition of complete in that
10152 case) or the qualifying class is currently being
10154 || !(dependent_type_p (ctype
)
10155 || currently_open_class (ctype
)))
10156 /* Check that the qualifying type is complete. */
10157 && !complete_type_or_else (ctype
, NULL_TREE
))
10158 return error_mark_node
;
10159 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10161 if (current_class_type
10162 && (!friendp
|| funcdef_flag
))
10164 error (funcdef_flag
10165 ? G_("cannot define member function %<%T::%s%> "
10167 : G_("cannot declare member function %<%T::%s%> "
10169 ctype
, name
, current_class_type
);
10170 return error_mark_node
;
10173 else if (typedef_p
&& current_class_type
)
10175 error ("cannot declare member %<%T::%s%> within %qT",
10176 ctype
, name
, current_class_type
);
10177 return error_mark_node
;
10181 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
10182 ctype
= current_class_type
;
10184 /* Now TYPE has the actual type. */
10186 if (returned_attrs
)
10189 *attrlist
= chainon (returned_attrs
, *attrlist
);
10191 attrlist
= &returned_attrs
;
10195 && declarator
->kind
== cdk_id
10196 && declarator
->std_attributes
)
10197 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
10198 a declarator-id appertains to the entity that is declared. */
10199 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
10201 /* Handle parameter packs. */
10202 if (parameter_pack_p
)
10204 if (decl_context
== PARM
)
10205 /* Turn the type into a pack expansion.*/
10206 type
= make_pack_expansion (type
);
10208 error ("non-parameter %qs cannot be a parameter pack", name
);
10211 /* Did array size calculations overflow or does the array cover more
10212 than half of the address-space? */
10213 if (TREE_CODE (type
) == ARRAY_TYPE
10214 && COMPLETE_TYPE_P (type
)
10215 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
10216 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
10218 error ("size of array %qs is too large", name
);
10219 /* If we proceed with the array type as it is, we'll eventually
10220 crash in tree_to_[su]hwi(). */
10221 type
= error_mark_node
;
10224 if ((decl_context
== FIELD
|| decl_context
== PARM
)
10225 && !processing_template_decl
10226 && variably_modified_type_p (type
, NULL_TREE
))
10228 if (decl_context
== FIELD
)
10229 error ("data member may not have variably modified type %qT", type
);
10231 error ("parameter may not have variably modified type %qT", type
);
10232 type
= error_mark_node
;
10235 if (explicitp
== 1 || (explicitp
&& friendp
))
10237 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
10238 in the declaration of a constructor or conversion function within
10239 a class definition. */
10240 if (!current_class_type
)
10241 error ("%<explicit%> outside class declaration");
10243 error ("%<explicit%> in friend declaration");
10245 error ("only declarations of constructors and conversion operators "
10246 "can be %<explicit%>");
10250 if (storage_class
== sc_mutable
)
10252 if (decl_context
!= FIELD
|| friendp
)
10254 error ("non-member %qs cannot be declared %<mutable%>", name
);
10255 storage_class
= sc_none
;
10257 else if (decl_context
== TYPENAME
|| typedef_p
)
10259 error ("non-object member %qs cannot be declared %<mutable%>", name
);
10260 storage_class
= sc_none
;
10262 else if (TREE_CODE (type
) == FUNCTION_TYPE
10263 || TREE_CODE (type
) == METHOD_TYPE
)
10265 error ("function %qs cannot be declared %<mutable%>", name
);
10266 storage_class
= sc_none
;
10270 error ("static %qs cannot be declared %<mutable%>", name
);
10271 storage_class
= sc_none
;
10273 else if (type_quals
& TYPE_QUAL_CONST
)
10275 error ("const %qs cannot be declared %<mutable%>", name
);
10276 storage_class
= sc_none
;
10278 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10280 permerror (input_location
, "reference %qs cannot be declared "
10281 "%<mutable%>", name
);
10282 storage_class
= sc_none
;
10286 /* If this is declaring a typedef name, return a TYPE_DECL. */
10287 if (typedef_p
&& decl_context
!= TYPENAME
)
10291 /* Note that the grammar rejects storage classes
10292 in typenames, fields or parameters. */
10293 if (current_lang_name
== lang_name_java
)
10294 TYPE_FOR_JAVA (type
) = 1;
10296 /* This declaration:
10298 typedef void f(int) const;
10300 declares a function type which is not a member of any
10301 particular class, but which is cv-qualified; for
10302 example "f S::*" declares a pointer to a const-qualified
10303 member function of S. We record the cv-qualification in the
10305 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10307 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10309 /* We have now dealt with these qualifiers. */
10310 memfn_quals
= TYPE_UNQUALIFIED
;
10311 rqual
= REF_QUAL_NONE
;
10314 if (type_uses_auto (type
))
10316 error ("typedef declared %<auto%>");
10317 type
= error_mark_node
;
10320 if (decl_context
== FIELD
)
10321 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10323 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10324 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10325 error_at (DECL_SOURCE_LOCATION (decl
),
10326 "typedef name may not be a nested-name-specifier");
10327 TREE_TYPE (decl
) = error_mark_node
;
10330 if (decl_context
!= FIELD
)
10332 if (!current_function_decl
)
10333 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10334 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10335 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10336 (current_function_decl
)))
10337 /* The TYPE_DECL is "abstract" because there will be
10338 clones of this constructor/destructor, and there will
10339 be copies of this TYPE_DECL generated in those
10340 clones. The decloning optimization (for space) may
10341 revert this subsequently if it determines that
10342 the clones should share a common implementation. */
10343 DECL_ABSTRACT_P (decl
) = true;
10345 else if (current_class_type
10346 && constructor_name_p (unqualified_id
, current_class_type
))
10347 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10348 "as enclosing class",
10351 /* If the user declares "typedef struct {...} foo" then the
10352 struct will have an anonymous name. Fill that name in now.
10353 Nothing can refer to it, so nothing needs know about the name
10355 if (type
!= error_mark_node
10357 && TYPE_NAME (type
)
10358 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10359 && TYPE_ANONYMOUS_P (type
)
10360 && declspecs
->type_definition_p
10361 && attributes_naming_typedef_ok (*attrlist
)
10362 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10366 /* Replace the anonymous name with the real name everywhere. */
10367 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10369 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10370 /* We do not rename the debug info representing the
10371 anonymous tagged type because the standard says in
10372 [dcl.typedef] that the naming applies only for
10373 linkage purposes. */
10374 /*debug_hooks->set_name (t, decl);*/
10375 TYPE_NAME (t
) = decl
;
10378 if (TYPE_LANG_SPECIFIC (type
))
10379 TYPE_WAS_ANONYMOUS (type
) = 1;
10381 /* If this is a typedef within a template class, the nested
10382 type is a (non-primary) template. The name for the
10383 template needs updating as well. */
10384 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10385 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10386 = TYPE_IDENTIFIER (type
);
10388 /* Adjust linkage now that we aren't anonymous anymore. */
10389 reset_type_linkage (type
);
10391 /* FIXME remangle member functions; member functions of a
10392 type with external linkage have external linkage. */
10396 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10397 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10399 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10400 memfn_quals
!= TYPE_UNQUALIFIED
,
10401 inlinep
, friendp
, raises
!= NULL_TREE
);
10403 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10404 /* Acknowledge that this was written:
10405 `using analias = atype;'. */
10406 TYPE_DECL_ALIAS_P (decl
) = 1;
10411 /* Detect the case of an array type of unspecified size
10412 which came, as such, direct from a typedef name.
10413 We must copy the type, so that the array's domain can be
10414 individually set by the object's initializer. */
10416 if (type
&& typedef_type
10417 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10418 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10419 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10421 /* Detect where we're using a typedef of function type to declare a
10422 function. PARMS will not be set, so we must create it now. */
10424 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10426 tree decls
= NULL_TREE
;
10429 for (args
= TYPE_ARG_TYPES (type
);
10430 args
&& args
!= void_list_node
;
10431 args
= TREE_CHAIN (args
))
10433 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10435 DECL_CHAIN (decl
) = decls
;
10439 parms
= nreverse (decls
);
10441 if (decl_context
!= TYPENAME
)
10443 /* The qualifiers on the function type become the qualifiers on
10444 the non-static member function. */
10445 memfn_quals
|= type_memfn_quals (type
);
10446 rqual
= type_memfn_rqual (type
);
10447 type_quals
= TYPE_UNQUALIFIED
;
10451 /* If this is a type name (such as, in a cast or sizeof),
10452 compute the type and return it now. */
10454 if (decl_context
== TYPENAME
)
10456 /* Note that the grammar rejects storage classes
10457 in typenames, fields or parameters. */
10458 if (type_quals
!= TYPE_UNQUALIFIED
)
10459 type_quals
= TYPE_UNQUALIFIED
;
10461 /* Special case: "friend class foo" looks like a TYPENAME context. */
10464 if (type_quals
!= TYPE_UNQUALIFIED
)
10466 error ("type qualifiers specified for friend class declaration");
10467 type_quals
= TYPE_UNQUALIFIED
;
10471 error ("%<inline%> specified for friend class declaration");
10477 /* Don't allow friend declaration without a class-key. */
10478 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10479 permerror (input_location
, "template parameters cannot be friends");
10480 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10481 permerror (input_location
, "friend declaration requires class-key, "
10482 "i.e. %<friend class %T::%D%>",
10483 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10485 permerror (input_location
, "friend declaration requires class-key, "
10486 "i.e. %<friend %#T%>",
10490 /* Only try to do this stuff if we didn't already give up. */
10491 if (type
!= integer_type_node
)
10493 /* A friendly class? */
10494 if (current_class_type
)
10495 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10496 /*complain=*/true);
10498 error ("trying to make class %qT a friend of global scope",
10501 type
= void_type_node
;
10504 else if (memfn_quals
|| rqual
)
10506 if (ctype
== NULL_TREE
10507 && TREE_CODE (type
) == METHOD_TYPE
)
10508 ctype
= TYPE_METHOD_BASETYPE (type
);
10511 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10512 /* Core issue #547: need to allow this in template type args.
10513 Allow it in general in C++11 for alias-declarations. */
10514 else if ((template_type_arg
|| cxx_dialect
>= cxx11
)
10515 && TREE_CODE (type
) == FUNCTION_TYPE
)
10516 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10518 error ("invalid qualifiers on non-member function type");
10523 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10524 && decl_context
!= CATCHPARM
10525 && TREE_CODE (type
) != UNION_TYPE
10528 error ("abstract declarator %qT used as declaration", type
);
10529 return error_mark_node
;
10532 /* Only functions may be declared using an operator-function-id. */
10534 && IDENTIFIER_OPNAME_P (unqualified_id
)
10535 && TREE_CODE (type
) != FUNCTION_TYPE
10536 && TREE_CODE (type
) != METHOD_TYPE
)
10538 error ("declaration of %qD as non-function", unqualified_id
);
10539 return error_mark_node
;
10542 /* We don't check parameter types here because we can emit a better
10543 error message later. */
10544 if (decl_context
!= PARM
)
10546 type
= check_var_type (unqualified_id
, type
);
10547 if (type
== error_mark_node
)
10548 return error_mark_node
;
10551 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10552 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10554 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10556 if (ctype
|| in_namespace
)
10557 error ("cannot use %<::%> in parameter declaration");
10559 if (type_uses_auto (type
))
10561 if (cxx_dialect
>= cxx14
)
10562 error ("%<auto%> parameter not permitted in this context");
10564 error ("parameter declared %<auto%>");
10565 type
= error_mark_node
;
10568 /* A parameter declared as an array of T is really a pointer to T.
10569 One declared as a function is really a pointer to a function.
10570 One declared as a member is really a pointer to member. */
10572 if (TREE_CODE (type
) == ARRAY_TYPE
)
10574 /* Transfer const-ness of array into that of type pointed to. */
10575 type
= build_pointer_type (TREE_TYPE (type
));
10576 type_quals
= TYPE_UNQUALIFIED
;
10577 array_parameter_p
= true;
10579 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10580 type
= build_pointer_type (type
);
10583 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10584 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10586 cp_cv_quals real_quals
= memfn_quals
;
10587 if (cxx_dialect
< cxx14
&& constexpr_p
10588 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10589 real_quals
|= TYPE_QUAL_CONST
;
10590 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10596 if (decl_context
== PARM
)
10598 decl
= cp_build_parm_decl (unqualified_id
, type
);
10599 DECL_ARRAY_PARAMETER_P (decl
) = array_parameter_p
;
10601 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10602 memfn_quals
!= TYPE_UNQUALIFIED
,
10603 inlinep
, friendp
, raises
!= NULL_TREE
);
10605 else if (decl_context
== FIELD
)
10607 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10608 && type_uses_auto (type
))
10610 error ("non-static data member declared %<auto%>");
10611 type
= error_mark_node
;
10614 /* The C99 flexible array extension. */
10615 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10616 && TYPE_DOMAIN (type
) == NULL_TREE
)
10618 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10619 tf_warning_or_error
);
10620 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10623 if (type
== error_mark_node
)
10625 /* Happens when declaring arrays of sizes which
10626 are error_mark_node, for example. */
10629 else if (in_namespace
&& !friendp
)
10631 /* Something like struct S { int N::j; }; */
10632 error ("invalid use of %<::%>");
10633 return error_mark_node
;
10635 else if (TREE_CODE (type
) == FUNCTION_TYPE
10636 || TREE_CODE (type
) == METHOD_TYPE
)
10639 tree function_context
;
10643 /* This should never happen in pure C++ (the check
10644 could be an assert). It could happen in
10645 Objective-C++ if someone writes invalid code that
10646 uses a function declaration for an instance
10647 variable or property (instance variables and
10648 properties are parsed as FIELD_DECLs, but they are
10649 part of an Objective-C class, not a C++ class).
10650 That code is invalid and is caught by this
10654 error ("declaration of function %qD in invalid context",
10656 return error_mark_node
;
10659 /* ``A union may [ ... ] not [ have ] virtual functions.''
10661 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10663 error ("function %qD declared virtual inside a union",
10665 return error_mark_node
;
10668 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10672 error ("%qD cannot be declared virtual, since it "
10673 "is always static",
10680 /* Check that the name used for a destructor makes sense. */
10681 if (sfk
== sfk_destructor
)
10683 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10687 gcc_assert (friendp
);
10688 error ("expected qualified name in friend declaration "
10689 "for destructor %qD", uqname
);
10690 return error_mark_node
;
10693 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10695 error ("declaration of %qD as member of %qT",
10697 return error_mark_node
;
10701 error ("a destructor cannot be %<constexpr%>");
10702 return error_mark_node
;
10705 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10707 error ("expected qualified name in friend declaration "
10708 "for constructor %qD",
10709 id_declarator
->u
.id
.unqualified_name
);
10710 return error_mark_node
;
10713 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10715 tree tmpl
= TREE_OPERAND (unqualified_id
, 0);
10716 if (variable_template_p (tmpl
))
10718 error ("specialization of variable template %qD "
10719 "declared as function", tmpl
);
10720 inform (DECL_SOURCE_LOCATION (tmpl
),
10721 "variable template declared here");
10722 return error_mark_node
;
10726 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10727 function_context
= (ctype
!= NULL_TREE
) ?
10728 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10729 publicp
= (! friendp
|| ! staticp
)
10730 && function_context
== NULL_TREE
;
10732 if (late_return_type_p
)
10733 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
10735 decl
= grokfndecl (ctype
, type
,
10736 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10737 ? unqualified_id
: dname
,
10740 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10741 friendp
? -1 : 0, friendp
, publicp
,
10742 inlinep
| (2 * constexpr_p
),
10744 funcdef_flag
, template_count
, in_namespace
,
10745 attrlist
, declarator
->id_loc
);
10746 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10747 if (decl
== NULL_TREE
)
10748 return error_mark_node
;
10750 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10751 /* The decl and setting of decl_attr is also turned off. */
10752 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10755 /* [class.conv.ctor]
10757 A constructor declared without the function-specifier
10758 explicit that can be called with a single parameter
10759 specifies a conversion from the type of its first
10760 parameter to the type of its class. Such a constructor
10761 is called a converting constructor. */
10762 if (explicitp
== 2)
10763 DECL_NONCONVERTING_P (decl
) = 1;
10765 else if (!staticp
&& !dependent_type_p (type
)
10766 && !COMPLETE_TYPE_P (complete_type (type
))
10767 && (TREE_CODE (type
) != ARRAY_TYPE
10768 || !COMPLETE_TYPE_P (TREE_TYPE (type
))
10769 || initialized
== 0))
10771 if (unqualified_id
)
10773 error ("field %qD has incomplete type %qT",
10774 unqualified_id
, type
);
10775 cxx_incomplete_type_inform (strip_array_types (type
));
10778 error ("name %qT has incomplete type", type
);
10780 type
= error_mark_node
;
10787 error ("%qE is neither function nor member function; "
10788 "cannot be declared friend", unqualified_id
);
10796 /* Friends are treated specially. */
10797 if (ctype
== current_class_type
)
10798 ; /* We already issued a permerror. */
10799 else if (decl
&& DECL_NAME (decl
))
10801 if (template_class_depth (current_class_type
) == 0)
10803 decl
= check_explicit_specialization
10804 (unqualified_id
, decl
, template_count
,
10805 2 * funcdef_flag
+ 4);
10806 if (decl
== error_mark_node
)
10807 return error_mark_node
;
10810 decl
= do_friend (ctype
, unqualified_id
, decl
,
10816 return error_mark_node
;
10819 /* Structure field. It may not be a function, except for C++. */
10821 if (decl
== NULL_TREE
)
10825 /* C++ allows static class members. All other work
10826 for this is done by grokfield. */
10827 decl
= build_lang_decl_loc (declarator
10828 ? declarator
->id_loc
10830 VAR_DECL
, unqualified_id
, type
);
10831 set_linkage_for_static_data_member (decl
);
10832 /* Even if there is an in-class initialization, DECL
10833 is considered undefined until an out-of-class
10834 definition is provided. */
10835 DECL_EXTERNAL (decl
) = 1;
10839 set_decl_tls_model (decl
, decl_default_tls_model (decl
));
10840 if (declspecs
->gnu_thread_keyword_p
)
10841 DECL_GNU_TLS_P (decl
) = true;
10844 if (constexpr_p
&& !initialized
)
10846 error ("constexpr static data member %qD must have an "
10847 "initializer", decl
);
10848 constexpr_p
= false;
10855 error ("non-static data member %qE declared %<constexpr%>",
10857 constexpr_p
= false;
10859 decl
= build_decl (input_location
,
10860 FIELD_DECL
, unqualified_id
, type
);
10861 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10862 if (bitfield
&& !unqualified_id
)
10863 TREE_NO_WARNING (decl
) = 1;
10865 if (storage_class
== sc_mutable
)
10867 DECL_MUTABLE_P (decl
) = 1;
10868 storage_class
= sc_none
;
10873 /* An attempt is being made to initialize a non-static
10874 member. This is new in C++11. */
10875 maybe_warn_cpp0x (CPP0X_NSDMI
);
10877 /* If this has been parsed with static storage class, but
10878 errors forced staticp to be cleared, ensure NSDMI is
10880 if (declspecs
->storage_class
== sc_static
)
10881 DECL_INITIAL (decl
) = error_mark_node
;
10885 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10886 memfn_quals
!= TYPE_UNQUALIFIED
,
10887 inlinep
, friendp
, raises
!= NULL_TREE
);
10890 else if (TREE_CODE (type
) == FUNCTION_TYPE
10891 || TREE_CODE (type
) == METHOD_TYPE
)
10893 tree original_name
;
10896 if (!unqualified_id
)
10897 return error_mark_node
;
10899 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10900 original_name
= dname
;
10902 original_name
= unqualified_id
;
10904 if (storage_class
== sc_auto
)
10905 error ("storage class %<auto%> invalid for function %qs", name
);
10906 else if (storage_class
== sc_register
)
10907 error ("storage class %<register%> invalid for function %qs", name
);
10910 if (declspecs
->gnu_thread_keyword_p
)
10911 error ("storage class %<__thread%> invalid for function %qs",
10914 error ("storage class %<thread_local%> invalid for function %qs",
10918 if (virt_specifiers
)
10919 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10920 /* Function declaration not at top level.
10921 Storage classes other than `extern' are not allowed
10922 and `extern' makes no difference. */
10923 if (! toplevel_bindings_p ()
10924 && (storage_class
== sc_static
10925 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10928 if (storage_class
== sc_static
)
10929 pedwarn (input_location
, OPT_Wpedantic
,
10930 "%<static%> specified invalid for function %qs "
10931 "declared out of global scope", name
);
10933 pedwarn (input_location
, OPT_Wpedantic
,
10934 "%<inline%> specifier invalid for function %qs "
10935 "declared out of global scope", name
);
10938 if (ctype
== NULL_TREE
)
10942 error ("virtual non-class function %qs", name
);
10945 else if (sfk
== sfk_constructor
10946 || sfk
== sfk_destructor
)
10948 error (funcdef_flag
10949 ? G_("%qs defined in a non-class scope")
10950 : G_("%qs declared in a non-class scope"), name
);
10955 /* Record whether the function is public. */
10956 publicp
= (ctype
!= NULL_TREE
10957 || storage_class
!= sc_static
);
10959 if (late_return_type_p
)
10960 TYPE_HAS_LATE_RETURN_TYPE (type
) = 1;
10962 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10963 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10965 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10967 template_count
, in_namespace
, attrlist
,
10968 declarator
->id_loc
);
10969 if (decl
== NULL_TREE
)
10970 return error_mark_node
;
10974 int invalid_static
= 0;
10976 /* Don't allow a static member function in a class, and forbid
10977 declaring main to be static. */
10978 if (TREE_CODE (type
) == METHOD_TYPE
)
10980 permerror (input_location
, "cannot declare member function %qD to have "
10981 "static linkage", decl
);
10982 invalid_static
= 1;
10984 else if (current_function_decl
)
10986 /* FIXME need arm citation */
10987 error ("cannot declare static function inside another function");
10988 invalid_static
= 1;
10991 if (invalid_static
)
10994 storage_class
= sc_none
;
11000 /* It's a variable. */
11002 /* An uninitialized decl with `extern' is a reference. */
11003 decl
= grokvardecl (type
, dname
, unqualified_id
,
11006 (type_quals
& TYPE_QUAL_CONST
) != 0,
11008 ctype
? ctype
: in_namespace
);
11009 if (decl
== NULL_TREE
)
11010 return error_mark_node
;
11012 bad_specifiers (decl
, BSP_VAR
, virtualp
,
11013 memfn_quals
!= TYPE_UNQUALIFIED
,
11014 inlinep
, friendp
, raises
!= NULL_TREE
);
11018 DECL_CONTEXT (decl
) = ctype
;
11021 permerror (input_location
, "%<static%> may not be used when defining "
11022 "(as opposed to declaring) a static data member");
11024 storage_class
= sc_none
;
11026 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
11028 error ("static member %qD declared %<register%>", decl
);
11029 storage_class
= sc_none
;
11031 if (storage_class
== sc_extern
&& pedantic
)
11033 pedwarn (input_location
, OPT_Wpedantic
,
11034 "cannot explicitly declare member %q#D to have "
11035 "extern linkage", decl
);
11036 storage_class
= sc_none
;
11039 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
11041 error ("declaration of constexpr variable %qD is not a definition",
11043 constexpr_p
= false;
11047 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
11049 if (toplevel_bindings_p ())
11051 /* It's common practice (and completely valid) to have a const
11052 be initialized and declared extern. */
11053 if (!(type_quals
& TYPE_QUAL_CONST
))
11054 warning (0, "%qs initialized and declared %<extern%>", name
);
11058 error ("%qs has both %<extern%> and initializer", name
);
11059 return error_mark_node
;
11063 /* Record `register' declaration for warnings on &
11064 and in case doing stupid register allocation. */
11066 if (storage_class
== sc_register
)
11067 DECL_REGISTER (decl
) = 1;
11068 else if (storage_class
== sc_extern
)
11069 DECL_THIS_EXTERN (decl
) = 1;
11070 else if (storage_class
== sc_static
)
11071 DECL_THIS_STATIC (decl
) = 1;
11073 /* Set constexpr flag on vars (functions got it in grokfndecl). */
11074 if (constexpr_p
&& VAR_P (decl
))
11075 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
11077 /* Record constancy and volatility on the DECL itself . There's
11078 no need to do this when processing a template; we'll do this
11079 for the instantiated declaration based on the type of DECL. */
11080 if (!processing_template_decl
)
11081 cp_apply_type_quals_to_decl (type_quals
, decl
);
11087 /* Subroutine of start_function. Ensure that each of the parameter
11088 types (as listed in PARMS) is complete, as is required for a
11089 function definition. */
11092 require_complete_types_for_parms (tree parms
)
11094 for (; parms
; parms
= DECL_CHAIN (parms
))
11096 if (dependent_type_p (TREE_TYPE (parms
)))
11098 if (!VOID_TYPE_P (TREE_TYPE (parms
))
11099 && complete_type_or_else (TREE_TYPE (parms
), parms
))
11101 relayout_decl (parms
);
11102 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
11105 /* grokparms or complete_type_or_else will have already issued
11107 TREE_TYPE (parms
) = error_mark_node
;
11111 /* Returns nonzero if T is a local variable. */
11114 local_variable_p (const_tree t
)
11117 /* A VAR_DECL with a context that is a _TYPE is a static data
11119 && !TYPE_P (CP_DECL_CONTEXT (t
))
11120 /* Any other non-local variable must be at namespace scope. */
11121 && !DECL_NAMESPACE_SCOPE_P (t
))
11122 || (TREE_CODE (t
) == PARM_DECL
))
11128 /* Like local_variable_p, but suitable for use as a tree-walking
11132 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
11135 if (local_variable_p (*tp
)
11136 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
11138 else if (TYPE_P (*tp
))
11139 *walk_subtrees
= 0;
11144 /* Check that ARG, which is a default-argument expression for a
11145 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
11146 something goes wrong. DECL may also be a _TYPE node, rather than a
11147 DECL, if there is no DECL available. */
11150 check_default_argument (tree decl
, tree arg
, tsubst_flags_t complain
)
11155 if (TREE_CODE (arg
) == DEFAULT_ARG
)
11156 /* We get a DEFAULT_ARG when looking at an in-class declaration
11157 with a default argument. Ignore the argument for now; we'll
11158 deal with it after the class is complete. */
11167 decl_type
= TREE_TYPE (decl
);
11169 if (arg
== error_mark_node
11170 || decl
== error_mark_node
11171 || TREE_TYPE (arg
) == error_mark_node
11172 || decl_type
== error_mark_node
)
11173 /* Something already went wrong. There's no need to check
11175 return error_mark_node
;
11177 /* [dcl.fct.default]
11179 A default argument expression is implicitly converted to the
11181 ++cp_unevaluated_operand
;
11182 perform_implicit_conversion_flags (decl_type
, arg
, complain
,
11184 --cp_unevaluated_operand
;
11186 if (warn_zero_as_null_pointer_constant
11187 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
11188 && null_ptr_cst_p (arg
)
11189 && (complain
& tf_warning
)
11190 && maybe_warn_zero_as_null_pointer_constant (arg
, input_location
))
11191 return nullptr_node
;
11193 /* [dcl.fct.default]
11195 Local variables shall not be used in default argument
11198 The keyword `this' shall not be used in a default argument of a
11199 member function. */
11200 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
11203 if (complain
& tf_warning_or_error
)
11205 if (DECL_NAME (var
) == this_identifier
)
11206 permerror (input_location
, "default argument %qE uses %qD",
11209 error ("default argument %qE uses local variable %qD", arg
, var
);
11211 return error_mark_node
;
11218 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
11221 type_is_deprecated (tree type
)
11223 enum tree_code code
;
11224 if (TREE_DEPRECATED (type
))
11226 if (TYPE_NAME (type
)
11227 && TREE_DEPRECATED (TYPE_NAME (type
)))
11230 /* Do warn about using typedefs to a deprecated class. */
11231 if (OVERLOAD_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
11232 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
11234 code
= TREE_CODE (type
);
11236 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
11237 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
11238 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
11239 return type_is_deprecated (TREE_TYPE (type
));
11241 if (TYPE_PTRMEMFUNC_P (type
))
11242 return type_is_deprecated
11243 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
11248 /* Decode the list of parameter types for a function type.
11249 Given the list of things declared inside the parens,
11250 return a list of types.
11252 If this parameter does not end with an ellipsis, we append
11255 *PARMS is set to the chain of PARM_DECLs created. */
11258 grokparms (tree parmlist
, tree
*parms
)
11260 tree result
= NULL_TREE
;
11261 tree decls
= NULL_TREE
;
11265 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
11267 tree type
= NULL_TREE
;
11268 tree init
= TREE_PURPOSE (parm
);
11269 tree decl
= TREE_VALUE (parm
);
11270 const char *errmsg
;
11272 if (parm
== void_list_node
)
11275 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
11278 type
= TREE_TYPE (decl
);
11279 if (VOID_TYPE_P (type
))
11281 if (same_type_p (type
, void_type_node
)
11283 && !DECL_NAME (decl
) && !result
11284 && TREE_CHAIN (parm
) == void_list_node
)
11285 /* DR 577: A parameter list consisting of a single
11286 unnamed parameter of non-dependent type 'void'. */
11288 else if (cv_qualified_p (type
))
11289 error_at (DECL_SOURCE_LOCATION (decl
),
11290 "invalid use of cv-qualified type %qT in "
11291 "parameter declaration", type
);
11293 error_at (DECL_SOURCE_LOCATION (decl
),
11294 "invalid use of type %<void%> in parameter "
11296 /* It's not a good idea to actually create parameters of
11297 type `void'; other parts of the compiler assume that a
11298 void type terminates the parameter list. */
11299 type
= error_mark_node
;
11300 TREE_TYPE (decl
) = error_mark_node
;
11303 if (type
!= error_mark_node
11304 && TYPE_FOR_JAVA (type
)
11305 && MAYBE_CLASS_TYPE_P (type
))
11307 error ("parameter %qD has Java class type", decl
);
11308 type
= error_mark_node
;
11309 TREE_TYPE (decl
) = error_mark_node
;
11313 if (type
!= error_mark_node
11314 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11317 type
= error_mark_node
;
11318 TREE_TYPE (decl
) = error_mark_node
;
11321 if (type
!= error_mark_node
)
11323 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11325 tree deptype
= type_is_deprecated (type
);
11327 warn_deprecated_use (deptype
, NULL_TREE
);
11330 /* Top-level qualifiers on the parameters are
11331 ignored for function types. */
11332 type
= cp_build_qualified_type (type
, 0);
11333 if (TREE_CODE (type
) == METHOD_TYPE
)
11335 error ("parameter %qD invalidly declared method type", decl
);
11336 type
= build_pointer_type (type
);
11337 TREE_TYPE (decl
) = type
;
11339 else if (abstract_virtuals_error (decl
, type
))
11340 any_error
= 1; /* Seems like a good idea. */
11341 else if (POINTER_TYPE_P (type
))
11343 /* [dcl.fct]/6, parameter types cannot contain pointers
11344 (references) to arrays of unknown bound. */
11345 tree t
= TREE_TYPE (type
);
11346 int ptr
= TYPE_PTR_P (type
);
11350 if (TYPE_PTR_P (t
))
11352 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11354 else if (!TYPE_DOMAIN (t
))
11358 if (TREE_CODE (t
) == ARRAY_TYPE
)
11360 ? G_("parameter %qD includes pointer to array of "
11361 "unknown bound %qT")
11362 : G_("parameter %qD includes reference to array of "
11363 "unknown bound %qT"),
11369 else if (init
&& !processing_template_decl
)
11370 init
= check_default_argument (decl
, init
, tf_warning_or_error
);
11373 DECL_CHAIN (decl
) = decls
;
11375 result
= tree_cons (init
, type
, result
);
11377 decls
= nreverse (decls
);
11378 result
= nreverse (result
);
11380 result
= chainon (result
, void_list_node
);
11387 /* D is a constructor or overloaded `operator='.
11389 Let T be the class in which D is declared. Then, this function
11392 -1 if D's is an ill-formed constructor or copy assignment operator
11393 whose first parameter is of type `T'.
11394 0 if D is not a copy constructor or copy assignment
11396 1 if D is a copy constructor or copy assignment operator whose
11397 first parameter is a reference to non-const qualified T.
11398 2 if D is a copy constructor or copy assignment operator whose
11399 first parameter is a reference to const qualified T.
11401 This function can be used as a predicate. Positive values indicate
11402 a copy constructor and nonzero values indicate a copy assignment
11406 copy_fn_p (const_tree d
)
11412 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11414 if (TREE_CODE (d
) == TEMPLATE_DECL
11415 || (DECL_TEMPLATE_INFO (d
)
11416 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11417 /* Instantiations of template member functions are never copy
11418 functions. Note that member functions of templated classes are
11419 represented as template functions internally, and we must
11420 accept those as copy functions. */
11423 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11427 arg_type
= TREE_VALUE (args
);
11428 if (arg_type
== error_mark_node
)
11431 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11433 /* Pass by value copy assignment operator. */
11436 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11437 && !TYPE_REF_IS_RVALUE (arg_type
)
11438 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11440 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11446 args
= TREE_CHAIN (args
);
11448 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11449 /* There are more non-optional args. */
11455 /* D is a constructor or overloaded `operator='.
11457 Let T be the class in which D is declared. Then, this function
11458 returns true when D is a move constructor or move assignment
11459 operator, false otherwise. */
11462 move_fn_p (const_tree d
)
11464 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11466 if (cxx_dialect
== cxx98
)
11467 /* There are no move constructors if we are in C++98 mode. */
11470 if (TREE_CODE (d
) == TEMPLATE_DECL
11471 || (DECL_TEMPLATE_INFO (d
)
11472 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11473 /* Instantiations of template member functions are never move
11474 functions. Note that member functions of templated classes are
11475 represented as template functions internally, and we must
11476 accept those as move functions. */
11479 return move_signature_fn_p (d
);
11482 /* D is a constructor or overloaded `operator='.
11484 Then, this function returns true when D has the same signature as a move
11485 constructor or move assignment operator (because either it is such a
11486 ctor/op= or it is a template specialization with the same signature),
11487 false otherwise. */
11490 move_signature_fn_p (const_tree d
)
11494 bool result
= false;
11496 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11500 arg_type
= TREE_VALUE (args
);
11501 if (arg_type
== error_mark_node
)
11504 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11505 && TYPE_REF_IS_RVALUE (arg_type
)
11506 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11510 args
= TREE_CHAIN (args
);
11512 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11513 /* There are more non-optional args. */
11519 /* Remember any special properties of member function DECL. */
11522 grok_special_member_properties (tree decl
)
11526 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11529 class_type
= DECL_CONTEXT (decl
);
11530 if (DECL_CONSTRUCTOR_P (decl
))
11532 int ctor
= copy_fn_p (decl
);
11534 if (!DECL_ARTIFICIAL (decl
))
11535 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11541 A non-template constructor for class X is a copy
11542 constructor if its first parameter is of type X&, const
11543 X&, volatile X& or const volatile X&, and either there
11544 are no other parameters or else all other parameters have
11545 default arguments. */
11546 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11547 if (user_provided_p (decl
))
11548 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11550 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11552 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11553 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11554 else if (move_fn_p (decl
) && user_provided_p (decl
))
11555 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11556 else if (is_list_ctor (decl
))
11557 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11559 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11560 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11561 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11563 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11567 A non-template assignment operator for class X is a copy
11568 assignment operator if its parameter is of type X, X&, const
11569 X&, volatile X& or const volatile X&. */
11571 int assop
= copy_fn_p (decl
);
11575 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11576 if (user_provided_p (decl
))
11577 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11579 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11581 else if (move_fn_p (decl
) && user_provided_p (decl
))
11582 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11584 /* Destructors are handled in check_methods. */
11587 /* Check a constructor DECL has the correct form. Complains
11588 if the class has a constructor of the form X(X). */
11591 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11593 int ctor_parm
= copy_fn_p (decl
);
11599 A declaration of a constructor for a class X is ill-formed if
11600 its first parameter is of type (optionally cv-qualified) X
11601 and either there are no other parameters or else all other
11602 parameters have default arguments.
11604 We *don't* complain about member template instantiations that
11605 have this form, though; they can occur as we try to decide
11606 what constructor to use during overload resolution. Since
11607 overload resolution will never prefer such a constructor to
11608 the non-template copy constructor (which is either explicitly
11609 or implicitly defined), there's no need to worry about their
11610 existence. Theoretically, they should never even be
11611 instantiated, but that's hard to forestall. */
11612 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11620 /* An operator with this code is unary, but can also be binary. */
11623 ambi_op_p (enum tree_code code
)
11625 return (code
== INDIRECT_REF
11626 || code
== ADDR_EXPR
11627 || code
== UNARY_PLUS_EXPR
11628 || code
== NEGATE_EXPR
11629 || code
== PREINCREMENT_EXPR
11630 || code
== PREDECREMENT_EXPR
);
11633 /* An operator with this name can only be unary. */
11636 unary_op_p (enum tree_code code
)
11638 return (code
== TRUTH_NOT_EXPR
11639 || code
== BIT_NOT_EXPR
11640 || code
== COMPONENT_REF
11641 || code
== TYPE_EXPR
);
11644 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11645 errors are issued for invalid declarations. */
11648 grok_op_properties (tree decl
, bool complain
)
11650 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11652 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11653 tree name
= DECL_NAME (decl
);
11654 enum tree_code operator_code
;
11659 /* Count the number of arguments and check for ellipsis. */
11660 for (argtype
= argtypes
, arity
= 0;
11661 argtype
&& argtype
!= void_list_node
;
11662 argtype
= TREE_CHAIN (argtype
))
11664 ellipsis_p
= !argtype
;
11666 class_type
= DECL_CONTEXT (decl
);
11667 if (class_type
&& !CLASS_TYPE_P (class_type
))
11668 class_type
= NULL_TREE
;
11670 if (DECL_CONV_FN_P (decl
))
11671 operator_code
= TYPE_EXPR
;
11675 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11676 if (ansi_opname (CODE) == name) \
11678 operator_code = (CODE); \
11681 else if (ansi_assopname (CODE) == name) \
11683 operator_code = (CODE); \
11684 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11688 #include "operators.def"
11689 #undef DEF_OPERATOR
11691 gcc_unreachable ();
11694 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11695 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11698 switch (operator_code
)
11701 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11705 TYPE_GETS_DELETE (class_type
) |= 1;
11709 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11712 case VEC_DELETE_EXPR
:
11713 TYPE_GETS_DELETE (class_type
) |= 2;
11720 /* [basic.std.dynamic.allocation]/1:
11722 A program is ill-formed if an allocation function is declared
11723 in a namespace scope other than global scope or declared static
11726 The same also holds true for deallocation functions. */
11727 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11728 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11730 if (DECL_NAMESPACE_SCOPE_P (decl
))
11732 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11734 error ("%qD may not be declared within a namespace", decl
);
11737 else if (!TREE_PUBLIC (decl
))
11739 error ("%qD may not be declared as static", decl
);
11745 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11747 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11748 DECL_IS_OPERATOR_NEW (decl
) = 1;
11750 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11751 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11754 /* An operator function must either be a non-static member function
11755 or have at least one parameter of a class, a reference to a class,
11756 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11757 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11759 if (operator_code
== TYPE_EXPR
11760 || operator_code
== CALL_EXPR
11761 || operator_code
== COMPONENT_REF
11762 || operator_code
== ARRAY_REF
11763 || operator_code
== NOP_EXPR
)
11765 error ("%qD must be a nonstatic member function", decl
);
11772 if (DECL_STATIC_FUNCTION_P (decl
))
11774 error ("%qD must be either a non-static member "
11775 "function or a non-member function", decl
);
11779 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11781 tree arg
= non_reference (TREE_VALUE (p
));
11782 if (arg
== error_mark_node
)
11785 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11786 because these checks are performed even on
11787 template functions. */
11788 if (MAYBE_CLASS_TYPE_P (arg
)
11789 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11793 if (!p
|| p
== void_list_node
)
11796 error ("%qD must have an argument of class or "
11797 "enumerated type", decl
);
11803 /* There are no restrictions on the arguments to an overloaded
11805 if (operator_code
== CALL_EXPR
)
11808 /* Warn about conversion operators that will never be used. */
11809 if (IDENTIFIER_TYPENAME_P (name
)
11810 && ! DECL_TEMPLATE_INFO (decl
)
11812 /* Warn only declaring the function; there is no need to
11813 warn again about out-of-class definitions. */
11814 && class_type
== current_class_type
)
11816 tree t
= TREE_TYPE (name
);
11817 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11820 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11822 if (VOID_TYPE_P (t
))
11823 warning (OPT_Wconversion
,
11825 ? G_("conversion to a reference to void "
11826 "will never use a type conversion operator")
11827 : G_("conversion to void "
11828 "will never use a type conversion operator"));
11829 else if (class_type
)
11831 if (t
== class_type
)
11832 warning (OPT_Wconversion
,
11834 ? G_("conversion to a reference to the same type "
11835 "will never use a type conversion operator")
11836 : G_("conversion to the same type "
11837 "will never use a type conversion operator"));
11838 /* Don't force t to be complete here. */
11839 else if (MAYBE_CLASS_TYPE_P (t
)
11840 && COMPLETE_TYPE_P (t
)
11841 && DERIVED_FROM_P (t
, class_type
))
11842 warning (OPT_Wconversion
,
11844 ? G_("conversion to a reference to a base class "
11845 "will never use a type conversion operator")
11846 : G_("conversion to a base class "
11847 "will never use a type conversion operator"));
11852 if (operator_code
== COND_EXPR
)
11855 error ("ISO C++ prohibits overloading operator ?:");
11858 else if (ellipsis_p
)
11860 error ("%qD must not have variable number of arguments", decl
);
11863 else if (ambi_op_p (operator_code
))
11866 /* We pick the one-argument operator codes by default, so
11867 we don't have to change anything. */
11869 else if (arity
== 2)
11871 /* If we thought this was a unary operator, we now know
11872 it to be a binary operator. */
11873 switch (operator_code
)
11876 operator_code
= MULT_EXPR
;
11880 operator_code
= BIT_AND_EXPR
;
11883 case UNARY_PLUS_EXPR
:
11884 operator_code
= PLUS_EXPR
;
11888 operator_code
= MINUS_EXPR
;
11891 case PREINCREMENT_EXPR
:
11892 operator_code
= POSTINCREMENT_EXPR
;
11895 case PREDECREMENT_EXPR
:
11896 operator_code
= POSTDECREMENT_EXPR
;
11900 gcc_unreachable ();
11903 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11905 if ((operator_code
== POSTINCREMENT_EXPR
11906 || operator_code
== POSTDECREMENT_EXPR
)
11907 && ! processing_template_decl
11908 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11911 error ("postfix %qD must take %<int%> as its argument",
11914 error ("postfix %qD must take %<int%> as its second "
11922 error ("%qD must take either zero or one argument", decl
);
11924 error ("%qD must take either one or two arguments", decl
);
11928 /* More Effective C++ rule 6. */
11930 && (operator_code
== POSTINCREMENT_EXPR
11931 || operator_code
== POSTDECREMENT_EXPR
11932 || operator_code
== PREINCREMENT_EXPR
11933 || operator_code
== PREDECREMENT_EXPR
))
11935 tree arg
= TREE_VALUE (argtypes
);
11936 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11937 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11938 arg
= TREE_TYPE (arg
);
11939 arg
= TYPE_MAIN_VARIANT (arg
);
11940 if (operator_code
== PREINCREMENT_EXPR
11941 || operator_code
== PREDECREMENT_EXPR
)
11943 if (TREE_CODE (ret
) != REFERENCE_TYPE
11944 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11946 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11947 build_reference_type (arg
));
11951 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11952 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11956 else if (unary_op_p (operator_code
))
11961 error ("%qD must take %<void%>", decl
);
11963 error ("%qD must take exactly one argument", decl
);
11967 else /* if (binary_op_p (operator_code)) */
11972 error ("%qD must take exactly one argument", decl
);
11974 error ("%qD must take exactly two arguments", decl
);
11978 /* More Effective C++ rule 7. */
11980 && (operator_code
== TRUTH_ANDIF_EXPR
11981 || operator_code
== TRUTH_ORIF_EXPR
11982 || operator_code
== COMPOUND_EXPR
))
11983 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11987 /* Effective C++ rule 23. */
11990 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11991 && (operator_code
== PLUS_EXPR
11992 || operator_code
== MINUS_EXPR
11993 || operator_code
== TRUNC_DIV_EXPR
11994 || operator_code
== MULT_EXPR
11995 || operator_code
== TRUNC_MOD_EXPR
)
11996 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11997 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11999 /* [over.oper]/8 */
12000 for (; argtypes
&& argtypes
!= void_list_node
;
12001 argtypes
= TREE_CHAIN (argtypes
))
12002 if (TREE_PURPOSE (argtypes
))
12004 TREE_PURPOSE (argtypes
) = NULL_TREE
;
12005 if (operator_code
== POSTINCREMENT_EXPR
12006 || operator_code
== POSTDECREMENT_EXPR
)
12008 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
12013 error ("%qD cannot have default arguments", decl
);
12021 /* Return a string giving the keyword associate with CODE. */
12023 static const char *
12024 tag_name (enum tag_types code
)
12036 case typename_type
:
12039 gcc_unreachable ();
12043 /* Name lookup in an elaborated-type-specifier (after the keyword
12044 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
12045 elaborated-type-specifier is invalid, issue a diagnostic and return
12046 error_mark_node; otherwise, return the *_TYPE to which it referred.
12047 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
12050 check_elaborated_type_specifier (enum tag_types tag_code
,
12052 bool allow_template_p
)
12058 struct S { struct S *p; };
12060 name lookup will find the TYPE_DECL for the implicit "S::S"
12061 typedef. Adjust for that here. */
12062 if (DECL_SELF_REFERENCE_P (decl
))
12063 decl
= TYPE_NAME (TREE_TYPE (decl
));
12065 type
= TREE_TYPE (decl
);
12067 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
12068 is false for this case as well. */
12069 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
12071 error ("using template type parameter %qT after %qs",
12072 type
, tag_name (tag_code
));
12073 return error_mark_node
;
12075 /* Accept template template parameters. */
12076 else if (allow_template_p
12077 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
12078 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
12082 If the identifier resolves to a typedef-name or the
12083 simple-template-id resolves to an alias template
12084 specialization, the elaborated-type-specifier is ill-formed.
12086 In other words, the only legitimate declaration to use in the
12087 elaborated type specifier is the implicit typedef created when
12088 the type is declared. */
12089 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
12090 && !DECL_SELF_REFERENCE_P (decl
)
12091 && tag_code
!= typename_type
)
12093 if (alias_template_specialization_p (type
))
12094 error ("using alias template specialization %qT after %qs",
12095 type
, tag_name (tag_code
));
12097 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
12098 inform (DECL_SOURCE_LOCATION (decl
),
12099 "%qD has a previous declaration here", decl
);
12100 return error_mark_node
;
12102 else if (TREE_CODE (type
) != RECORD_TYPE
12103 && TREE_CODE (type
) != UNION_TYPE
12104 && tag_code
!= enum_type
12105 && tag_code
!= typename_type
)
12107 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
12108 inform (input_location
, "%q+T has a previous declaration here", type
);
12109 return error_mark_node
;
12111 else if (TREE_CODE (type
) != ENUMERAL_TYPE
12112 && tag_code
== enum_type
)
12114 error ("%qT referred to as enum", type
);
12115 inform (input_location
, "%q+T has a previous declaration here", type
);
12116 return error_mark_node
;
12118 else if (!allow_template_p
12119 && TREE_CODE (type
) == RECORD_TYPE
12120 && CLASSTYPE_IS_TEMPLATE (type
))
12122 /* If a class template appears as elaborated type specifier
12123 without a template header such as:
12125 template <class T> class C {};
12126 void f(class C); // No template header here
12128 then the required template argument is missing. */
12129 error ("template argument required for %<%s %T%>",
12130 tag_name (tag_code
),
12131 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
12132 return error_mark_node
;
12138 /* Lookup NAME in elaborate type specifier in scope according to
12139 SCOPE and issue diagnostics if necessary.
12140 Return *_TYPE node upon success, NULL_TREE when the NAME is not
12141 found, and ERROR_MARK_NODE for type error. */
12144 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
12145 tag_scope scope
, bool template_header_p
)
12149 if (scope
== ts_global
)
12151 /* First try ordinary name lookup, ignoring hidden class name
12152 injected via friend declaration. */
12153 decl
= lookup_name_prefer_type (name
, 2);
12154 /* If that fails, the name will be placed in the smallest
12155 non-class, non-function-prototype scope according to 3.3.1/5.
12156 We may already have a hidden name declared as friend in this
12157 scope. So lookup again but not ignoring hidden names.
12158 If we find one, that name will be made visible rather than
12159 creating a new tag. */
12161 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
12164 decl
= lookup_type_scope (name
, scope
);
12167 && (DECL_CLASS_TEMPLATE_P (decl
)
12168 /* If scope is ts_current we're defining a class, so ignore a
12169 template template parameter. */
12170 || (scope
!= ts_current
12171 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl
))))
12172 decl
= DECL_TEMPLATE_RESULT (decl
);
12174 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
12176 /* Look for invalid nested type:
12180 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
12182 error ("%qD has the same name as the class in which it is "
12185 return error_mark_node
;
12188 /* Two cases we need to consider when deciding if a class
12189 template is allowed as an elaborated type specifier:
12190 1. It is a self reference to its own class.
12191 2. It comes with a template header.
12195 template <class T> class C {
12196 class C *c1; // DECL_SELF_REFERENCE_P is true
12199 template <class U> class C; // template_header_p is true
12200 template <class T> class C<T>::D {
12201 class C *c2; // DECL_SELF_REFERENCE_P is true
12204 t
= check_elaborated_type_specifier (tag_code
,
12207 | DECL_SELF_REFERENCE_P (decl
));
12210 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
12212 error ("reference to %qD is ambiguous", name
);
12213 print_candidates (decl
);
12214 return error_mark_node
;
12220 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
12221 Define the tag as a forward-reference if it is not defined.
12223 If a declaration is given, process it here, and report an error if
12224 multiple declarations are not identical.
12226 SCOPE is TS_CURRENT when this is also a definition. Only look in
12227 the current frame for the name (since C++ allows new names in any
12228 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
12229 declaration. Only look beginning from the current scope outward up
12230 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
12232 TEMPLATE_HEADER_P is true when this declaration is preceded by
12233 a set of template parameters. */
12236 xref_tag_1 (enum tag_types tag_code
, tree name
,
12237 tag_scope orig_scope
, bool template_header_p
)
12239 enum tree_code code
;
12241 tree context
= NULL_TREE
;
12244 gcc_assert (identifier_p (name
));
12250 code
= RECORD_TYPE
;
12256 code
= ENUMERAL_TYPE
;
12259 gcc_unreachable ();
12262 if (orig_scope
== ts_lambda
)
12263 scope
= ts_current
;
12265 scope
= orig_scope
;
12267 /* In case of anonymous name, xref_tag is only called to
12268 make type node and push name. Name lookup is not required. */
12269 if (ANON_AGGRNAME_P (name
))
12272 t
= lookup_and_check_tag (tag_code
, name
,
12273 scope
, template_header_p
);
12275 if (t
== error_mark_node
)
12276 return error_mark_node
;
12278 if (scope
!= ts_current
&& t
&& current_class_type
12279 && template_class_depth (current_class_type
)
12280 && template_header_p
)
12282 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
12285 /* Since SCOPE is not TS_CURRENT, we are not looking at a
12286 definition of this tag. Since, in addition, we are currently
12287 processing a (member) template declaration of a template
12288 class, we must be very careful; consider:
12295 { template <class V>
12296 friend struct S1; };
12298 Here, the S2::S1 declaration should not be confused with the
12299 outer declaration. In particular, the inner version should
12300 have a template parameter of level 2, not level 1. This
12301 would be particularly important if the member declaration
12304 template <class V = U> friend struct S1;
12306 say, when we should tsubst into `U' when instantiating
12307 S2. On the other hand, when presented with:
12317 we must find the inner binding eventually. We
12318 accomplish this by making sure that the new type we
12319 create to represent this declaration has the right
12321 context
= TYPE_CONTEXT (t
);
12327 /* If no such tag is yet defined, create a forward-reference node
12328 and record it as the "definition".
12329 When a real declaration of this type is found,
12330 the forward-reference will be altered into a real type. */
12331 if (code
== ENUMERAL_TYPE
)
12333 error ("use of enum %q#D without previous declaration", name
);
12334 return error_mark_node
;
12338 t
= make_class_type (code
);
12339 TYPE_CONTEXT (t
) = context
;
12340 if (orig_scope
== ts_lambda
)
12341 /* Remember that we're declaring a lambda to avoid bogus errors
12342 in push_template_decl. */
12343 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12344 t
= pushtag (name
, t
, scope
);
12349 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12351 if (!redeclare_class_template (t
, current_template_parms
))
12352 return error_mark_node
;
12354 else if (!processing_template_decl
12355 && CLASS_TYPE_P (t
)
12356 && CLASSTYPE_IS_TEMPLATE (t
))
12358 error ("redeclaration of %qT as a non-template", t
);
12359 error ("previous declaration %q+D", t
);
12360 return error_mark_node
;
12363 /* Make injected friend class visible. */
12364 if (scope
!= ts_within_enclosing_non_class
12365 && hidden_name_p (TYPE_NAME (t
)))
12367 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12368 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12370 if (TYPE_TEMPLATE_INFO (t
))
12372 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12373 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12381 /* Wrapper for xref_tag_1. */
12384 xref_tag (enum tag_types tag_code
, tree name
,
12385 tag_scope scope
, bool template_header_p
)
12389 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12390 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12391 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12397 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12399 enum tag_types tag_kind
;
12401 if (TREE_CODE (old
) == RECORD_TYPE
)
12402 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12404 tag_kind
= union_type
;
12406 if (id
== NULL_TREE
)
12407 id
= TYPE_IDENTIFIER (old
);
12409 return xref_tag (tag_kind
, id
, scope
, false);
12412 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12413 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12414 access_* node, and the TREE_VALUE is the type of the base-class.
12415 Non-NULL TREE_TYPE indicates virtual inheritance.
12417 Returns true if the binfo hierarchy was successfully created,
12418 false if an error was detected. */
12421 xref_basetypes (tree ref
, tree base_list
)
12424 tree binfo
, base_binfo
;
12425 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12426 unsigned max_bases
= 0; /* Maximum direct bases. */
12428 tree default_access
;
12429 tree igo_prev
; /* Track Inheritance Graph Order. */
12431 if (ref
== error_mark_node
)
12434 /* The base of a derived class is private by default, all others are
12436 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12437 && CLASSTYPE_DECLARED_CLASS (ref
)
12438 ? access_private_node
: access_public_node
);
12440 /* First, make sure that any templates in base-classes are
12441 instantiated. This ensures that if we call ourselves recursively
12442 we do not get confused about which classes are marked and which
12444 basep
= &base_list
;
12447 tree basetype
= TREE_VALUE (*basep
);
12449 /* The dependent_type_p call below should really be dependent_scope_p
12450 so that we give a hard error about using an incomplete type as a
12451 base, but we allow it with a pedwarn for backward
12453 if (processing_template_decl
12454 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12455 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12456 if (!dependent_type_p (basetype
)
12457 && !complete_type_or_else (basetype
, NULL
))
12458 /* An incomplete type. Remove it from the list. */
12459 *basep
= TREE_CHAIN (*basep
);
12463 if (TREE_TYPE (*basep
))
12465 if (CLASS_TYPE_P (basetype
))
12466 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12467 basep
= &TREE_CHAIN (*basep
);
12471 TYPE_MARKED_P (ref
) = 1;
12473 /* The binfo slot should be empty, unless this is an (ill-formed)
12475 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12477 error ("redefinition of %q#T", ref
);
12481 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12483 binfo
= make_tree_binfo (max_bases
);
12485 TYPE_BINFO (ref
) = binfo
;
12486 BINFO_OFFSET (binfo
) = size_zero_node
;
12487 BINFO_TYPE (binfo
) = ref
;
12489 /* Apply base-class info set up to the variants of this type. */
12490 fixup_type_variants (ref
);
12494 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12495 /* An aggregate cannot have baseclasses. */
12496 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12498 if (TREE_CODE (ref
) == UNION_TYPE
)
12500 error ("derived union %qT invalid", ref
);
12507 if (TYPE_FOR_JAVA (ref
))
12509 error ("Java class %qT cannot have multiple bases", ref
);
12516 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12518 if (TYPE_FOR_JAVA (ref
))
12520 error ("Java class %qT cannot have virtual bases", ref
);
12525 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12527 tree access
= TREE_PURPOSE (base_list
);
12528 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12529 tree basetype
= TREE_VALUE (base_list
);
12531 if (access
== access_default_node
)
12532 access
= default_access
;
12534 if (PACK_EXPANSION_P (basetype
))
12535 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12536 if (TREE_CODE (basetype
) == TYPE_DECL
)
12537 basetype
= TREE_TYPE (basetype
);
12538 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12540 error ("base type %qT fails to be a struct or class type",
12545 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12546 TYPE_FOR_JAVA (ref
) = 1;
12548 base_binfo
= NULL_TREE
;
12549 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12551 base_binfo
= TYPE_BINFO (basetype
);
12552 /* The original basetype could have been a typedef'd type. */
12553 basetype
= BINFO_TYPE (base_binfo
);
12555 /* Inherit flags from the base. */
12556 TYPE_HAS_NEW_OPERATOR (ref
)
12557 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12558 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12559 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12560 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12561 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12562 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12563 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12564 CLASSTYPE_REPEATED_BASE_P (ref
)
12565 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12568 /* We must do this test after we've seen through a typedef
12570 if (TYPE_MARKED_P (basetype
))
12572 if (basetype
== ref
)
12573 error ("recursive type %qT undefined", basetype
);
12575 error ("duplicate base type %qT invalid", basetype
);
12579 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12580 /* Regenerate the pack expansion for the bases. */
12581 basetype
= make_pack_expansion (basetype
);
12583 TYPE_MARKED_P (basetype
) = 1;
12585 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12586 &igo_prev
, via_virtual
);
12587 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12588 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12590 BINFO_BASE_APPEND (binfo
, base_binfo
);
12591 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12594 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12595 /* If we didn't get max_vbases vbases, we must have shared at
12596 least one of them, and are therefore diamond shaped. */
12597 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12599 /* Unmark all the types. */
12600 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12601 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12602 TYPE_MARKED_P (ref
) = 0;
12604 /* Now see if we have a repeated base type. */
12605 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12607 for (base_binfo
= binfo
; base_binfo
;
12608 base_binfo
= TREE_CHAIN (base_binfo
))
12610 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12612 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12615 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12617 for (base_binfo
= binfo
; base_binfo
;
12618 base_binfo
= TREE_CHAIN (base_binfo
))
12619 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12620 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12629 /* Copies the enum-related properties from type SRC to type DST.
12630 Used with the underlying type of an enum and the enum itself. */
12632 copy_type_enum (tree dst
, tree src
)
12635 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12637 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12638 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12639 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12640 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12641 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12642 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12643 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12644 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12645 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12649 /* Begin compiling the definition of an enumeration type.
12652 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12654 UNDERLYING_TYPE is the type that will be used as the storage for
12655 the enumeration type. This should be NULL_TREE if no storage type
12658 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12660 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12662 Returns the type object, as yet incomplete.
12663 Also records info about it so that build_enumerator
12664 may be used to declare the individual values as they are read. */
12667 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12668 bool scoped_enum_p
, bool *is_new
)
12670 tree prevtype
= NULL_TREE
;
12671 gcc_assert (identifier_p (name
));
12675 /* [C++0x dcl.enum]p5:
12677 If not explicitly specified, the underlying type of a scoped
12678 enumeration type is int. */
12679 if (!underlying_type
&& scoped_enum_p
)
12680 underlying_type
= integer_type_node
;
12682 if (underlying_type
)
12683 underlying_type
= cv_unqualified (underlying_type
);
12685 /* If this is the real definition for a previous forward reference,
12686 fill in the contents in the same object that used to be the
12687 forward reference. */
12689 enumtype
= lookup_and_check_tag (enum_type
, name
,
12690 /*tag_scope=*/ts_current
,
12691 /*template_header_p=*/false);
12693 /* In case of a template_decl, the only check that should be deferred
12694 to instantiation time is the comparison of underlying types. */
12695 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12697 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12699 error_at (input_location
, "scoped/unscoped mismatch "
12700 "in enum %q#T", enumtype
);
12701 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12702 "previous definition here");
12703 enumtype
= error_mark_node
;
12705 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12707 error_at (input_location
, "underlying type mismatch "
12708 "in enum %q#T", enumtype
);
12709 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12710 "previous definition here");
12711 enumtype
= error_mark_node
;
12713 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12714 && !dependent_type_p (underlying_type
)
12715 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12716 && !same_type_p (underlying_type
,
12717 ENUM_UNDERLYING_TYPE (enumtype
)))
12719 error_at (input_location
, "different underlying type "
12720 "in enum %q#T", enumtype
);
12721 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12722 "previous definition here");
12723 underlying_type
= NULL_TREE
;
12727 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12728 || processing_template_decl
)
12730 /* In case of error, make a dummy enum to allow parsing to
12732 if (enumtype
== error_mark_node
)
12734 name
= make_anon_name ();
12735 enumtype
= NULL_TREE
;
12738 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12739 of an opaque enum, or an opaque enum of an already defined
12740 enumeration (C++0x only).
12741 In any other case, it'll be NULL_TREE. */
12747 prevtype
= enumtype
;
12749 /* Do not push the decl more than once, unless we need to
12750 compare underlying types at instantiation time */
12752 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12753 || (underlying_type
12754 && dependent_type_p (underlying_type
))
12755 || (ENUM_UNDERLYING_TYPE (enumtype
)
12756 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12758 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12759 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12762 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12765 if (enumtype
== error_mark_node
)
12766 return error_mark_node
;
12768 /* The enum is considered opaque until the opening '{' of the
12769 enumerator list. */
12770 SET_OPAQUE_ENUM_P (enumtype
, true);
12771 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12774 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12776 if (underlying_type
)
12778 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12780 copy_type_enum (enumtype
, underlying_type
);
12781 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12783 else if (dependent_type_p (underlying_type
))
12784 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12786 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12787 underlying_type
, enumtype
);
12790 /* If into a template class, the returned enum is always the first
12791 declaration (opaque or not) seen. This way all the references to
12792 this type will be to the same declaration. The following ones are used
12793 only to check for definition errors. */
12794 if (prevtype
&& processing_template_decl
)
12800 /* After processing and defining all the values of an enumeration type,
12801 install their decls in the enumeration type.
12802 ENUMTYPE is the type object. */
12805 finish_enum_value_list (tree enumtype
)
12808 tree underlying_type
;
12811 tree minnode
, maxnode
;
12814 bool fixed_underlying_type_p
12815 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12817 /* We built up the VALUES in reverse order. */
12818 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12820 /* For an enum defined in a template, just set the type of the values;
12821 all further processing is postponed until the template is
12822 instantiated. We need to set the type so that tsubst of a CONST_DECL
12824 if (processing_template_decl
)
12826 for (values
= TYPE_VALUES (enumtype
);
12828 values
= TREE_CHAIN (values
))
12829 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12833 /* Determine the minimum and maximum values of the enumerators. */
12834 if (TYPE_VALUES (enumtype
))
12836 minnode
= maxnode
= NULL_TREE
;
12838 for (values
= TYPE_VALUES (enumtype
);
12840 values
= TREE_CHAIN (values
))
12842 decl
= TREE_VALUE (values
);
12844 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12845 each enumerator has the type of its enumeration. Prior to the
12846 closing brace, the type of each enumerator is the type of its
12847 initializing value. */
12848 TREE_TYPE (decl
) = enumtype
;
12850 /* Update the minimum and maximum values, if appropriate. */
12851 value
= DECL_INITIAL (decl
);
12852 if (value
== error_mark_node
)
12853 value
= integer_zero_node
;
12854 /* Figure out what the minimum and maximum values of the
12855 enumerators are. */
12857 minnode
= maxnode
= value
;
12858 else if (tree_int_cst_lt (maxnode
, value
))
12860 else if (tree_int_cst_lt (value
, minnode
))
12867 If the enumerator-list is empty, the underlying type is as if
12868 the enumeration had a single enumerator with value 0. */
12869 minnode
= maxnode
= integer_zero_node
;
12871 if (!fixed_underlying_type_p
)
12873 /* Compute the number of bits require to represent all values of the
12874 enumeration. We must do this before the type of MINNODE and
12875 MAXNODE are transformed, since tree_int_cst_min_precision relies
12876 on the TREE_TYPE of the value it is passed. */
12877 signop sgn
= tree_int_cst_sgn (minnode
) >= 0 ? UNSIGNED
: SIGNED
;
12878 int lowprec
= tree_int_cst_min_precision (minnode
, sgn
);
12879 int highprec
= tree_int_cst_min_precision (maxnode
, sgn
);
12880 int precision
= MAX (lowprec
, highprec
);
12882 bool use_short_enum
;
12884 /* Determine the underlying type of the enumeration.
12888 The underlying type of an enumeration is an integral type that
12889 can represent all the enumerator values defined in the
12890 enumeration. It is implementation-defined which integral type is
12891 used as the underlying type for an enumeration except that the
12892 underlying type shall not be larger than int unless the value of
12893 an enumerator cannot fit in an int or unsigned int.
12895 We use "int" or an "unsigned int" as the underlying type, even if
12896 a smaller integral type would work, unless the user has
12897 explicitly requested that we use the smallest possible type. The
12898 user can request that for all enumerations with a command line
12899 flag, or for just one enumeration with an attribute. */
12901 use_short_enum
= flag_short_enums
12902 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12904 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12908 underlying_type
= integer_types
[itk
];
12909 if (underlying_type
!= NULL_TREE
12910 && TYPE_PRECISION (underlying_type
) >= precision
12911 && TYPE_SIGN (underlying_type
) == sgn
)
12914 if (itk
== itk_none
)
12918 IF no integral type can represent all the enumerator values, the
12919 enumeration is ill-formed. */
12920 error ("no integral type can represent all of the enumerator values "
12921 "for %qT", enumtype
);
12922 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12923 underlying_type
= integer_types
[itk_unsigned_long_long
];
12928 The value of sizeof() applied to an enumeration type, an object
12929 of an enumeration type, or an enumerator, is the value of sizeof()
12930 applied to the underlying type. */
12931 copy_type_enum (enumtype
, underlying_type
);
12933 /* Compute the minimum and maximum values for the type.
12937 For an enumeration where emin is the smallest enumerator and emax
12938 is the largest, the values of the enumeration are the values of the
12939 underlying type in the range bmin to bmax, where bmin and bmax are,
12940 respectively, the smallest and largest values of the smallest bit-
12941 field that can store emin and emax. */
12943 /* The middle-end currently assumes that types with TYPE_PRECISION
12944 narrower than their underlying type are suitably zero or sign
12945 extended to fill their mode. Similarly, it assumes that the front
12946 end assures that a value of a particular type must be within
12947 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12949 We used to set these fields based on bmin and bmax, but that led
12950 to invalid assumptions like optimizing away bounds checking. So
12951 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12952 TYPE_MAX_VALUE to the values for the mode above and only restrict
12953 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12954 ENUM_UNDERLYING_TYPE (enumtype
)
12955 = build_distinct_type_copy (underlying_type
);
12956 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12957 set_min_and_max_values_for_integral_type
12958 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, sgn
);
12960 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12961 if (flag_strict_enums
)
12962 set_min_and_max_values_for_integral_type (enumtype
, precision
, sgn
);
12965 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12967 /* Convert each of the enumerators to the type of the underlying
12968 type of the enumeration. */
12969 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12971 location_t saved_location
;
12973 decl
= TREE_VALUE (values
);
12974 saved_location
= input_location
;
12975 input_location
= DECL_SOURCE_LOCATION (decl
);
12976 if (fixed_underlying_type_p
)
12977 /* If the enumeration type has a fixed underlying type, we
12978 already checked all of the enumerator values. */
12979 value
= DECL_INITIAL (decl
);
12981 value
= perform_implicit_conversion (underlying_type
,
12982 DECL_INITIAL (decl
),
12983 tf_warning_or_error
);
12984 input_location
= saved_location
;
12986 /* Do not clobber shared ints. */
12987 value
= copy_node (value
);
12989 TREE_TYPE (value
) = enumtype
;
12990 DECL_INITIAL (decl
) = value
;
12993 /* Fix up all variant types of this enum type. */
12994 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12995 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12997 if (at_class_scope_p ()
12998 && COMPLETE_TYPE_P (current_class_type
)
12999 && UNSCOPED_ENUM_P (enumtype
))
13000 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
13001 current_class_type
);
13003 /* Finish debugging output for this type. */
13004 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
13007 /* Finishes the enum type. This is called only the first time an
13008 enumeration is seen, be it opaque or odinary.
13009 ENUMTYPE is the type object. */
13012 finish_enum (tree enumtype
)
13014 if (processing_template_decl
)
13016 if (at_function_scope_p ())
13017 add_stmt (build_min (TAG_DEFN
, enumtype
));
13021 /* If this is a forward declaration, there should not be any variants,
13022 though we can get a variant in the middle of an enum-specifier with
13023 wacky code like 'enum E { e = sizeof(const E*) };' */
13024 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
13025 && (TYPE_VALUES (enumtype
)
13026 || !TYPE_NEXT_VARIANT (enumtype
)));
13029 /* Build and install a CONST_DECL for an enumeration constant of the
13030 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
13031 LOC is the location of NAME.
13032 Assignment of sequential values by default is handled here. */
13035 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
13041 /* scalar_constant_value will pull out this expression, so make sure
13042 it's folded as appropriate. */
13043 if (processing_template_decl
)
13044 value
= fold_non_dependent_expr (value
);
13046 /* If the VALUE was erroneous, pretend it wasn't there; that will
13047 result in the enum being assigned the next value in sequence. */
13048 if (value
== error_mark_node
)
13051 /* Remove no-op casts from the value. */
13053 STRIP_TYPE_NOPS (value
);
13055 if (! processing_template_decl
)
13057 /* Validate and default VALUE. */
13058 if (value
!= NULL_TREE
)
13060 if (!ENUM_UNDERLYING_TYPE (enumtype
))
13062 tree tmp_value
= build_expr_type_conversion (WANT_INT
| WANT_ENUM
,
13067 else if (! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13068 value
= perform_implicit_conversion_flags
13069 (ENUM_UNDERLYING_TYPE (enumtype
), value
, tf_warning_or_error
,
13070 LOOKUP_IMPLICIT
| LOOKUP_NO_NARROWING
);
13072 if (value
== error_mark_node
)
13075 if (value
!= NULL_TREE
)
13077 value
= cxx_constant_value (value
);
13079 if (TREE_CODE (value
) != INTEGER_CST
13080 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
13082 error ("enumerator value for %qD is not an integer constant",
13089 /* Default based on previous value. */
13090 if (value
== NULL_TREE
)
13092 if (TYPE_VALUES (enumtype
))
13097 /* C++03 7.2/4: If no initializer is specified for the first
13098 enumerator, the type is an unspecified integral
13099 type. Otherwise the type is the same as the type of the
13100 initializing value of the preceding enumerator unless the
13101 incremented value is not representable in that type, in
13102 which case the type is an unspecified integral type
13103 sufficient to contain the incremented value. */
13104 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
13105 if (error_operand_p (prev_value
))
13106 value
= error_mark_node
;
13109 tree type
= TREE_TYPE (prev_value
);
13110 signop sgn
= TYPE_SIGN (type
);
13111 widest_int wi
= wi::add (wi::to_widest (prev_value
), 1, sgn
,
13115 bool pos
= !wi::neg_p (wi
, sgn
);
13116 if (!wi::fits_to_tree_p (wi
, type
))
13119 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
13121 type
= integer_types
[itk
];
13122 if (type
!= NULL_TREE
13123 && (pos
|| !TYPE_UNSIGNED (type
))
13124 && wi::fits_to_tree_p (wi
, type
))
13127 if (type
&& cxx_dialect
< cxx11
13128 && itk
> itk_unsigned_long
)
13129 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
13130 incremented enumerator value is too large for %<unsigned long%>" : "\
13131 incremented enumerator value is too large for %<long%>");
13133 if (type
== NULL_TREE
)
13136 value
= wide_int_to_tree (type
, wi
);
13141 error ("overflow in enumeration values at %qD", name
);
13142 value
= error_mark_node
;
13147 value
= integer_zero_node
;
13150 /* Remove no-op casts from the value. */
13151 STRIP_TYPE_NOPS (value
);
13153 /* If the underlying type of the enum is fixed, check whether
13154 the enumerator values fits in the underlying type. If it
13155 does not fit, the program is ill-formed [C++0x dcl.enum]. */
13156 if (ENUM_UNDERLYING_TYPE (enumtype
)
13158 && TREE_CODE (value
) == INTEGER_CST
)
13160 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
13161 error ("enumerator value %E is outside the range of underlying "
13162 "type %<%T%>", value
, ENUM_UNDERLYING_TYPE (enumtype
));
13164 /* Convert the value to the appropriate type. */
13165 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
13169 /* C++ associates enums with global, function, or class declarations. */
13170 context
= current_scope ();
13172 /* Build the actual enumeration constant. Note that the enumeration
13173 constants have the underlying type of the enum (if it is fixed)
13174 or the type of their initializer (if the underlying type of the
13175 enum is not fixed):
13179 If the underlying type is fixed, the type of each enumerator
13180 prior to the closing brace is the underlying type; if the
13181 initializing value of an enumerator cannot be represented by
13182 the underlying type, the program is ill-formed. If the
13183 underlying type is not fixed, the type of each enumerator is
13184 the type of its initializing value.
13186 If the underlying type is not fixed, it will be computed by
13187 finish_enum and we will reset the type of this enumerator. Of
13188 course, if we're processing a template, there may be no value. */
13189 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
13191 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
13193 DECL_CONTEXT (decl
) = enumtype
;
13194 TREE_CONSTANT (decl
) = 1;
13195 TREE_READONLY (decl
) = 1;
13196 DECL_INITIAL (decl
) = value
;
13198 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
13199 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
13200 on the TYPE_FIELDS list for `S'. (That's so that you can say
13201 things like `S::i' later.) */
13202 finish_member_declaration (decl
);
13206 /* Add this enumeration constant to the list for this type. */
13207 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
13210 /* Look for an enumerator with the given NAME within the enumeration
13211 type ENUMTYPE. This routine is used primarily for qualified name
13212 lookup into an enumerator in C++0x, e.g.,
13214 enum class Color { Red, Green, Blue };
13216 Color color = Color::Red;
13218 Returns the value corresponding to the enumerator, or
13219 NULL_TREE if no such enumerator was found. */
13221 lookup_enumerator (tree enumtype
, tree name
)
13224 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
13226 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
13227 return e
? TREE_VALUE (e
) : NULL_TREE
;
13231 /* We're defining DECL. Make sure that its type is OK. */
13234 check_function_type (tree decl
, tree current_function_parms
)
13236 tree fntype
= TREE_TYPE (decl
);
13237 tree return_type
= complete_type (TREE_TYPE (fntype
));
13239 /* In a function definition, arg types must be complete. */
13240 require_complete_types_for_parms (current_function_parms
);
13242 if (dependent_type_p (return_type
)
13243 || type_uses_auto (return_type
))
13245 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
13246 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
13248 tree args
= TYPE_ARG_TYPES (fntype
);
13250 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
13251 error ("return type %q#T is incomplete", return_type
);
13253 error ("return type has Java class type %q#T", return_type
);
13255 /* Make it return void instead. */
13256 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13257 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
13259 TREE_CHAIN (args
));
13261 fntype
= build_function_type (void_type_node
, args
);
13263 = build_exception_variant (fntype
,
13264 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
13265 fntype
= (cp_build_type_attribute_variant
13266 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
13267 TREE_TYPE (decl
) = fntype
;
13270 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
13273 /* Create the FUNCTION_DECL for a function definition.
13274 DECLSPECS and DECLARATOR are the parts of the declaration;
13275 they describe the function's name and the type it returns,
13276 but twisted together in a fashion that parallels the syntax of C.
13278 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
13279 DECLARATOR is really the DECL for the function we are about to
13280 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
13281 indicating that the function is an inline defined in-class.
13283 This function creates a binding context for the function body
13284 as well as setting up the FUNCTION_DECL in current_function_decl.
13286 For C++, we must first check whether that datum makes any sense.
13287 For example, "class A local_a(1,2);" means that variable local_a
13288 is an aggregate of type A, which should have a constructor
13289 applied to it with the argument list [1, 2].
13291 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
13292 or may be a BLOCK if the function has been defined previously
13293 in this translation unit. On exit, DECL_INITIAL (decl1) will be
13294 error_mark_node if the function has never been defined, or
13295 a BLOCK if the function has been defined somewhere. */
13298 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
13300 tree ctype
= NULL_TREE
;
13303 int doing_friend
= 0;
13304 cp_binding_level
*bl
;
13305 tree current_function_parms
;
13306 struct c_fileinfo
*finfo
13307 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
13308 bool honor_interface
;
13310 /* Sanity check. */
13311 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
13312 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
13314 fntype
= TREE_TYPE (decl1
);
13315 if (TREE_CODE (fntype
) == METHOD_TYPE
)
13316 ctype
= TYPE_METHOD_BASETYPE (fntype
);
13318 /* ISO C++ 11.4/5. A friend function defined in a class is in
13319 the (lexical) scope of the class in which it is defined. */
13320 if (!ctype
&& DECL_FRIEND_P (decl1
))
13322 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13324 /* CTYPE could be null here if we're dealing with a template;
13325 for example, `inline friend float foo()' inside a template
13326 will have no CTYPE set. */
13327 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13333 if (DECL_DECLARED_INLINE_P (decl1
)
13334 && lookup_attribute ("noinline", attrs
))
13335 warning (0, "inline function %q+D given attribute noinline", decl1
);
13337 /* Handle gnu_inline attribute. */
13338 if (GNU_INLINE_P (decl1
))
13340 DECL_EXTERNAL (decl1
) = 1;
13341 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13342 DECL_INTERFACE_KNOWN (decl1
) = 1;
13343 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13346 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13347 /* This is a constructor, we must ensure that any default args
13348 introduced by this definition are propagated to the clones
13349 now. The clones are used directly in overload resolution. */
13350 adjust_clone_args (decl1
);
13352 /* Sometimes we don't notice that a function is a static member, and
13353 build a METHOD_TYPE for it. Fix that up now. */
13354 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13355 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13357 /* Set up current_class_type, and enter the scope of the class, if
13360 push_nested_class (ctype
);
13361 else if (DECL_STATIC_FUNCTION_P (decl1
))
13362 push_nested_class (DECL_CONTEXT (decl1
));
13364 /* Now that we have entered the scope of the class, we must restore
13365 the bindings for any template parameters surrounding DECL1, if it
13366 is an inline member template. (Order is important; consider the
13367 case where a template parameter has the same name as a field of
13368 the class.) It is not until after this point that
13369 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13370 if (flags
& SF_INCLASS_INLINE
)
13371 maybe_begin_member_template_processing (decl1
);
13373 /* Effective C++ rule 15. */
13375 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13376 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13377 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13379 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13380 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13381 if (!DECL_INITIAL (decl1
))
13382 DECL_INITIAL (decl1
) = error_mark_node
;
13384 /* This function exists in static storage.
13385 (This does not mean `static' in the C sense!) */
13386 TREE_STATIC (decl1
) = 1;
13388 /* We must call push_template_decl after current_class_type is set
13389 up. (If we are processing inline definitions after exiting a
13390 class scope, current_class_type will be NULL_TREE until set above
13391 by push_nested_class.) */
13392 if (processing_template_decl
)
13394 tree newdecl1
= push_template_decl (decl1
);
13395 if (newdecl1
== error_mark_node
)
13397 if (ctype
|| DECL_STATIC_FUNCTION_P (decl1
))
13398 pop_nested_class ();
13404 /* We are now in the scope of the function being defined. */
13405 current_function_decl
= decl1
;
13407 /* Save the parm names or decls from this function's declarator
13408 where store_parm_decls will find them. */
13409 current_function_parms
= DECL_ARGUMENTS (decl1
);
13411 /* Make sure the parameter and return types are reasonable. When
13412 you declare a function, these types can be incomplete, but they
13413 must be complete when you define the function. */
13414 check_function_type (decl1
, current_function_parms
);
13416 /* Build the return declaration for the function. */
13417 restype
= TREE_TYPE (fntype
);
13419 if (DECL_RESULT (decl1
) == NULL_TREE
)
13423 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13424 DECL_ARTIFICIAL (resdecl
) = 1;
13425 DECL_IGNORED_P (resdecl
) = 1;
13426 DECL_RESULT (decl1
) = resdecl
;
13428 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13431 /* Let the user know we're compiling this function. */
13432 announce_function (decl1
);
13434 /* Record the decl so that the function name is defined.
13435 If we already have a decl for this name, and it is a FUNCTION_DECL,
13436 use the old decl. */
13437 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13439 /* A specialization is not used to guide overload resolution. */
13440 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13441 && !(DECL_USE_TEMPLATE (decl1
) &&
13442 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13444 tree olddecl
= pushdecl (decl1
);
13446 if (olddecl
== error_mark_node
)
13447 /* If something went wrong when registering the declaration,
13448 use DECL1; we have to have a FUNCTION_DECL to use when
13449 parsing the body of the function. */
13453 /* Otherwise, OLDDECL is either a previous declaration
13454 of the same function or DECL1 itself. */
13456 if (warn_missing_declarations
13457 && olddecl
== decl1
13458 && !DECL_MAIN_P (decl1
)
13459 && TREE_PUBLIC (decl1
)
13460 && !DECL_DECLARED_INLINE_P (decl1
))
13464 /* Check whether DECL1 is in an anonymous
13466 for (context
= DECL_CONTEXT (decl1
);
13468 context
= DECL_CONTEXT (context
))
13470 if (TREE_CODE (context
) == NAMESPACE_DECL
13471 && DECL_NAME (context
) == NULL_TREE
)
13475 if (context
== NULL
)
13476 warning (OPT_Wmissing_declarations
,
13477 "no previous declaration for %q+D", decl1
);
13485 /* We need to set the DECL_CONTEXT. */
13486 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13487 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13489 fntype
= TREE_TYPE (decl1
);
13490 restype
= TREE_TYPE (fntype
);
13492 /* If #pragma weak applies, mark the decl appropriately now.
13493 The pragma only applies to global functions. Because
13494 determining whether or not the #pragma applies involves
13495 computing the mangled name for the declaration, we cannot
13496 apply the pragma until after we have merged this declaration
13497 with any previous declarations; if the original declaration
13498 has a linkage specification, that specification applies to
13499 the definition as well, and may affect the mangled name. */
13500 if (DECL_FILE_SCOPE_P (decl1
))
13501 maybe_apply_pragma_weak (decl1
);
13504 /* Reset this in case the call to pushdecl changed it. */
13505 current_function_decl
= decl1
;
13507 gcc_assert (DECL_INITIAL (decl1
));
13509 /* This function may already have been parsed, in which case just
13510 return; our caller will skip over the body without parsing. */
13511 if (DECL_INITIAL (decl1
) != error_mark_node
)
13514 /* Initialize RTL machinery. We cannot do this until
13515 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13516 even when processing a template; this is how we get
13517 CFUN set up, and our per-function variables initialized.
13518 FIXME factor out the non-RTL stuff. */
13519 bl
= current_binding_level
;
13520 allocate_struct_function (decl1
, processing_template_decl
);
13522 /* Initialize the language data structures. Whenever we start
13523 a new function, we destroy temporaries in the usual way. */
13524 cfun
->language
= ggc_cleared_alloc
<language_function
> ();
13525 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13526 current_binding_level
= bl
;
13528 if (!processing_template_decl
&& type_uses_auto (restype
))
13530 FNDECL_USED_AUTO (decl1
) = true;
13531 current_function_auto_return_pattern
= restype
;
13534 /* Start the statement-tree, start the tree now. */
13535 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13537 /* If we are (erroneously) defining a function that we have already
13538 defined before, wipe out what we knew before. */
13539 if (!DECL_PENDING_INLINE_P (decl1
))
13540 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13542 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13544 /* We know that this was set up by `grokclassfn'. We do not
13545 wait until `store_parm_decls', since evil parse errors may
13546 never get us to that point. Here we keep the consistency
13547 between `current_class_type' and `current_class_ptr'. */
13548 tree t
= DECL_ARGUMENTS (decl1
);
13550 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13551 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13553 cp_function_chain
->x_current_class_ref
13554 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13555 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13556 cp_function_chain
->x_current_class_ptr
= t
;
13558 /* Constructors and destructors need to know whether they're "in
13559 charge" of initializing virtual base classes. */
13560 t
= DECL_CHAIN (t
);
13561 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13563 current_in_charge_parm
= t
;
13564 t
= DECL_CHAIN (t
);
13566 if (DECL_HAS_VTT_PARM_P (decl1
))
13568 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13569 current_vtt_parm
= t
;
13573 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13574 /* Implicitly-defined methods (like the
13575 destructor for a class in which no destructor
13576 is explicitly declared) must not be defined
13577 until their definition is needed. So, we
13578 ignore interface specifications for
13579 compiler-generated functions. */
13580 && !DECL_ARTIFICIAL (decl1
));
13582 if (processing_template_decl
)
13583 /* Don't mess with interface flags. */;
13584 else if (DECL_INTERFACE_KNOWN (decl1
))
13586 tree ctx
= decl_function_context (decl1
);
13588 if (DECL_NOT_REALLY_EXTERN (decl1
))
13589 DECL_EXTERNAL (decl1
) = 0;
13591 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13592 /* This is a function in a local class in an extern inline
13593 or template function. */
13594 comdat_linkage (decl1
);
13596 /* If this function belongs to an interface, it is public.
13597 If it belongs to someone else's interface, it is also external.
13598 This only affects inlines and template instantiations. */
13599 else if (!finfo
->interface_unknown
&& honor_interface
)
13601 if (DECL_DECLARED_INLINE_P (decl1
)
13602 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13604 DECL_EXTERNAL (decl1
)
13605 = (finfo
->interface_only
13606 || (DECL_DECLARED_INLINE_P (decl1
)
13607 && ! flag_implement_inlines
13608 && !DECL_VINDEX (decl1
)));
13610 /* For WIN32 we also want to put these in linkonce sections. */
13611 maybe_make_one_only (decl1
);
13614 DECL_EXTERNAL (decl1
) = 0;
13615 DECL_INTERFACE_KNOWN (decl1
) = 1;
13616 /* If this function is in an interface implemented in this file,
13617 make sure that the back end knows to emit this function
13619 if (!DECL_EXTERNAL (decl1
))
13620 mark_needed (decl1
);
13622 else if (finfo
->interface_unknown
&& finfo
->interface_only
13623 && honor_interface
)
13625 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13626 interface, we will have both finfo->interface_unknown and
13627 finfo->interface_only set. In that case, we don't want to
13628 use the normal heuristics because someone will supply a
13629 #pragma implementation elsewhere, and deducing it here would
13630 produce a conflict. */
13631 comdat_linkage (decl1
);
13632 DECL_EXTERNAL (decl1
) = 0;
13633 DECL_INTERFACE_KNOWN (decl1
) = 1;
13634 DECL_DEFER_OUTPUT (decl1
) = 1;
13638 /* This is a definition, not a reference.
13639 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13640 if (!GNU_INLINE_P (decl1
))
13641 DECL_EXTERNAL (decl1
) = 0;
13643 if ((DECL_DECLARED_INLINE_P (decl1
)
13644 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13645 && ! DECL_INTERFACE_KNOWN (decl1
))
13646 DECL_DEFER_OUTPUT (decl1
) = 1;
13648 DECL_INTERFACE_KNOWN (decl1
) = 1;
13651 /* Determine the ELF visibility attribute for the function. We must not
13652 do this before calling "pushdecl", as we must allow "duplicate_decls"
13653 to merge any attributes appropriately. We also need to wait until
13655 if (!DECL_CLONED_FUNCTION_P (decl1
))
13656 determine_visibility (decl1
);
13658 if (!processing_template_decl
)
13659 maybe_instantiate_noexcept (decl1
);
13661 begin_scope (sk_function_parms
, decl1
);
13665 if (DECL_DESTRUCTOR_P (decl1
)
13666 || (DECL_CONSTRUCTOR_P (decl1
)
13667 && targetm
.cxx
.cdtor_returns_this ()))
13669 cdtor_label
= build_decl (input_location
,
13670 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13671 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13674 start_fname_decls ();
13676 store_parm_decls (current_function_parms
);
13682 /* Like start_preparsed_function, except that instead of a
13683 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13685 Returns true on success. If the DECLARATOR is not suitable
13686 for a function, we return false, which tells the parser to
13687 skip the entire function. */
13690 start_function (cp_decl_specifier_seq
*declspecs
,
13691 const cp_declarator
*declarator
,
13696 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13697 if (decl1
== error_mark_node
)
13699 /* If the declarator is not suitable for a function definition,
13700 cause a syntax error. */
13701 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13703 error ("invalid function declaration");
13707 if (DECL_MAIN_P (decl1
))
13708 /* main must return int. grokfndecl should have corrected it
13709 (and issued a diagnostic) if the user got it wrong. */
13710 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13711 integer_type_node
));
13713 return start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13716 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13720 use_eh_spec_block (tree fn
)
13722 return (flag_exceptions
&& flag_enforce_eh_specs
13723 && !processing_template_decl
13724 && !type_throw_all_p (TREE_TYPE (fn
))
13725 /* We insert the EH_SPEC_BLOCK only in the original
13726 function; then, it is copied automatically to the
13728 && !DECL_CLONED_FUNCTION_P (fn
)
13729 /* Implicitly-generated constructors and destructors have
13730 exception specifications. However, those specifications
13731 are the union of the possible exceptions specified by the
13732 constructors/destructors for bases and members, so no
13733 unallowed exception will ever reach this function. By
13734 not creating the EH_SPEC_BLOCK we save a little memory,
13735 and we avoid spurious warnings about unreachable
13737 && !DECL_DEFAULTED_FN (fn
));
13740 /* Store the parameter declarations into the current function declaration.
13741 This is called after parsing the parameter declarations, before
13742 digesting the body of the function.
13744 Also install to binding contour return value identifier, if any. */
13747 store_parm_decls (tree current_function_parms
)
13749 tree fndecl
= current_function_decl
;
13752 /* This is a chain of any other decls that came in among the parm
13753 declarations. If a parm is declared with enum {foo, bar} x;
13754 then CONST_DECLs for foo and bar are put here. */
13755 tree nonparms
= NULL_TREE
;
13757 if (current_function_parms
)
13759 /* This case is when the function was defined with an ANSI prototype.
13760 The parms already have decls, so we need not do anything here
13761 except record them as in effect
13762 and complain if any redundant old-style parm decls were written. */
13764 tree specparms
= current_function_parms
;
13767 /* Must clear this because it might contain TYPE_DECLs declared
13769 current_binding_level
->names
= NULL
;
13771 /* If we're doing semantic analysis, then we'll call pushdecl
13772 for each of these. We must do them in reverse order so that
13773 they end in the correct forward order. */
13774 specparms
= nreverse (specparms
);
13776 for (parm
= specparms
; parm
; parm
= next
)
13778 next
= DECL_CHAIN (parm
);
13779 if (TREE_CODE (parm
) == PARM_DECL
)
13781 if (DECL_NAME (parm
) == NULL_TREE
13782 || !VOID_TYPE_P (parm
))
13785 error ("parameter %qD declared void", parm
);
13789 /* If we find an enum constant or a type tag,
13790 put it aside for the moment. */
13791 TREE_CHAIN (parm
) = NULL_TREE
;
13792 nonparms
= chainon (nonparms
, parm
);
13796 /* Get the decls in their original chain order and record in the
13797 function. This is all and only the PARM_DECLs that were
13798 pushed into scope by the loop above. */
13799 DECL_ARGUMENTS (fndecl
) = getdecls ();
13802 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13804 /* Now store the final chain of decls for the arguments
13805 as the decl-chain of the current lexical scope.
13806 Put the enumerators in as well, at the front so that
13807 DECL_ARGUMENTS is not modified. */
13808 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13810 if (use_eh_spec_block (current_function_decl
))
13811 current_eh_spec_block
= begin_eh_spec_block ();
13815 /* We have finished doing semantic analysis on DECL, but have not yet
13816 generated RTL for its body. Save away our current state, so that
13817 when we want to generate RTL later we know what to do. */
13820 save_function_data (tree decl
)
13822 struct language_function
*f
;
13824 /* Save the language-specific per-function data so that we can
13825 get it back when we really expand this function. */
13826 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13829 f
= ggc_alloc
<language_function
> ();
13830 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13831 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13833 /* Clear out the bits we don't need. */
13834 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13835 f
->bindings
= NULL
;
13836 f
->x_local_names
= NULL
;
13837 f
->base
.local_typedefs
= NULL
;
13841 /* Set the return value of the constructor (if present). */
13844 finish_constructor_body (void)
13849 if (targetm
.cxx
.cdtor_returns_this ()
13850 && (! TYPE_FOR_JAVA (current_class_type
)))
13852 /* Any return from a constructor will end up here. */
13853 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13855 val
= DECL_ARGUMENTS (current_function_decl
);
13856 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13857 DECL_RESULT (current_function_decl
), val
);
13858 /* Return the address of the object. */
13859 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13860 add_stmt (exprstmt
);
13864 /* Do all the processing for the beginning of a destructor; set up the
13865 vtable pointers and cleanups for bases and members. */
13868 begin_destructor_body (void)
13870 tree compound_stmt
;
13872 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13873 issued an error message. We still want to try to process the
13874 body of the function, but initialize_vtbl_ptrs will crash if
13875 TYPE_BINFO is NULL. */
13876 if (COMPLETE_TYPE_P (current_class_type
))
13878 compound_stmt
= begin_compound_stmt (0);
13879 /* Make all virtual function table pointers in non-virtual base
13880 classes point to CURRENT_CLASS_TYPE's virtual function
13882 initialize_vtbl_ptrs (current_class_ptr
);
13883 finish_compound_stmt (compound_stmt
);
13885 /* Insert a cleanup to let the back end know that the object is dead
13886 when we exit the destructor, either normally or via exception. */
13887 tree btype
= CLASSTYPE_AS_BASE (current_class_type
);
13888 tree clobber
= build_constructor (btype
, NULL
);
13889 TREE_THIS_VOLATILE (clobber
) = true;
13890 tree bref
= build_nop (build_reference_type (btype
), current_class_ptr
);
13891 bref
= convert_from_reference (bref
);
13892 tree exprstmt
= build2 (MODIFY_EXPR
, btype
, bref
, clobber
);
13893 finish_decl_cleanup (NULL_TREE
, exprstmt
);
13895 /* And insert cleanups for our bases and members so that they
13896 will be properly destroyed if we throw. */
13897 push_base_cleanups ();
13901 /* At the end of every destructor we generate code to delete the object if
13902 necessary. Do that now. */
13905 finish_destructor_body (void)
13909 /* Any return from a destructor will end up here; that way all base
13910 and member cleanups will be run when the function returns. */
13911 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13913 /* In a virtual destructor, we must call delete. */
13914 if (DECL_VIRTUAL_P (current_function_decl
))
13917 tree virtual_size
= cxx_sizeof (current_class_type
);
13921 At the point of definition of a virtual destructor (including
13922 an implicit definition), non-placement operator delete shall
13923 be looked up in the scope of the destructor's class and if
13924 found shall be accessible and unambiguous. */
13925 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13927 /*global_p=*/false,
13928 /*placement=*/NULL_TREE
,
13929 /*alloc_fn=*/NULL_TREE
,
13930 tf_warning_or_error
);
13932 if_stmt
= begin_if_stmt ();
13933 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13934 current_in_charge_parm
,
13937 finish_expr_stmt (exprstmt
);
13938 finish_then_clause (if_stmt
);
13939 finish_if_stmt (if_stmt
);
13942 if (targetm
.cxx
.cdtor_returns_this ())
13946 val
= DECL_ARGUMENTS (current_function_decl
);
13947 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13948 DECL_RESULT (current_function_decl
), val
);
13949 /* Return the address of the object. */
13950 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13951 add_stmt (exprstmt
);
13955 /* Do the necessary processing for the beginning of a function body, which
13956 in this case includes member-initializers, but not the catch clauses of
13957 a function-try-block. Currently, this means opening a binding level
13958 for the member-initializers (in a ctor), member cleanups (in a dtor),
13959 and capture proxies (in a lambda operator()). */
13962 begin_function_body (void)
13966 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13969 if (processing_template_decl
)
13970 /* Do nothing now. */;
13972 /* Always keep the BLOCK node associated with the outermost pair of
13973 curly braces of a function. These are needed for correct
13974 operation of dwarfout.c. */
13975 keep_next_level (true);
13977 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13979 if (processing_template_decl
)
13980 /* Do nothing now. */;
13981 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13982 begin_destructor_body ();
13987 /* Do the processing for the end of a function body. Currently, this means
13988 closing out the cleanups for fully-constructed bases and members, and in
13989 the case of the destructor, deleting the object if desired. Again, this
13990 is only meaningful for [cd]tors, since they are the only functions where
13991 there is a significant distinction between the main body and any
13992 function catch clauses. Handling, say, main() return semantics here
13993 would be wrong, as flowing off the end of a function catch clause for
13994 main() would also need to return 0. */
13997 finish_function_body (tree compstmt
)
13999 if (compstmt
== NULL_TREE
)
14002 /* Close the block. */
14003 finish_compound_stmt (compstmt
);
14005 if (processing_template_decl
)
14006 /* Do nothing now. */;
14007 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
14008 finish_constructor_body ();
14009 else if (DECL_DESTRUCTOR_P (current_function_decl
))
14010 finish_destructor_body ();
14013 /* Given a function, returns the BLOCK corresponding to the outermost level
14014 of curly braces, skipping the artificial block created for constructor
14018 outer_curly_brace_block (tree fndecl
)
14020 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
14021 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
14022 /* Skip the artificial function body block. */
14023 block
= BLOCK_SUBBLOCKS (block
);
14027 /* If FNDECL is a class's key method, add the class to the list of
14028 keyed classes that should be emitted. */
14031 record_key_method_defined (tree fndecl
)
14033 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
14034 && DECL_VIRTUAL_P (fndecl
)
14035 && !processing_template_decl
)
14037 tree fnclass
= DECL_CONTEXT (fndecl
);
14038 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
14039 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
14043 /* Subroutine of finish_function.
14044 Save the body of constexpr functions for possible
14045 future compile time evaluation. */
14048 maybe_save_function_definition (tree fun
)
14050 if (!processing_template_decl
14051 && DECL_DECLARED_CONSTEXPR_P (fun
)
14052 && !cp_function_chain
->invalid_constexpr
14053 && !DECL_CLONED_FUNCTION_P (fun
))
14054 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
14057 /* Finish up a function declaration and compile that function
14058 all the way to assembler language output. The free the storage
14059 for the function definition.
14061 FLAGS is a bitwise or of the following values:
14063 We just finished processing the body of an in-class inline
14064 function definition. (This processing will have taken place
14065 after the class definition is complete.) */
14068 finish_function (int flags
)
14070 tree fndecl
= current_function_decl
;
14071 tree fntype
, ctype
= NULL_TREE
;
14072 int inclass_inline
= (flags
& 2) != 0;
14074 /* When we get some parse errors, we can end up without a
14075 current_function_decl, so cope. */
14076 if (fndecl
== NULL_TREE
)
14077 return error_mark_node
;
14079 if (c_dialect_objc ())
14080 objc_finish_function ();
14082 gcc_assert (!defer_mark_used_calls
);
14083 defer_mark_used_calls
= true;
14085 record_key_method_defined (fndecl
);
14087 fntype
= TREE_TYPE (fndecl
);
14089 /* TREE_READONLY (fndecl) = 1;
14090 This caused &foo to be of type ptr-to-const-function
14091 which then got a warning when stored in a ptr-to-function variable. */
14093 gcc_assert (building_stmt_list_p ());
14094 /* The current function is being defined, so its DECL_INITIAL should
14095 be set, and unless there's a multiple definition, it should be
14096 error_mark_node. */
14097 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
14099 /* For a cloned function, we've already got all the code we need;
14100 there's no need to add any extra bits. */
14101 if (!DECL_CLONED_FUNCTION_P (fndecl
))
14103 /* Make it so that `main' always returns 0 by default. */
14104 if (DECL_MAIN_P (current_function_decl
))
14105 finish_return_stmt (integer_zero_node
);
14107 if (use_eh_spec_block (current_function_decl
))
14108 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
14109 (TREE_TYPE (current_function_decl
)),
14110 current_eh_spec_block
);
14113 /* If we're saving up tree structure, tie off the function now. */
14114 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
14116 if (fn_contains_cilk_spawn_p (cfun
) && !processing_template_decl
)
14117 cfun
->cilk_frame_decl
= insert_cilk_frame (fndecl
);
14119 finish_fname_decls ();
14121 /* If this function can't throw any exceptions, remember that. */
14122 if (!processing_template_decl
14123 && !cp_function_chain
->can_throw
14124 && !flag_non_call_exceptions
14125 && !decl_replaceable_p (fndecl
))
14126 TREE_NOTHROW (fndecl
) = 1;
14128 /* This must come after expand_function_end because cleanups might
14129 have declarations (from inline functions) that need to go into
14130 this function's blocks. */
14132 /* If the current binding level isn't the outermost binding level
14133 for this function, either there is a bug, or we have experienced
14134 syntax errors and the statement tree is malformed. */
14135 if (current_binding_level
->kind
!= sk_function_parms
)
14137 /* Make sure we have already experienced errors. */
14138 gcc_assert (errorcount
);
14140 /* Throw away the broken statement tree and extra binding
14142 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
14144 while (current_binding_level
->kind
!= sk_function_parms
)
14146 if (current_binding_level
->kind
== sk_class
)
14147 pop_nested_class ();
14149 poplevel (0, 0, 0);
14152 poplevel (1, 0, 1);
14154 /* Statements should always be full-expressions at the outermost set
14155 of curly braces for a function. */
14156 gcc_assert (stmts_are_full_exprs_p ());
14158 /* If there are no return statements in a function with auto return type,
14159 the return type is void. But if the declared type is something like
14160 auto*, this is an error. */
14161 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
14162 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
14164 if (!is_auto (current_function_auto_return_pattern
)
14165 && !current_function_returns_value
&& !current_function_returns_null
)
14167 error ("no return statements in function returning %qT",
14168 current_function_auto_return_pattern
);
14169 inform (input_location
, "only plain %<auto%> return type can be "
14170 "deduced to %<void%>");
14172 apply_deduced_return_type (fndecl
, void_type_node
);
14173 fntype
= TREE_TYPE (fndecl
);
14176 /* Save constexpr function body before it gets munged by
14177 the NRV transformation. */
14178 maybe_save_function_definition (fndecl
);
14180 /* Set up the named return value optimization, if we can. Candidate
14181 variables are selected in check_return_expr. */
14182 if (current_function_return_value
)
14184 tree r
= current_function_return_value
;
14187 if (r
!= error_mark_node
14188 /* This is only worth doing for fns that return in memory--and
14189 simpler, since we don't have to worry about promoted modes. */
14190 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
14191 /* Only allow this for variables declared in the outer scope of
14192 the function so we know that their lifetime always ends with a
14193 return; see g++.dg/opt/nrv6.C. We could be more flexible if
14194 we were to do this optimization in tree-ssa. */
14195 && (outer
= outer_curly_brace_block (fndecl
))
14196 && chain_member (r
, BLOCK_VARS (outer
)))
14197 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
14199 current_function_return_value
= NULL_TREE
;
14202 /* Remember that we were in class scope. */
14203 if (current_class_name
)
14204 ctype
= current_class_type
;
14206 /* Must mark the RESULT_DECL as being in this function. */
14207 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
14209 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
14210 to the FUNCTION_DECL node itself. */
14211 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
14213 /* Save away current state, if appropriate. */
14214 if (!processing_template_decl
)
14215 save_function_data (fndecl
);
14217 /* Complain if there's just no return statement. */
14218 if (warn_return_type
14219 && !VOID_TYPE_P (TREE_TYPE (fntype
))
14220 && !dependent_type_p (TREE_TYPE (fntype
))
14221 && !current_function_returns_value
&& !current_function_returns_null
14222 /* Don't complain if we abort or throw. */
14223 && !current_function_returns_abnormally
14224 /* Don't complain if there's an infinite loop. */
14225 && !current_function_infinite_loop
14226 /* Don't complain if we are declared noreturn. */
14227 && !TREE_THIS_VOLATILE (fndecl
)
14228 && !DECL_NAME (DECL_RESULT (fndecl
))
14229 && !TREE_NO_WARNING (fndecl
)
14230 /* Structor return values (if any) are set by the compiler. */
14231 && !DECL_CONSTRUCTOR_P (fndecl
)
14232 && !DECL_DESTRUCTOR_P (fndecl
)
14233 && targetm
.warn_func_return (fndecl
))
14235 warning (OPT_Wreturn_type
,
14236 "no return statement in function returning non-void");
14237 TREE_NO_WARNING (fndecl
) = 1;
14240 /* Store the end of the function, so that we get good line number
14241 info for the epilogue. */
14242 cfun
->function_end_locus
= input_location
;
14244 /* Complain about parameters that are only set, but never otherwise used. */
14245 if (warn_unused_but_set_parameter
14246 && !processing_template_decl
14247 && errorcount
== unused_but_set_errorcount
14248 && !DECL_CLONED_FUNCTION_P (fndecl
))
14252 for (decl
= DECL_ARGUMENTS (fndecl
);
14254 decl
= DECL_CHAIN (decl
))
14255 if (TREE_USED (decl
)
14256 && TREE_CODE (decl
) == PARM_DECL
14257 && !DECL_READ_P (decl
)
14258 && DECL_NAME (decl
)
14259 && !DECL_ARTIFICIAL (decl
)
14260 && !TREE_NO_WARNING (decl
)
14261 && !DECL_IN_SYSTEM_HEADER (decl
)
14262 && TREE_TYPE (decl
) != error_mark_node
14263 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
14264 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
14265 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
14266 warning (OPT_Wunused_but_set_parameter
,
14267 "parameter %q+D set but not used", decl
);
14268 unused_but_set_errorcount
= errorcount
;
14271 /* Complain about locally defined typedefs that are not used in this
14273 maybe_warn_unused_local_typedefs ();
14275 /* Genericize before inlining. */
14276 if (!processing_template_decl
)
14278 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
14279 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
14280 cp_genericize (fndecl
);
14281 /* Clear out the bits we don't need. */
14282 f
->x_current_class_ptr
= NULL
;
14283 f
->x_current_class_ref
= NULL
;
14284 f
->x_eh_spec_block
= NULL
;
14285 f
->x_in_charge_parm
= NULL
;
14286 f
->x_vtt_parm
= NULL
;
14287 f
->x_return_value
= NULL
;
14288 f
->bindings
= NULL
;
14289 f
->extern_decl_map
= NULL
;
14290 f
->infinite_loops
= NULL
;
14292 /* Clear out the bits we don't need. */
14293 local_names
= NULL
;
14295 /* We're leaving the context of this function, so zap cfun. It's still in
14296 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
14298 current_function_decl
= NULL
;
14300 /* If this is an in-class inline definition, we may have to pop the
14301 bindings for the template parameters that we added in
14302 maybe_begin_member_template_processing when start_function was
14304 if (inclass_inline
)
14305 maybe_end_member_template_processing ();
14307 /* Leave the scope of the class. */
14309 pop_nested_class ();
14314 current_function_decl
= NULL_TREE
;
14316 defer_mark_used_calls
= false;
14317 if (deferred_mark_used_calls
)
14322 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
14324 vec_free (deferred_mark_used_calls
);
14330 /* Create the FUNCTION_DECL for a function definition.
14331 DECLSPECS and DECLARATOR are the parts of the declaration;
14332 they describe the return type and the name of the function,
14333 but twisted together in a fashion that parallels the syntax of C.
14335 This function creates a binding context for the function body
14336 as well as setting up the FUNCTION_DECL in current_function_decl.
14338 Returns a FUNCTION_DECL on success.
14340 If the DECLARATOR is not suitable for a function (it defines a datum
14341 instead), we return 0, which tells yyparse to report a parse error.
14343 May return void_type_node indicating that this method is actually
14344 a friend. See grokfield for more details.
14346 Came here with a `.pushlevel' .
14348 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14349 CHANGES TO CODE IN `grokfield'. */
14352 grokmethod (cp_decl_specifier_seq
*declspecs
,
14353 const cp_declarator
*declarator
, tree attrlist
)
14355 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14358 if (fndecl
== error_mark_node
)
14359 return error_mark_node
;
14361 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14363 error ("invalid member function declaration");
14364 return error_mark_node
;
14368 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14370 /* Pass friends other than inline friend functions back. */
14371 if (fndecl
== void_type_node
)
14374 if (DECL_IN_AGGR_P (fndecl
))
14376 if (DECL_CLASS_SCOPE_P (fndecl
))
14377 error ("%qD is already defined in class %qT", fndecl
,
14378 DECL_CONTEXT (fndecl
));
14379 return error_mark_node
;
14382 check_template_shadow (fndecl
);
14384 DECL_COMDAT (fndecl
) = 1;
14385 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14386 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14388 /* We process method specializations in finish_struct_1. */
14389 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14391 fndecl
= push_template_decl (fndecl
);
14392 if (fndecl
== error_mark_node
)
14396 if (! DECL_FRIEND_P (fndecl
))
14398 if (DECL_CHAIN (fndecl
))
14400 fndecl
= copy_node (fndecl
);
14401 TREE_CHAIN (fndecl
) = NULL_TREE
;
14405 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14407 DECL_IN_AGGR_P (fndecl
) = 1;
14412 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14413 we can lay it out later, when and if its type becomes complete.
14415 Also handle constexpr variables where the initializer involves
14416 an unlowered PTRMEM_CST because the class isn't complete yet. */
14419 maybe_register_incomplete_var (tree var
)
14421 gcc_assert (VAR_P (var
));
14423 /* Keep track of variables with incomplete types. */
14424 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14425 && DECL_EXTERNAL (var
))
14427 tree inner_type
= TREE_TYPE (var
);
14429 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14430 inner_type
= TREE_TYPE (inner_type
);
14431 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14433 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14434 /* RTTI TD entries are created while defining the type_info. */
14435 || (TYPE_LANG_SPECIFIC (inner_type
)
14436 && TYPE_BEING_DEFINED (inner_type
)))
14438 incomplete_var iv
= {var
, inner_type
};
14439 vec_safe_push (incomplete_vars
, iv
);
14441 else if (!(DECL_LANG_SPECIFIC (var
) && DECL_TEMPLATE_INFO (var
))
14442 && decl_constant_var_p (var
)
14443 && (TYPE_PTRMEM_P (inner_type
) || CLASS_TYPE_P (inner_type
)))
14445 /* When the outermost open class is complete we can resolve any
14446 pointers-to-members. */
14447 tree context
= outermost_open_class ();
14448 incomplete_var iv
= {var
, context
};
14449 vec_safe_push (incomplete_vars
, iv
);
14454 /* Called when a class type (given by TYPE) is defined. If there are
14455 any existing VAR_DECLs whose type has been completed by this
14456 declaration, update them now. */
14459 complete_vars (tree type
)
14462 incomplete_var
*iv
;
14464 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14466 if (same_type_p (type
, iv
->incomplete_type
))
14468 tree var
= iv
->decl
;
14469 tree type
= TREE_TYPE (var
);
14471 if (TYPE_MAIN_VARIANT (strip_array_types (type
))
14472 == iv
->incomplete_type
)
14474 /* Complete the type of the variable. The VAR_DECL itself
14475 will be laid out in expand_expr. */
14476 complete_type (type
);
14477 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14480 if (DECL_INITIAL (var
)
14481 && decl_constant_var_p (var
))
14482 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14484 /* Remove this entry from the list. */
14485 incomplete_vars
->unordered_remove (ix
);
14491 /* Check for pending declarations which may have abstract type. */
14492 complete_type_check_abstract (type
);
14495 /* If DECL is of a type which needs a cleanup, build and return an
14496 expression to perform that cleanup here. Return NULL_TREE if no
14497 cleanup need be done. */
14500 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14506 /* Assume no cleanup is required. */
14507 cleanup
= NULL_TREE
;
14509 if (error_operand_p (decl
))
14512 /* Handle "__attribute__((cleanup))". We run the cleanup function
14513 before the destructor since the destructor is what actually
14514 terminates the lifetime of the object. */
14515 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14522 /* Get the name specified by the user for the cleanup function. */
14523 id
= TREE_VALUE (TREE_VALUE (attr
));
14524 /* Look up the name to find the cleanup function to call. It is
14525 important to use lookup_name here because that is what is
14526 used in c-common.c:handle_cleanup_attribute when performing
14527 initial checks on the attribute. Note that those checks
14528 include ensuring that the function found is not an overloaded
14529 function, or an object with an overloaded call operator,
14530 etc.; we can rely on the fact that the function found is an
14531 ordinary FUNCTION_DECL. */
14532 fn
= lookup_name (id
);
14533 arg
= build_address (decl
);
14535 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14536 if (cleanup
== error_mark_node
)
14537 return error_mark_node
;
14539 /* Handle ordinary C++ destructors. */
14540 type
= TREE_TYPE (decl
);
14541 if (type_build_dtor_call (type
))
14543 int flags
= LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
|LOOKUP_DESTRUCTOR
;
14547 if (TREE_CODE (type
) == ARRAY_TYPE
)
14550 addr
= build_address (decl
);
14552 call
= build_delete (TREE_TYPE (addr
), addr
,
14553 sfk_complete_destructor
, flags
, 0, complain
);
14554 if (call
== error_mark_node
)
14555 cleanup
= error_mark_node
;
14556 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
14557 /* Discard the call. */;
14559 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14564 /* build_delete sets the location of the destructor call to the
14565 current location, even though the destructor is going to be
14566 called later, at the end of the current scope. This can lead to
14567 a "jumpy" behaviour for users of debuggers when they step around
14568 the end of the block. So let's unset the location of the
14569 destructor call instead. */
14570 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14571 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14574 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl
))))
14575 /* Treat objects with destructors as used; the destructor may do
14576 something substantive. */
14583 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14584 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14585 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14588 static_fn_type (tree memfntype
)
14593 if (TYPE_PTRMEMFUNC_P (memfntype
))
14594 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14595 if (POINTER_TYPE_P (memfntype
)
14596 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14597 memfntype
= TREE_TYPE (memfntype
);
14598 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14600 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14601 args
= TYPE_ARG_TYPES (memfntype
);
14602 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14603 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14604 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14605 fntype
= (cp_build_type_attribute_variant
14606 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14607 fntype
= (build_exception_variant
14608 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14609 if (TYPE_HAS_LATE_RETURN_TYPE (memfntype
))
14610 TYPE_HAS_LATE_RETURN_TYPE (fntype
) = 1;
14614 /* DECL was originally constructed as a non-static member function,
14615 but turned out to be static. Update it accordingly. */
14618 revert_static_member_fn (tree decl
)
14620 tree stype
= static_fn_type (decl
);
14621 cp_cv_quals quals
= type_memfn_quals (stype
);
14622 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14624 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14625 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14627 TREE_TYPE (decl
) = stype
;
14629 if (DECL_ARGUMENTS (decl
))
14630 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14631 DECL_STATIC_FUNCTION_P (decl
) = 1;
14634 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14635 one of the language-independent trees. */
14637 enum cp_tree_node_structure_enum
14638 cp_tree_node_structure (union lang_tree_node
* t
)
14640 switch (TREE_CODE (&t
->generic
))
14642 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14643 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14644 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14645 case OVERLOAD
: return TS_CP_OVERLOAD
;
14646 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14647 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14648 case BASELINK
: return TS_CP_BASELINK
;
14649 case TEMPLATE_DECL
: return TS_CP_TEMPLATE_DECL
;
14650 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14651 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14652 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14653 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14654 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14655 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14656 default: return TS_CP_GENERIC
;
14660 /* Build the void_list_node (void_type_node having been created). */
14662 build_void_list_node (void)
14664 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14669 cp_missing_noreturn_ok_p (tree decl
)
14671 /* A missing noreturn is ok for the `main' function. */
14672 return DECL_MAIN_P (decl
);
14675 /* Return the decl used to identify the COMDAT group into which DECL should
14679 cxx_comdat_group (tree decl
)
14681 /* Virtual tables, construction virtual tables, and virtual table
14682 tables all go in a single COMDAT group, named after the primary
14684 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14685 decl
= CLASSTYPE_VTABLES (DECL_CONTEXT (decl
));
14686 /* For all other DECLs, the COMDAT group is the mangled name of the
14687 declaration itself. */
14690 while (DECL_THUNK_P (decl
))
14692 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14693 into the same section as the target function. In that case
14694 we must return target's name. */
14695 tree target
= THUNK_TARGET (decl
);
14696 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14697 && DECL_SECTION_NAME (target
) != NULL
14698 && DECL_ONE_ONLY (target
))
14708 /* Returns the return type for FN as written by the user, which may include
14709 a placeholder for a deduced return type. */
14712 fndecl_declared_return_type (tree fn
)
14714 fn
= STRIP_TEMPLATE (fn
);
14715 if (FNDECL_USED_AUTO (fn
))
14717 struct language_function
*f
= NULL
;
14718 if (DECL_STRUCT_FUNCTION (fn
))
14719 f
= DECL_STRUCT_FUNCTION (fn
)->language
;
14721 f
= DECL_SAVED_FUNCTION_DATA (fn
);
14722 return f
->x_auto_return_pattern
;
14724 return TREE_TYPE (TREE_TYPE (fn
));
14727 /* Returns true iff DECL was declared with an auto return type and it has
14728 not yet been deduced to a real type. */
14731 undeduced_auto_decl (tree decl
)
14733 if (cxx_dialect
< cxx14
)
14735 return type_uses_auto (TREE_TYPE (decl
));
14738 /* Complain if DECL has an undeduced return type. */
14741 require_deduced_type (tree decl
)
14743 if (undeduced_auto_decl (decl
))
14744 error ("use of %qD before deduction of %<auto%>", decl
);
14747 #include "gt-cp-decl.h"